@pascal-app/nodes 0.1.1

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

@@ -0,0 +1,10 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { PipeFittingNode } from './schema';
+/**
+ * DWV fittings — minted automatically by the pipe draw tool (corner
+ * joints → elbows, body taps → wyes on horizontal drains / sanitary
+ * tees on stacks), or click-placed via the tool (armed from the Build
+ * tab's DWV Pipe panel). Editable after the fact via the inspector.
+ */
+export declare const pipeFittingDefinition: NodeDefinition<typeof PipeFittingNode>;
+//# sourceMappingURL=definition.d.ts.map

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

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

package/dist/pipe-fitting/definition.js

@@ -0,0 +1,91 @@
+import { useScene } from '@pascal-app/core';
+import { getRotationAxis, rotateEulerWorld } from '../shared/fitting-rotation';
+import { buildPipeFittingFloorplan } from './floorplan';
+import { buildPipeFittingGeometry } from './geometry';
+import { pipeFittingParametrics } from './parametrics';
+import { getPipeFittingPorts } from './ports';
+import { PipeFittingNode } from './schema';
+/**
+ * DWV fittings — minted automatically by the pipe draw tool (corner
+ * joints → elbows, body taps → wyes on horizontal drains / sanitary
+ * tees on stacks), or click-placed via the tool (armed from the Build
+ * tab's DWV Pipe panel). Editable after the fact via the inspector.
+ */
+export const pipeFittingDefinition = {
+    kind: 'pipe-fitting',
+    schemaVersion: 1,
+    schema: PipeFittingNode,
+    category: 'utility',
+    distributionRole: 'fitting',
+    snapProfile: 'item',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        fittingType: 'elbow',
+        angle: 90,
+        diameter: 2,
+        diameter2: 2,
+        pipeMaterial: 'pvc',
+        system: 'waste',
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        movable: { axes: ['x', 'y', 'z'], gridSnap: true, cursorAttached: true },
+        duplicable: true,
+        deletable: true,
+    },
+    parametrics: pipeFittingParametrics,
+    geometry: buildPipeFittingGeometry,
+    geometryKey: (n) => JSON.stringify([n.fittingType, n.angle, n.diameter, n.diameter2, n.pipeMaterial, n.system]),
+    ports: getPipeFittingPorts,
+    floorplan: buildPipeFittingFloorplan,
+    // R/T rotate a selected fitting ±45° around the shared active axis —
+    // same scheme as duct fittings (the default editor rotate only knows
+    // Y; DWV stacks need X/Z). Alt-cycling lives in `./selection.tsx`.
+    keyboardActions: {
+        r: {
+            appliesTo: (node) => node.type === 'pipe-fitting',
+            run: (node) => useScene.getState().updateNode(node.id, {
+                rotation: rotateEulerWorld(node.rotation, getRotationAxis(), 1),
+            }),
+        },
+        t: {
+            appliesTo: (node) => node.type === 'pipe-fitting',
+            run: (node) => useScene.getState().updateNode(node.id, {
+                rotation: rotateEulerWorld(node.rotation, getRotationAxis(), -1),
+            }),
+        },
+        axisCycling: true,
+    },
+    // Alt-cycles the active rotation axis while a fitting is selected.
+    // Editor-only (drives `useEditor.rotationAxis`), so it mounts via the
+    // editor's SelectionAffordanceManager rather than `def.system`.
+    affordanceTools: {
+        selection: () => import('./selection'),
+        move: () => import('./move-tool'),
+    },
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Click', label: 'Place fitting' },
+        { key: 'Hover a pipe end', label: 'Snap onto the run' },
+        { key: 'R / T', label: 'Rotate ±45°' },
+        { key: 'Alt', label: 'Switch rotation axis (Y → X → Z)' },
+        { key: 'Esc', label: 'Exit' },
+    ],
+    presentation: {
+        label: 'Pipe Fitting',
+        description: 'DWV joint — elbow bend, 45° wye, or sanitary tee.',
+        // Reuses the duct-fitting artwork — DWV fittings read the same in the UI.
+        icon: { kind: 'url', src: '/icons/duct-fitting.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 96,
+        hidden: true,
+    },
+    mcp: {
+        description: 'A DWV pipe fitting (elbow, wye, or sanitary tee) with typed ports. Minted automatically at drain joints; position is level-local meters, rotation an XYZ euler.',
+    },
+};

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

@@ -0,0 +1,10 @@
+import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import type { PipeFittingNode } from './schema';
+/**
+ * Floor-plan symbol for a DWV fitting: one line per collar from the
+ * junction out (a wye's 45° branch reads at its true plan angle), plus
+ * a hub circle. Vertical collars (stack connections) collapse onto the
+ * hub, which is how they should read from above.
+ */
+export declare function buildPipeFittingFloorplan(node: PipeFittingNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

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

package/dist/pipe-fitting/floorplan.js

@@ -0,0 +1,50 @@
+import { INCHES_TO_METERS } from '../duct-segment/geometry';
+import { getPipeFittingPorts } from './ports';
+const WASTE_COLOR = '#57534e';
+const VENT_COLOR = '#78716c';
+/**
+ * Floor-plan symbol for a DWV fitting: one line per collar from the
+ * junction out (a wye's 45° branch reads at its true plan angle), plus
+ * a hub circle. Vertical collars (stack connections) collapse onto the
+ * hub, which is how they should read from above.
+ */
+export function buildPipeFittingFloorplan(node, ctx) {
+    const [cx, , cz] = node.position;
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const showSelectedChrome = (view?.selected || view?.highlighted) ?? false;
+    const stroke = showSelectedChrome && palette
+        ? palette.selectedStroke
+        : node.system === 'vent'
+            ? VENT_COLOR
+            : WASTE_COLOR;
+    const children = [];
+    for (const port of getPipeFittingPorts(node)) {
+        const px = port.position[0];
+        const pz = port.position[2];
+        if (Math.hypot(px - cx, pz - cz) < 1e-4)
+            continue;
+        children.push({
+            kind: 'line',
+            x1: cx,
+            y1: cz,
+            x2: px,
+            y2: pz,
+            stroke,
+            strokeWidth: port.diameter * INCHES_TO_METERS,
+            strokeLinecap: 'round',
+            opacity: showSelectedChrome ? 0.95 : 0.85,
+        });
+    }
+    children.push({
+        kind: 'circle',
+        cx,
+        cy: cz,
+        r: (node.diameter * INCHES_TO_METERS) / 2 + 0.012,
+        fill: stroke,
+        opacity: 0.95,
+    });
+    if (showSelectedChrome)
+        children.push({ kind: 'move-handle', point: [cx, cz] });
+    return { kind: 'group', children };
+}

package/dist/pipe-fitting/geometry.d.ts

@@ -0,0 +1,11 @@
+import { Group } from 'three';
+import type { PipeFittingNode } from './schema';
+/**
+ * Pure geometry builder for a DWV fitting, in the node's LOCAL frame.
+ * One cylinder stub per port from the junction outward, an oversized
+ * hub sphere at the junction, and a smaller hub at each collar opening
+ * (solvent-weld couplings). Wyes read correctly because their branch
+ * stub leaves at 45° — the port layout does the work.
+ */
+export declare function buildPipeFittingGeometry(node: PipeFittingNode): Group;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAiC,MAAM,OAAO,CAAA;AAI5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAI/C;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CA0BrE"}

package/dist/pipe-fitting/geometry.js

@@ -0,0 +1,31 @@
+import { Group, Mesh, SphereGeometry, Vector3 } from 'three';
+import { buildSection, INCHES_TO_METERS } from '../duct-segment/geometry';
+import { createPipeMaterial } from '../pipe-segment/geometry';
+import { localPipeFittingPorts } from './ports';
+const RADIAL_SEGMENTS = 20;
+/**
+ * Pure geometry builder for a DWV fitting, in the node's LOCAL frame.
+ * One cylinder stub per port from the junction outward, an oversized
+ * hub sphere at the junction, and a smaller hub at each collar opening
+ * (solvent-weld couplings). Wyes read correctly because their branch
+ * stub leaves at 45° — the port layout does the work.
+ */
+export function buildPipeFittingGeometry(node) {
+    const group = new Group();
+    const material = createPipeMaterial(node);
+    const radiusRun = (node.diameter * INCHES_TO_METERS) / 2;
+    for (const port of localPipeFittingPorts(node)) {
+        const radius = (port.diameter * INCHES_TO_METERS) / 2;
+        const stub = buildSection(new Vector3(0, 0, 0), port.position, radius, material, `pipe-fitting-stub-${port.id}`);
+        if (stub)
+            group.add(stub);
+        const hub = new Mesh(new SphereGeometry(radius * 1.18, RADIAL_SEGMENTS, 12), material);
+        hub.name = `pipe-fitting-hub-${port.id}`;
+        hub.position.copy(port.position);
+        group.add(hub);
+    }
+    const junction = new Mesh(new SphereGeometry(radiusRun * 1.18, RADIAL_SEGMENTS, 12), material);
+    junction.name = 'pipe-fitting-junction';
+    group.add(junction);
+    return group;
+}

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

@@ -0,0 +1,5 @@
+export { pipeFittingDefinition } from './definition';
+export { buildPipeFittingGeometry } from './geometry';
+export { getPipeFittingPorts } from './ports';
+export { PipeFittingNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/pipe-fitting/index.js

@@ -0,0 +1,4 @@
+export { pipeFittingDefinition } from './definition';
+export { buildPipeFittingGeometry } from './geometry';
+export { getPipeFittingPorts } from './ports';
+export { PipeFittingNode } from './schema';

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

@@ -0,0 +1,30 @@
+import { type AnyNode } from '@pascal-app/core';
+/**
+ * Ghost-preview duplicate / move tool for DWV pipe fittings (elbow / wye /
+ * sanitary tee) — the plumbing sibling of the duct-fitting move tool.
+ *
+ * **Duplicate** (`metadata.isNew`): pure drag-to-place — NOTHING is
+ * inserted into the scene until the commit click. A translucent copy of the
+ * fitting (built from its real geometry, at its own `rotation`, so an elbow
+ * / riser stays properly aligned) rides the cursor inside a footprint
+ * bounding box — the same affordance other items get — and Figma-style
+ * alignment guides snap the box edges to nearby geometry. The commit click
+ * calls `createNode`; Esc discards.
+ *
+ * **Move** (existing fitting): the real node is hidden while the ghost + box
+ * track the cursor; commit writes the new `position` and reveals it.
+ *
+ * Modifiers (mirroring the duct-fitting move):
+ * - **Alt** detaches: the connected-pipe follow drops so the fitting moves
+ *   on its own, leaving every mated run where it sits.
+ * - **Ctrl / Cmd** switches to vertical movement (stack / riser editing): XZ
+ *   holds and the cursor's screen-Y drives the riser height.
+ * - **Shift** bypasses grid snapping / alignment.
+ *
+ * Wired via `def.affordanceTools.move`.
+ */
+export declare const MovePipeFittingTool: React.FC<{
+    node: AnyNode;
+}>;
+export default MovePipeFittingTool;
+//# sourceMappingURL=move-tool.d.ts.map

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

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

package/dist/pipe-fitting/move-tool.js

@@ -0,0 +1,312 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, PipeFittingNode, sceneRegistry, useScene, } from '@pascal-app/core';
+import { DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useState } from 'react';
+import { Box3, Euler, MeshBasicMaterial, Vector3 } from 'three';
+import { collectGhostAlignmentCandidates, resolveGhostAlignment, } from '../shared/ghost-alignment';
+import { startRunMoveConnectivity } from '../shared/run-move-connectivity';
+import { buildPipeFittingGeometry } from './geometry';
+const GHOST_COLOR = '#818cf8';
+const GHOST_OPACITY = 0.5;
+/** Screen pixels → meters for the Ctrl-vertical (riser) drag — matches the
+ *  pipe draw tool's Alt-vertical feel. 100 px ≈ 1 m. */
+const VERTICAL_PIXELS_PER_METER = 100;
+const VERTICAL_Y_MIN_M = -3;
+const VERTICAL_Y_MAX_M = 10;
+/** 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;
+}
+/** World-space size + centre offset of `box` after the fitting's euler
+ *  rotation — the footprint box that wraps the oriented geometry. */
+function rotatedBounds(box, rotation) {
+    const euler = new Euler(rotation[0], rotation[1], rotation[2]);
+    const min = box.min;
+    const max = box.max;
+    const corners = [
+        [min.x, min.y, min.z],
+        [max.x, min.y, min.z],
+        [min.x, max.y, min.z],
+        [min.x, min.y, max.z],
+        [max.x, max.y, min.z],
+        [max.x, min.y, max.z],
+        [min.x, max.y, max.z],
+        [max.x, max.y, max.z],
+    ];
+    const lo = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+    const hi = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+    const v = new Vector3();
+    for (const c of corners) {
+        v.set(c[0], c[1], c[2]).applyEuler(euler);
+        lo[0] = Math.min(lo[0], v.x);
+        lo[1] = Math.min(lo[1], v.y);
+        lo[2] = Math.min(lo[2], v.z);
+        hi[0] = Math.max(hi[0], v.x);
+        hi[1] = Math.max(hi[1], v.y);
+        hi[2] = Math.max(hi[2], v.z);
+    }
+    return {
+        size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]],
+        offset: [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2],
+    };
+}
+/**
+ * Ghost-preview duplicate / move tool for DWV pipe fittings (elbow / wye /
+ * sanitary tee) — the plumbing sibling of the duct-fitting move tool.
+ *
+ * **Duplicate** (`metadata.isNew`): pure drag-to-place — NOTHING is
+ * inserted into the scene until the commit click. A translucent copy of the
+ * fitting (built from its real geometry, at its own `rotation`, so an elbow
+ * / riser stays properly aligned) rides the cursor inside a footprint
+ * bounding box — the same affordance other items get — and Figma-style
+ * alignment guides snap the box edges to nearby geometry. The commit click
+ * calls `createNode`; Esc discards.
+ *
+ * **Move** (existing fitting): the real node is hidden while the ghost + box
+ * track the cursor; commit writes the new `position` and reveals it.
+ *
+ * Modifiers (mirroring the duct-fitting move):
+ * - **Alt** detaches: the connected-pipe follow drops so the fitting moves
+ *   on its own, leaving every mated run where it sits.
+ * - **Ctrl / Cmd** switches to vertical movement (stack / riser editing): XZ
+ *   holds and the cursor's screen-Y drives the riser height.
+ * - **Shift** bypasses grid snapping / alignment.
+ *
+ * Wired via `def.affordanceTools.move`.
+ */
+export const MovePipeFittingTool = ({ node }) => {
+    const fitting = node;
+    const originalPosition = (fitting.position ?? [0, 0, 0]);
+    const rotation = (fitting.rotation ?? [0, 0, 0]);
+    const isNew = typeof node.metadata === 'object' &&
+        node.metadata !== null &&
+        !Array.isArray(node.metadata) &&
+        node.metadata.isNew === true;
+    const [cursorPos, setCursorPos] = useState(originalPosition);
+    // Translucent stand-in built from the fitting's real geometry. Rotation is
+    // a geometry input (it decides the elbow's profile roles), so the ghost
+    // matches what lands. Rebuilt only if the source changes.
+    const ghost = useMemo(() => {
+        const group = buildPipeFittingGeometry(fitting);
+        group.traverse((obj) => {
+            const mesh = obj;
+            if (mesh.isMesh) {
+                mesh.material = new MeshBasicMaterial({
+                    color: GHOST_COLOR,
+                    transparent: true,
+                    opacity: GHOST_OPACITY,
+                    depthTest: false,
+                });
+                mesh.renderOrder = 999;
+            }
+            obj.layers.set(EDITOR_LAYER);
+        });
+        return group;
+    }, [fitting]);
+    // Footprint box that wraps the oriented geometry (size + centre offset),
+    // measured once from the ghost.
+    const bounds = useMemo(() => {
+        const box = new Box3().setFromObject(ghost);
+        if (box.isEmpty())
+            return { size: [0.3, 0.3, 0.3], offset: [0, 0, 0] };
+        return rotatedBounds(box, rotation);
+    }, [ghost, rotation]);
+    useEffect(() => {
+        return () => {
+            ghost.traverse((obj) => {
+                const mesh = obj;
+                if (mesh.isMesh) {
+                    mesh.geometry?.dispose?.();
+                    const mat = mesh.material;
+                    if (Array.isArray(mat))
+                        for (const m of mat)
+                            m.dispose?.();
+                    else
+                        mat?.dispose?.();
+                }
+            });
+        };
+    }, [ghost]);
+    useEffect(() => {
+        const nodeId = node.id;
+        const [hx, , hz] = [bounds.size[0] / 2, 0, bounds.size[2] / 2];
+        const [ox, , oz] = bounds.offset;
+        useScene.temporal.getState().pause();
+        let committed = false;
+        let hasMoved = false;
+        const activatedAt = Date.now();
+        const candidates = collectGhostAlignmentCandidates(useScene.getState().nodes, nodeId, useViewer.getState().selection.levelId ?? node.parentId);
+        // Moving an existing fitting: hide its 3D MESH imperatively (NOT the
+        // store `visible` flag — the 2D floor plan skips `visible:false` nodes,
+        // so a store hide makes it 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 pipes as the fitting slides: the part of the move along
+        // a run's axis stretches it, the part across translates the whole run (and
+        // propagates to its far joint). Snapshot once at drag start; only existing
+        // fittings are mated to anything.
+        const connectivity = existedAtStart
+            ? startRunMoveConnectivity(node)
+            : null;
+        let lastPos = originalPosition;
+        // Tracks whether the last frame held Alt: the fitting is detached from its
+        // connected pipes for the drag, so they stay put (no follow) and the
+        // commit omits their updates. Mirrors the pipe endpoint's Alt-detach.
+        let lastDetached = false;
+        // Anchor for the Ctrl-vertical (riser) drag: clientY + base Y captured the
+        // frame Ctrl is first held, so vertical mouse motion maps to Y. Cleared
+        // when Ctrl is released. Mirrors the draw tool's Alt-vertical anchor.
+        let verticalAnchor = null;
+        const onMove = (event) => {
+            const bypass = event.nativeEvent?.shiftKey === true;
+            // Alt = detach: drop the connected-pipe follow so the fitting moves on
+            // its own, leaving every mated run where it sits.
+            const detached = event.nativeEvent?.altKey === true;
+            // Ctrl/Cmd = vertical: XZ locks to where the fitting sits and the cursor's
+            // screen-Y drives the riser height (connected pipes still follow).
+            const vertical = event.nativeEvent?.ctrlKey === true || event.nativeEvent?.metaKey === true;
+            const clientY = event.nativeEvent?.clientY;
+            const snap = bypass ? (v) => v : snapToGridStep;
+            let next;
+            if (vertical && typeof clientY === 'number') {
+                if (!verticalAnchor)
+                    verticalAnchor = { clientY, baseY: lastPos[1] };
+                // Screen +Y points down, so subtract to map "drag up = raise".
+                const dy = (verticalAnchor.clientY - clientY) / VERTICAL_PIXELS_PER_METER;
+                const y = Math.min(VERTICAL_Y_MAX_M, Math.max(VERTICAL_Y_MIN_M, verticalAnchor.baseY + snap(dy)));
+                next = [lastPos[0], y, lastPos[2]];
+                useAlignmentGuides.getState().clear();
+            }
+            else {
+                verticalAnchor = null;
+                let x = snap(event.localPosition[0]);
+                let z = snap(event.localPosition[2]);
+                // Alignment: snap the footprint box edges onto nearby geometry and
+                // publish guides (Alt / Shift bypass). Guides are DISPLAYED in every
+                // snapping mode (isAlignmentGuideActive); the magnetic pull toward them
+                // applies only in 'lines' mode (isMagneticSnapActive).
+                if (!bypass && isAlignmentGuideActive()) {
+                    const proposed = {
+                        minX: x + ox - hx,
+                        maxX: x + ox + hx,
+                        minZ: z + oz - hz,
+                        maxZ: z + oz + hz,
+                    };
+                    const { dx, dz, guides } = resolveGhostAlignment(nodeId, proposed, candidates);
+                    if (isMagneticSnapActive()) {
+                        x += dx;
+                        z += dz;
+                    }
+                    useAlignmentGuides.getState().set(guides);
+                }
+                else {
+                    useAlignmentGuides.getState().clear();
+                }
+                next = [x, lastPos[1], z];
+            }
+            if (next[0] !== lastPos[0] || next[1] !== lastPos[1] || next[2] !== lastPos[2]) {
+                triggerSFX('sfx:grid-snap');
+            }
+            lastPos = next;
+            lastDetached = detached;
+            hasMoved = true;
+            setCursorPos(next);
+            // Detached: keep the followers at their origin (drop any live overrides
+            // from a prior non-detached frame). Otherwise preview the follow.
+            if (detached)
+                connectivity?.clear();
+            else
+                connectivity?.preview({ position: next });
+        };
+        const commit = (event) => {
+            if (committed)
+                return;
+            if (Date.now() - activatedAt < 150) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            if (!hasMoved) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            committed = true;
+            useScene.temporal.getState().resume();
+            let selectId = nodeId;
+            if (isNew && !useScene.getState().nodes[nodeId]) {
+                const created = PipeFittingNode.parse({
+                    ...node,
+                    position: lastPos,
+                    metadata: stripPlacementMetadataFlags(node.metadata),
+                    visible: true,
+                });
+                useScene.getState().createNode(created, node.parentId);
+                selectId = created.id;
+            }
+            else {
+                // Fold connected-pipe / sibling-run follow-updates into the SAME batch
+                // as the moved fitting so the whole joint is one undo step. Detached
+                // (Alt on the final frame): the joint is broken, so nothing follows.
+                const followUpdates = lastDetached
+                    ? []
+                    : (connectivity?.commitUpdates({ position: lastPos }) ?? []);
+                useScene
+                    .getState()
+                    .updateNodes([
+                    { id: nodeId, data: { position: lastPos } },
+                    ...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();
+        };
+    }, [bounds, isNew, node, originalPosition]);
+    return (_jsxs("group", { children: [_jsx("primitive", { object: ghost, position: cursorPos, rotation: rotation }), _jsx(DragBoundingBox, { centerY: bounds.offset[1], nodeId: node.id, position: [cursorPos[0] + bounds.offset[0], cursorPos[1], cursorPos[2] + bounds.offset[2]], size: bounds.size })] }));
+};
+export default MovePipeFittingTool;

package/dist/pipe-fitting/parametrics.d.ts

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

package/dist/pipe-fitting/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,oBAAoB,EAAmB,MAAM,kBAAkB,CAAA;AAEjG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAkC/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CA0ExE,CAAA"}