@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/pipe-fitting/selection.js

@@ -1,13 +1,15 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { analyzePortConnectivity, pauseSceneHistory, resolveConnectivityUpdates, resumeSceneHistory, sceneRegistry, useScene, } from '@pascal-app/core';
-import { ARROW_COLOR, EDITOR_LAYER, isTypingTarget, swallowNextClick, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { ARROW_COLOR, AXIS_MOVE_DRAG_LABEL, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, isTypingTarget, ROTATE_HANDLE_DRAG_LABEL, swallowNextClick, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { createPortal, useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useState } from 'react';
 import { BufferGeometry, Euler, Float32BufferAttribute, LineSegments, OrthographicCamera, Plane, Quaternion, Raycaster, SphereGeometry, Vector2, Vector3, } from 'three';
 import { LineBasicNodeMaterial, MeshBasicNodeMaterial } from 'three/webgpu';
 import { AXIS_VECTORS, cycleRotationAxis, ROTATE_STEP_RAD, } from '../shared/fitting-rotation.js';
+import { createFollowerFrames } from '../shared/follower-frames.js';
+import { useHandleDragScope } from '../shared/handle-drag-scope.js';
 import { HandleCube, MoveChevron, RotateArc } from '../shared/selection-handles.js';
 import { pipeFittingLegLength } from './ports.js';
 const ARROW_GAP = 0.34;
@@ -164,6 +166,9 @@ const PipeFittingSelectionAffordance = () => {
             if (isTypingTarget(e.target))
                 return;
             e.preventDefault();
+            // Mid-drag, Alt is the turn's free-rotation modifier, not an axis switch.
+            if (useViewer.getState().inputDragging)
+                return;
             cycleRotationAxis();
         };
         window.addEventListener('keydown', onKeyDown);
@@ -197,6 +202,7 @@ const FittingHandles = ({ fitting }) => {
     const [open, setOpen] = useState(false);
     const [dragging, setDragging] = useState(false);
     const [sideSign, setSideSign] = useState(1);
+    const claimHandleDrag = useHandleDragScope();
     const makeRay = (clientX, clientY) => {
         const rect = gl.domElement.getBoundingClientRect();
         const ndc = new Vector2(((clientX - rect.left) / rect.width) * 2 - 1, -((clientY - rect.top) / rect.height) * 2 + 1);
@@ -239,12 +245,16 @@ const FittingHandles = ({ fitting }) => {
         const local = frame.worldToLocal(hit.clone());
         return axis === 'x' ? local.x : local.z;
     };
+    /** Null when the mated joints cannot follow the transform. */
     const connectivityUpdates = (connectivity, transform) => {
         if (!connectivity)
             return [];
         const preview = { ...fitting, ...transform };
         const nodes = useScene.getState().nodes;
-        return resolveConnectivityUpdates(connectivity, preview)
+        const updates = resolveConnectivityUpdates(connectivity, preview);
+        if (!updates)
+            return null;
+        return updates
             .filter((u) => nodes[u.id])
             .map((u) => {
             const node = nodes[u.id];
@@ -256,42 +266,55 @@ const FittingHandles = ({ fitting }) => {
             };
         });
     };
-    const beginDrag = (cursor, makeCompute) => (e) => {
+    const beginDrag = (handle, cursor, makeCompute) => (e) => {
         e.stopPropagation();
         const initialPosition = [...fitting.position];
         const initialRotation = [...fitting.rotation];
-        const connectivity = analyzePortConnectivity(fitting, useScene.getState().nodes);
+        const startNodes = useScene.getState().nodes;
+        const connectivity = analyzePortConnectivity(fitting, startNodes);
+        const followerFrame = createFollowerFrames(startNodes, fitting.id);
         const compute = makeCompute(e);
         pauseSceneHistory(useScene);
         useViewer.getState().setInputDragging(true);
         setDragging(true);
         document.body.style.cursor = cursor;
+        const releaseScope = claimHandleDrag(fitting.id, handle, () => {
+            swallowNextClick();
+            finish(false);
+        });
         let current = null;
-        const buildBatch = (t) => [
-            {
-                id: fitting.id,
-                data: preserveFittingParameters(fitting, t),
-            },
-            ...connectivityUpdates(connectivity, t),
-        ];
+        const buildBatch = (t) => {
+            const followers = connectivityUpdates(connectivity, t);
+            return (followers && [
+                {
+                    id: fitting.id,
+                    data: preserveFittingParameters(fitting, t),
+                },
+                ...followers,
+            ]);
+        };
         const onMove = (event) => {
             const next = compute(event);
             if (!next)
                 return;
+            // Joints that cannot follow hold the last frame, which release commits.
+            const batch = buildBatch(next);
+            if (!batch)
+                return;
             current = next;
-            useScene.getState().updateNodes(buildBatch(next));
+            useScene.getState().updateNodes(followerFrame(batch));
         };
         const cleanup = () => {
             window.removeEventListener('pointermove', onMove);
             window.removeEventListener('pointerup', onUp);
-            window.removeEventListener('pointercancel', onUp);
+            window.removeEventListener('pointercancel', onCancel);
+            releaseScope();
             useViewer.getState().setInputDragging(false);
             setDragging(false);
             if (document.body.style.cursor === cursor)
                 document.body.style.cursor = '';
         };
-        const onUp = () => {
-            swallowNextClick();
+        const finish = (commit) => {
             cleanup();
             const reverts = (connectivity?.connections ?? []).map((conn) => {
                 if (conn.kind !== 'rigid-node') {
@@ -318,12 +341,20 @@ const FittingHandles = ({ fitting }) => {
                 ...reverts.filter((u) => useScene.getState().nodes[u.id]),
             ]);
             resumeSceneHistory(useScene);
-            if (current)
-                useScene.getState().updateNodes(buildBatch(current));
+            if (!commit)
+                return;
+            const batch = current && buildBatch(current);
+            if (batch)
+                useScene.getState().updateNodes(batch);
+        };
+        const onUp = () => {
+            swallowNextClick();
+            finish(true);
         };
+        const onCancel = () => finish(false);
         window.addEventListener('pointermove', onMove);
         window.addEventListener('pointerup', onUp);
-        window.addEventListener('pointercancel', onUp);
+        window.addEventListener('pointercancel', onCancel);
     };
     const moveCompute = (axis) => (e) => {
         const anchorWorld = toWorld(fitting.position);
@@ -337,7 +368,7 @@ const FittingHandles = ({ fitting }) => {
             const s = sampleAxis(axis, event.clientX, event.clientY, anchorWorld);
             if (s === null)
                 return null;
-            const step = event.shiftKey ? 0 : useEditor.getState().gridSnapStep;
+            const step = !event.altKey && isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
             const delta = snap(s - start, step);
             if (delta === lastDelta)
                 return null;
@@ -376,8 +407,9 @@ const FittingHandles = ({ fitting }) => {
             if (b === null)
                 return null;
             const raw = b - startBearing;
-            const delta = event.shiftKey ? raw : Math.round(raw / ROTATE_STEP_RAD) * ROTATE_STEP_RAD;
-            if (!event.shiftKey) {
+            const snapped = !event.altKey && isAngleSnapActive();
+            const delta = snapped ? Math.round(raw / ROTATE_STEP_RAD) * ROTATE_STEP_RAD : raw;
+            if (snapped) {
                 const step = Math.round(raw / ROTATE_STEP_RAD);
                 if (step !== lastStep) {
                     lastStep = step;
@@ -400,6 +432,10 @@ const FittingHandles = ({ fitting }) => {
         useViewer.getState().setInputDragging(true);
         setDragging(true);
         document.body.style.cursor = cursor;
+        const releaseScope = claimHandleDrag(fitting.id, `resize-${dimension}`, () => {
+            swallowNextClick();
+            finish(false);
+        });
         let current = null;
         let lastValue = Number.NaN;
         const apply = (patch) => {
@@ -414,35 +450,43 @@ const FittingHandles = ({ fitting }) => {
             const rawDeltaM = sampleAxisParameter(event.clientX, event.clientY, centerWorld, axisWorld) - start;
             const deltaIn = (rawDeltaM / INCHES_TO_METERS) * 2;
             const nextRaw = baseValue + deltaIn;
-            const nextValue = clamp(event.shiftKey ? nextRaw : snap(nextRaw, RESIZE_STEP_IN), 1.25, 8);
+            // A size has no alignment lines to pull to, so either snapping mode
+            // steps it; held Alt sizes freely.
+            const snapped = !event.altKey && (isGridSnapActive() || isMagneticSnapActive());
+            const nextValue = clamp(snapped ? snap(nextRaw, RESIZE_STEP_IN) : nextRaw, 1.25, 8);
             if (nextValue === lastValue)
                 return;
             lastValue = nextValue;
             current = dimensionPatch(fitting, dimension, nextValue);
-            if (!event.shiftKey)
+            if (snapped)
                 triggerSFX('sfx:grid-snap');
             apply(current);
         };
         const cleanup = () => {
             window.removeEventListener('pointermove', onMove);
             window.removeEventListener('pointerup', onUp);
-            window.removeEventListener('pointercancel', onUp);
+            window.removeEventListener('pointercancel', onCancel);
+            releaseScope();
             useViewer.getState().setInputDragging(false);
             setDragging(false);
             if (document.body.style.cursor === cursor)
                 document.body.style.cursor = '';
         };
-        const onUp = () => {
-            swallowNextClick();
+        const finish = (commit) => {
             cleanup();
             apply(initialPatch);
             resumeSceneHistory(useScene);
-            if (current)
+            if (commit && current)
                 apply(current);
         };
+        const onUp = () => {
+            swallowNextClick();
+            finish(true);
+        };
+        const onCancel = () => finish(false);
         window.addEventListener('pointermove', onMove);
         window.addEventListener('pointerup', onUp);
-        window.addEventListener('pointercancel', onUp);
+        window.addEventListener('pointercancel', onCancel);
     };
     const extent = useMemo(() => fittingExtentM(fitting), [fitting]);
     const p = fitting.position;
@@ -573,6 +617,6 @@ const FittingHandles = ({ fitting }) => {
     if (dragging)
         return _jsx("group", { ref: setFrame });
     return (_jsxs("group", { ref: setFrame, children: [_jsx(HandleCube, { active: open, onClick: () => setOpen((o) => !o), position: p }), !open &&
-                resizeHandles.map((handle) => (_jsxs("group", { children: [_jsx(DashedResizeGuide, { from: handle.guideFrom, to: handle.guideTo }), _jsx(ResizeSphereHandle, { cursor: handle.cursor, onPointerDown: beginDimensionDrag(handle.key, handle.axis, handle.cursor), position: handle.position })] }, handle.key))), open && (_jsxs(_Fragment, { children: [moveArrows.map((a) => (_jsx(MoveChevron, { cursor: a.cursor, onPointerDown: beginDrag(a.axis === 'y' ? 'ns-resize' : 'grabbing', moveCompute(a.axis)), position: a.position, rotationY: a.rotationY, vertical: a.vertical }, a.key))), rotateArcs.map((arc) => (_jsx(RotateArc, { onPointerDown: beginDrag('grabbing', rotateCompute(arc.axis)), position: arc.position, rotation: arc.rotation }, arc.key)))] }))] }));
+                resizeHandles.map((handle) => (_jsxs("group", { children: [_jsx(DashedResizeGuide, { from: handle.guideFrom, to: handle.guideTo }), _jsx(ResizeSphereHandle, { cursor: handle.cursor, onPointerDown: beginDimensionDrag(handle.key, handle.axis, handle.cursor), position: handle.position })] }, handle.key))), open && (_jsxs(_Fragment, { children: [moveArrows.map((a) => (_jsx(MoveChevron, { cursor: a.cursor, onPointerDown: beginDrag(AXIS_MOVE_DRAG_LABEL, a.axis === 'y' ? 'ns-resize' : 'grabbing', moveCompute(a.axis)), position: a.position, rotationY: a.rotationY, vertical: a.vertical }, a.key))), rotateArcs.map((arc) => (_jsx(RotateArc, { onPointerDown: beginDrag(ROTATE_HANDLE_DRAG_LABEL, 'grabbing', rotateCompute(arc.axis)), position: arc.position, rotation: arc.rotation }, arc.key)))] }))] }));
 };
 export default PipeFittingSelectionAffordance;

package/dist/pipe-segment/collar-connection.d.ts

@@ -0,0 +1,12 @@
+import { type AnyNode, PipeFittingNode } from '@pascal-app/core';
+import type { ScenePort } from '@pascal-app/editor/distribution';
+type Point = [number, number, number];
+export declare function pipeCollar(nodes: Readonly<Record<string, AnyNode>>, nodeId: string, portId: string): ScenePort | null;
+export declare function pipeCollarOccupied(nodes: Readonly<Record<string, AnyNode>>, port: ScenePort): boolean;
+/** Fixed collars cannot be trimmed like pipe endpoints; leave straight along their axis. */
+export declare function planPipeCollarConnection(nodes: Readonly<Record<string, AnyNode>>, source: ScenePort, toward: Point, diameter: number, system: string, material: PipeFittingNode['pipeMaterial']): {
+    point: Point;
+    fittings: PipeFittingNode[];
+};
+export {};
+//# sourceMappingURL=collar-connection.d.ts.map

package/dist/pipe-segment/collar-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collar-connection.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/collar-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAgB,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAG9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAIhE,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AACrC,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,SAAS,GAAG,IAAI,CAWlB;AACD,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,EAAE,SAAS,GACd,OAAO,CAYT;AAED,4FAA4F;AAC5F,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,KAAK,EACb,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,eAAe,CAAC,cAAc,CAAC;WAoBD,KAAK;cAAkB,eAAe,EAAE;EAqBjF"}

package/dist/pipe-segment/collar-connection.js

@@ -0,0 +1,58 @@
+import { nodeRegistry, PipeFittingNode } from '@pascal-app/core';
+import { refuse } from '@pascal-app/core/agent-tools';
+import { queryNodes } from '@pascal-app/core/runtime';
+import { Euler, Quaternion, Vector3 } from 'three';
+import { pipeFittingLegLength } from '../pipe-fitting/ports.js';
+export function pipeCollar(nodes, nodeId, portId) {
+    const node = nodes[nodeId];
+    const port = node &&
+        nodeRegistry
+            .get(node.type)
+            ?.ports?.(node)
+            .find((port) => port.id === portId);
+    return port && (port.system === 'waste' || port.system === 'vent')
+        ? { ...port, nodeId: node.id }
+        : null;
+}
+export function pipeCollarOccupied(nodes, port) {
+    const owner = nodes[port.nodeId];
+    if (!owner)
+        return false;
+    return queryNodes(nodes, { parentId: owner.parentId }).some((node) => node.id !== port.nodeId &&
+        (nodeRegistry.get(node.type)?.ports?.(node) ?? []).some((other) => other.system === port.system &&
+            new Vector3(...other.position).distanceTo(new Vector3(...port.position)) < 0.005));
+}
+/** Fixed collars cannot be trimmed like pipe endpoints; leave straight along their axis. */
+export function planPipeCollarConnection(nodes, source, toward, diameter, system, material) {
+    const port = pipeCollar(nodes, source.nodeId, source.id);
+    if (!port || new Vector3(...port.position).distanceTo(new Vector3(...source.position)) > 1e-6)
+        return refuse('pipe_collar_changed', 'The connection moved or disappeared. Select the collar again.');
+    if (port.system !== system)
+        return refuse('pipe_collar_system', 'Use the same waste or vent system as the collar.');
+    if (pipeCollarOccupied(nodes, port))
+        return refuse('pipe_collar_occupied', 'This collar is already connected.');
+    const axis = new Vector3(...port.direction).normalize();
+    const travel = new Vector3(...toward).sub(new Vector3(...port.position));
+    if (travel.length() < 0.05 || axis.dot(travel.clone().normalize()) < 0.999999)
+        return refuse('pipe_collar_direction', 'Draw the first section straight out of the collar, then add a bend from the new pipe endpoint.');
+    if (diameter === port.diameter)
+        return { point: [...port.position], fittings: [] };
+    const leg = pipeFittingLegLength(Math.max(diameter, port.diameter));
+    if (travel.length() < 2 * leg + 0.05)
+        return refuse('pipe_collar_space', 'Lengthen the pipe to leave room for the reducer.');
+    const rotation = new Euler().setFromQuaternion(new Quaternion().setFromUnitVectors(new Vector3(1, 0, 0), axis));
+    const fitting = PipeFittingNode.parse({
+        parentId: nodes[source.nodeId].parentId,
+        fittingType: 'reducer',
+        diameter: port.diameter,
+        diameter2: diameter,
+        system: port.system,
+        pipeMaterial: material,
+        position: new Vector3(...port.position).addScaledVector(axis, leg).toArray(),
+        rotation: [rotation.x, rotation.y, rotation.z],
+    });
+    return {
+        point: new Vector3(...port.position).addScaledVector(axis, 2 * leg).toArray(),
+        fittings: [fitting],
+    };
+}

package/dist/pipe-segment/connect-operation.d.ts

@@ -0,0 +1,9 @@
+import type { AgentOperation } from '@pascal-app/core/agent-operations';
+export type PipeConnectInput = {
+    nodeId: string;
+    portId: string;
+    end: [number, number, number];
+    diameter?: number;
+};
+export declare const connectPipe: AgentOperation<PipeConnectInput>;
+//# sourceMappingURL=connect-operation.d.ts.map

package/dist/pipe-segment/connect-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-operation.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/connect-operation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAA;AAMvE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AACD,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,gBAAgB,CAuDxD,CAAA"}

package/dist/pipe-segment/connect-operation.js

@@ -0,0 +1,44 @@
+import { nodeRegistry, PipeSegmentNode } from '@pascal-app/core';
+import { refuse } from '@pascal-app/core/agent-tools';
+import { queryNodes } from '@pascal-app/core/runtime';
+import { createPipeRunEndCap } from '../shared/automatic-run-end-cap.js';
+import { pipeCollar, planPipeCollarConnection } from './collar-connection.js';
+export const connectPipe = (nodes, input) => {
+    const owner = nodes[input.nodeId];
+    const port = pipeCollar(nodes, input.nodeId, input.portId);
+    if (!owner || !port || owner.type === 'pipe-segment')
+        return refuse('pipe_collar_missing', 'Choose a fixture, trap or fitting waste/vent collar.');
+    if (!input.end.every(Number.isFinite))
+        return refuse('pipe_endpoint_invalid', 'Enter a finite endpoint.');
+    const diameter = input.diameter ?? port.diameter;
+    const parsed = PipeSegmentNode.safeParse({
+        parentId: owner.parentId,
+        path: [[...port.position], input.end],
+        diameter,
+        system: port.system,
+        pipeMaterial: 'pipeMaterial' in owner ? owner.pipeMaterial : 'pvc',
+    });
+    if (!parsed.success)
+        return refuse('pipe_size_invalid', 'Use a supported pipe diameter between 1.25 and 8 inches.');
+    const pipe = parsed.data;
+    const plan = planPipeCollarConnection(nodes, port, input.end, diameter, pipe.system, pipe.pipeMaterial);
+    // An endpoint at another collar must use the draw tool's two-ended connection planning.
+    if (queryNodes(nodes, { parentId: owner.parentId }).some((node) => (nodeRegistry.get(node.type)?.ports?.(node) ?? []).some((other) => other.system === port.system &&
+        Math.hypot(...other.position.map((v, i) => v - input.end[i])) < 0.005)))
+        return refuse('pipe_endpoint_occupied', 'Choose a free endpoint; use pipe drawing to join an existing collar.');
+    pipe.path = [plan.point, input.end];
+    const cap = createPipeRunEndCap(pipe);
+    return {
+        result: {
+            message: 'Pipe connected; source collar remains fixed.',
+            pipeId: pipe.id,
+            reducers: plan.fittings.length,
+        },
+        changes: {
+            create: [pipe, ...plan.fittings, cap].map((node) => ({
+                node,
+                parentId: owner.parentId ?? undefined,
+            })),
+        },
+    };
+};

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

@@ -1,8 +1,8 @@
-import { type AnyNode, type AnyNodeId, type FloorplanAffordance } from '@pascal-app/core';
+import { type AnyNode, type AnyNodeId, type FloorplanAffordance, type NodePort } from '@pascal-app/core';
 import type { RunBodyHit, ScenePort } from '@pascal-app/editor/distribution';
 import type { PipeFittingNode } from '../pipe-fitting/schema.js';
 import { type RunContinuationHandlePlan } from '../shared/elbow-branch-continuation.js';
-import type { PipeSegmentNode } from './schema.js';
+import { PipeSegmentNode } from './schema.js';
 export type PipeEndpoint = 'start' | 'end';
 export type PipeContinuationSeed = {
     pipe: PipeSegmentNode;
@@ -16,6 +16,7 @@ export declare function pipeContinuationHandlePlan(pipe: PipeSegmentNode, endpoi
 export declare function resolvePipeContinuationSeed(defaults: unknown, nodes: Record<string, AnyNode>): PipeContinuationSeed | null;
 export declare function activatePipeBranch(pipe: PipeSegmentNode, segmentIndex: number, point: [number, number, number]): void;
 export declare function activatePipeContinuation(pipe: PipeSegmentNode, endpoint: PipeEndpoint, fittingId?: AnyNodeId): void;
+export declare function activatePipeCollarContinuation(node: AnyNode, port: NodePort): void;
 export declare const pipeContinuationAffordance: FloorplanAffordance<PipeSegmentNode>;
 export declare const pipeBranchAffordance: FloorplanAffordance<PipeSegmentNode>;
 export declare function currentPipeContinuationSeed(): PipeContinuationSeed | null;

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

@@ -1 +1 @@
-{"version":3,"file":"continuation.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/continuation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,mBAAmB,EAAY,MAAM,kBAAkB,CAAA;AAEnG,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAE5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAIL,KAAK,yBAAyB,EAE/B,MAAM,qCAAqC,CAAA;AAC5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,KAAK,CAAA;AAE1C,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,eAAe,CAAA;IACrB,IAAI,EAAE,SAAS,GAAG,IAAI,CAAA;IACtB,IAAI,EAAE,UAAU,GAAG,IAAI,CAAA;IACvB,eAAe,CAAC,EAAE,eAAe,CAAA;CAClC,CAAA;AAYD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,CAkBhG;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,GAAG,SAAO,GACT,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAQjC;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,GAAG,SAAO,GACT,yBAAyB,GAAG,IAAI,CAGlC;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,oBAAoB,GAAG,IAAI,CAiD7B;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,eAAe,EACrB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAC9B,IAAI,CAQN;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,SAAS,CAAC,EAAE,SAAS,GACpB,IAAI,CAQN;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,eAAe,CAiB3E,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,eAAe,CAiBrE,CAAA;AAED,wBAAgB,2BAA2B,IAAI,oBAAoB,GAAG,IAAI,CAKzE"}
+{"version":3,"file":"continuation.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/continuation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAE5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAIL,KAAK,yBAAyB,EAE/B,MAAM,qCAAqC,CAAA;AAE5C,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAG1C,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,KAAK,CAAA;AAE1C,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,eAAe,CAAA;IACrB,IAAI,EAAE,SAAS,GAAG,IAAI,CAAA;IACtB,IAAI,EAAE,UAAU,GAAG,IAAI,CAAA;IACvB,eAAe,CAAC,EAAE,eAAe,CAAA;CAClC,CAAA;AAaD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,CAkBhG;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,GAAG,SAAO,GACT,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAQjC;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,GAAG,SAAO,GACT,yBAAyB,GAAG,IAAI,CAGlC;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,oBAAoB,GAAG,IAAI,CA8D7B;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,eAAe,EACrB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAC9B,IAAI,CAWN;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,SAAS,CAAC,EAAE,SAAS,GACpB,IAAI,CAuBN;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,CAwBlF;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,eAAe,CAiB3E,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,eAAe,CAiBrE,CAAA;AAED,wBAAgB,2BAA2B,IAAI,oBAAoB,GAAG,IAAI,CAKzE"}

package/dist/pipe-segment/continuation.js

@@ -1,7 +1,10 @@
-import { useScene } from '@pascal-app/core';
+import { useScene, } from '@pascal-app/core';
 import { useEditor } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { findMatedScenePorts, planPipeElbowBranchPromotion, planPipeTeeCrossPromotion, resolvePipeContinuationHandle, } from '../shared/elbow-branch-continuation.js';
+import { pipeCollar, pipeCollarOccupied } from './collar-connection.js';
+import { PipeSegmentNode } from './schema.js';
+import { pipeGrade } from './slope.js';
 export function pipeEndpointPort(pipe, endpoint) {
     if (pipe.path.length < 2)
         return null;
@@ -38,6 +41,20 @@ export function pipeContinuationHandlePlan(pipe, endpoint, nodes, gap = 0.28) {
 }
 export function resolvePipeContinuationSeed(defaults, nodes) {
     const continuation = defaults?.continuation;
+    if (typeof continuation?.nodeId === 'string' && typeof continuation.portId === 'string') {
+        const source = nodes[continuation.nodeId];
+        const port = pipeCollar(nodes, continuation.nodeId, continuation.portId);
+        if (!source || !port || pipeCollarOccupied(nodes, port))
+            return null;
+        const profile = PipeSegmentNode.safeParse({
+            parentId: source.parentId,
+            diameter: port.diameter,
+            system: port.system,
+            pipeMaterial: 'pipeMaterial' in source ? source.pipeMaterial : 'pvc',
+            path: [[...port.position], port.position.map((value, i) => value + port.direction[i])],
+        });
+        return profile.success ? { pipe: profile.data, port, body: null } : null;
+    }
     const endpoint = continuation?.endpoint;
     const nodeId = continuation?.nodeId;
     if (endpoint === 'branch' && typeof nodeId === 'string') {
@@ -92,6 +109,9 @@ export function activatePipeBranch(pipe, segmentIndex, point) {
         return;
     const editor = useEditor.getState();
     editor.setToolDefaults('pipe-segment', {
+        ...editor.toolDefaults['pipe-segment'],
+        routingMode: 'surface',
+        crossingMode: 'connect',
         continuation: { nodeId: pipe.id, endpoint: 'branch', segmentIndex, point },
     });
     useViewer.getState().setSelection({ selectedIds: [] });
@@ -102,7 +122,46 @@ export function activatePipeContinuation(pipe, endpoint, fittingId) {
         return;
     const editor = useEditor.getState();
     editor.setToolDefaults('pipe-segment', {
+        ...editor.toolDefaults['pipe-segment'],
+        routingMode: 'surface',
+        crossingMode: 'connect',
         continuation: { nodeId: pipe.id, endpoint, ...(fittingId ? { fittingId } : {}) },
+        ...(() => {
+            const a = endpoint === 'end' ? pipe.path.at(-2) : pipe.path[1];
+            const b = endpoint === 'end' ? pipe.path.at(-1) : pipe.path[0];
+            const grade = pipeGrade(a, b);
+            return grade === null
+                ? { fall: 'level' }
+                : {
+                    fall: Math.abs(grade) > 1e-6 ? 'sloped' : 'level',
+                    gradePercent: Math.abs(grade) * 100,
+                    flowDirection: grade < 0 ? 'reverse' : 'forward',
+                };
+        })(),
+    });
+    useViewer.getState().setSelection({ selectedIds: [] });
+    editor.setTool('pipe-segment');
+}
+export function activatePipeCollarContinuation(node, port) {
+    const editor = useEditor.getState();
+    editor.setToolDefaults('pipe-segment', {
+        ...editor.toolDefaults['pipe-segment'],
+        continuation: { nodeId: node.id, portId: port.id },
+        diameter: port.diameter,
+        system: port.system,
+        pipeMaterial: 'pipeMaterial' in node ? node.pipeMaterial : 'pvc',
+        elevation: port.position[1],
+        routingMode: Math.hypot(port.direction[0], port.direction[2]) < 1e-6 ? 'vertical' : 'horizontal',
+        targetElevation: port.position[1] + Math.sign(port.direction[1] || 1),
+        ...(() => {
+            const grade = pipeGrade([0, 0, 0], [...port.direction]) ?? 0;
+            return {
+                fall: Math.abs(grade) > 1e-6 ? 'sloped' : 'level',
+                gradePercent: Math.abs(grade) * 100,
+                flowDirection: grade < 0 ? 'reverse' : 'forward',
+            };
+        })(),
+        crossingMode: 'connect',
     });
     useViewer.getState().setSelection({ selectedIds: [] });
     editor.setTool('pipe-segment');

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

@@ -1,14 +1,79 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { PipeSegmentNode } from './schema.js';
-/**
- * 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>;
+export declare const pipeSegmentDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`pipe-segment_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"pipe-segment">>;
+    path: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    autoHangers: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    hangerOverrides: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        fraction: import("zod").ZodOptional<import("zod").ZodNumber>;
+        skipped: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        hostId: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>>;
+    hangerStyle: import("zod").ZodOptional<import("zod").ZodEnum<{
+        double: "double";
+        single: "single";
+    }>>;
+    hangerSpacing: import("zod").ZodOptional<import("zod").ZodNumber>;
+    hangerMaxReach: import("zod").ZodOptional<import("zod").ZodNumber>;
+    wallAttachment: import("zod").ZodOptional<import("zod").ZodObject<{
+        wallId: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`wall_${string}`>>;
+        side: import("zod").ZodEnum<{
+            back: "back";
+            front: "front";
+        }>;
+        startUV: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        endUV: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        offset: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+    diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    pipeMaterial: import("zod").ZodDefault<import("zod").ZodEnum<{
+        abs: "abs";
+        "cast-iron": "cast-iron";
+        pvc: "pvc";
+    }>>;
+    system: import("zod").ZodDefault<import("zod").ZodEnum<{
+        vent: "vent";
+        waste: "waste";
+    }>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +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;AAOtD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAgIxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGjC,CAAA"}

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

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { PipeSegmentNode } from './schema.js';
+export declare const pipeSegmentEditContribution: NodeEditContribution<typeof PipeSegmentNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAOvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAyCpF,CAAA"}