@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/pipe-fitting/tool.js

@@ -1,25 +1,24 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { emitter, PipeFittingNode, useScene } from '@pascal-app/core';
-import { CursorSphere, EDITOR_LAYER, isGridSnapActive, triggerSFX, useEditor, } from '@pascal-app/editor';
-import { useViewer } from '@pascal-app/viewer';
+import { emitter, PipeFittingNode, PipeSegmentNode, } from '@pascal-app/core';
+import { CursorSphere, EDITOR_LAYER, isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, useInteractionScope, useRegistryToolContext, } from '@pascal-app/editor';
 import { Html } from '@react-three/drei';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { Euler, Quaternion, Vector3 } from 'three';
+import { Euler, Mesh, MeshStandardMaterial, Quaternion, Vector3 } from 'three';
+import { accessoryCursor } from '../shared/accessory-cursor';
+import { inheritFittingProfile } from '../shared/accessory-placement';
+import { findAccessoryPort, snapAccessoryPoint, subscribeAccessorySnapping, } from '../shared/accessory-snapping';
+import { ConnectionFeedback } from '../shared/connection-feedback';
+import { alignDrawPoint, clearDrawAlignment } from '../shared/draw-alignment';
 import { AXIS_VECTORS, cycleRotationAxis, getRotationAxis, ROTATE_STEP_RAD, } from '../shared/fitting-rotation';
+import { createFittingSurfaceSupport } from '../shared/fitting-surface-support';
 import { LevelOffsetGroup } from '../shared/level-offset-group';
-import { collectScenePorts, DWV_PORT_SYSTEMS, findNearestPortXZ, } from '../shared/ports';
+import { collectScenePorts, DWV_PORT_SYSTEMS, findNearestRunBody3D, findNearestRunBodyXZ, } from '../shared/ports';
 import { pipeFittingDefinition } from './definition';
 import { buildPipeFittingGeometry } from './geometry';
+import { isInlinePipeFitting, planPipeInlineInsertion, } from './inline-insertion';
 import { localPipeFittingPorts } from './ports';
-/** Snap radius (meters, XZ) for mating onto an existing DWV port. */
-const PORT_SNAP_RADIUS_M = 0.5;
 const PREVIEW_OPACITY = 0.55;
-function snap(value, step) {
-    if (step <= 0)
-        return value;
-    return Math.round(value / step) * step;
-}
 /**
  * Resolve where the fitting would land for a cursor at `raw`:
  *   - Near an existing DWV port → mate: orientation aligns the inlet
@@ -29,16 +28,21 @@ function snap(value, step) {
  *   - Otherwise → grid-snapped free placement on the floor, manual
  *     rotation only.
  */
-function resolvePlacement(raw, previewNode, gridStep, manualQuat) {
-    const port = findNearestPortXZ(raw, collectScenePorts({ systems: DWV_PORT_SYSTEMS }), PORT_SNAP_RADIUS_M);
+export function resolvePlacement(raw, previewNode, gridStep, manualQuat, surfaceHit, surfaceNormal, support = createFittingSurfaceSupport(), context = { levelId: null, nodes: {} }) {
+    const { levelId, nodes } = context;
+    const port = levelId
+        ? findAccessoryPort(raw, collectScenePorts({ systems: DWV_PORT_SYSTEMS, levelId }, nodes), isGridSnapActive() || isMagneticSnapActive(), surfaceHit)
+        : null;
     if (port) {
+        clearDrawAlignment();
+        const fittedNode = inheritFittingProfile(previewNode, port, nodes);
         const direction = new Vector3(...port.direction).normalize();
         // Local +X must map onto the port's outward direction so the inlet
         // (local -X) faces back into the run it's joining. Manual rotation
         // composes in the world frame on top of the mate orientation.
         const mate = new Quaternion().setFromUnitVectors(new Vector3(1, 0, 0), direction);
         const final = manualQuat.clone().multiply(mate);
-        const inlet = localPipeFittingPorts(previewNode)[0];
+        const inlet = localPipeFittingPorts(fittedNode)[0];
         const inletWorldOffset = inlet.position.clone().applyQuaternion(final);
         const position = new Vector3(...port.position).sub(inletWorldOffset);
         const euler = new Euler().setFromQuaternion(final);
@@ -46,13 +50,74 @@ function resolvePlacement(raw, previewNode, gridStep, manualQuat) {
             position: [position.x, position.y, position.z],
             rotation: [euler.x, euler.y, euler.z],
             snapPort: port,
+            insertion: null,
+            node: fittedNode,
+            valid: true,
+        };
+    }
+    const snappingEnabled = isGridSnapActive() || isMagneticSnapActive();
+    if (levelId && snappingEnabled && isInlinePipeFitting(previewNode)) {
+        const filter = {
+            kinds: ['pipe-segment'],
+            levelId,
         };
+        const hit = surfaceHit
+            ? findNearestRunBody3D(raw, 0.5, filter, undefined, nodes)
+            : findNearestRunBodyXZ(raw, 0.5, filter, nodes);
+        const run = hit ? nodes[hit.nodeId] : null;
+        if (hit && run?.type === 'pipe-segment') {
+            const insertion = planPipeInlineInsertion(run, hit, previewNode);
+            const axis = new Vector3(...run.path[hit.segmentIndex + 1])
+                .sub(new Vector3(...run.path[hit.segmentIndex]))
+                .normalize();
+            const target = {
+                id: 'body',
+                nodeId: run.id,
+                position: hit.point,
+                direction: [axis.x, axis.y, axis.z],
+                diameter: run.diameter,
+                system: run.system,
+            };
+            if (insertion) {
+                clearDrawAlignment();
+                return {
+                    position: insertion.fitting.position,
+                    rotation: insertion.fitting.rotation,
+                    snapPort: target,
+                    insertion,
+                    node: insertion.fitting,
+                    valid: true,
+                };
+            }
+            const orientation = new Euler().setFromQuaternion(new Quaternion().setFromUnitVectors(new Vector3(1, 0, 0), axis));
+            return {
+                position: hit.point,
+                rotation: [orientation.x, orientation.y, orientation.z],
+                snapPort: target,
+                insertion: null,
+                node: PipeFittingNode.parse({
+                    ...previewNode,
+                    diameter: run.diameter,
+                    pipeMaterial: run.pipeMaterial,
+                    system: run.system,
+                }),
+                valid: false,
+            };
+        }
     }
     const euler = new Euler().setFromQuaternion(manualQuat);
+    const rotation = [euler.x, euler.y, euler.z];
+    const snapped = alignDrawPoint(snapAccessoryPoint(raw, gridStep, surfaceNormal), {
+        applySnap: !surfaceHit && isMagneticSnapActive(),
+        bypass: surfaceHit || !isMagneticSnapActive(),
+    });
     return {
-        position: [snap(raw[0], gridStep), 0, snap(raw[2], gridStep)],
-        rotation: [euler.x, euler.y, euler.z],
+        position: support(previewNode, rotation, snapped, raw, surfaceNormal),
+        rotation,
         snapPort: null,
+        insertion: null,
+        node: previewNode,
+        valid: true,
     };
 }
 /**
@@ -72,56 +137,129 @@ function resolvePlacement(raw, previewNode, gridStep, manualQuat) {
  * node happens to be selected.
  */
 const PipeFittingTool = () => {
-    const activeLevelId = useViewer((s) => s.selection.levelId);
+    const { activeLevelId, sceneApi, selectNode } = useRegistryToolContext();
     const [placement, setPlacement] = useState(null);
+    const toolDefaults = useEditor((s) => s.toolDefaults['pipe-fitting']);
     const axis = useEditor((s) => s.rotationAxis);
     // Accumulated manual rotation from R/T presses. Ref (not state) so the
     // emitter callbacks always read the latest without re-subscribing; a
     // placement recompute is triggered explicitly after each change.
+    const support = useMemo(createFittingSurfaceSupport, []);
     const manualQuatRef = useRef(new Quaternion());
     // Last raw cursor position so a key press can recompute the placement
     // without waiting for the next mouse move.
+    const surfaceNormalRef = useRef(undefined);
+    const surfaceHitRef = useRef(false);
     const lastRawRef = useRef(null);
     // Ghost matches exactly what a click creates (the kind's defaults).
-    const previewNode = useMemo(() => PipeFittingNode.parse({ ...pipeFittingDefinition.defaults(), name: 'Pipe fitting' }), []);
+    const previewNode = useMemo(() => PipeFittingNode.parse({ ...pipeFittingDefinition.defaults(), ...toolDefaults }), [toolDefaults]);
+    const displayNode = placement?.node ?? previewNode;
     const ghost = useMemo(() => {
-        const group = buildPipeFittingGeometry(previewNode);
+        const group = buildPipeFittingGeometry({
+            ...displayNode,
+            rotation: placement?.rotation ?? displayNode.rotation,
+        });
         group.traverse((child) => {
             // Overlay layer keeps the placement ghost out of the ink / SSGI
             // buffers and the thumbnail export, like every other tool preview.
             child.layers.set(EDITOR_LAYER);
-            const mesh = child;
-            if (mesh.material) {
-                mesh.material.transparent = true;
-                mesh.material.opacity = PREVIEW_OPACITY;
+            child.raycast = () => { };
+            if (child instanceof Mesh) {
+                const clone = (material) => {
+                    const copy = material.clone();
+                    if (placement?.valid === false && copy instanceof MeshStandardMaterial) {
+                        copy.color.set('#dc2626');
+                    }
+                    copy.transparent = true;
+                    copy.opacity = PREVIEW_OPACITY;
+                    return copy;
+                };
+                child.material = Array.isArray(child.material)
+                    ? child.material.map(clone)
+                    : clone(child.material);
             }
         });
         return group;
-    }, [previewNode]);
+    }, [displayNode, placement?.rotation, placement?.valid]);
+    useEffect(() => () => {
+        ghost.traverse((object) => {
+            if (!(object instanceof Mesh))
+                return;
+            object.geometry.dispose();
+            for (const material of Array.isArray(object.material) ? object.material : [object.material])
+                material.dispose();
+        });
+    }, [ghost]);
     useEffect(() => {
         if (!activeLevelId)
             return;
+        const draft = PipeFittingNode.parse({ ...previewNode, parentId: activeLevelId });
+        useInteractionScope.getState().begin({
+            kind: 'placing',
+            node: draft,
+            nodeId: draft.id,
+            nodeType: draft.type,
+            view: '3d',
+            pressDrag: false,
+            driver: 'registry-tool',
+        });
         const recompute = () => {
             const raw = lastRawRef.current;
             if (!raw)
                 return;
-            setPlacement(resolvePlacement(raw, previewNode, isGridSnapActive() ? useEditor.getState().gridSnapStep : 0, manualQuatRef.current));
+            const next = resolvePlacement(raw, previewNode, isGridSnapActive() ? useEditor.getState().gridSnapStep : 0, manualQuatRef.current, surfaceHitRef.current, surfaceNormalRef.current, support, { levelId: activeLevelId, nodes: sceneApi.nodes() });
+            setPlacement((previous) => ({
+                ...next,
+                node: previous && JSON.stringify(previous.node) === JSON.stringify(next.node)
+                    ? previous.node
+                    : next.node,
+                rotation: previous?.rotation.every((v, i) => v === next.rotation[i])
+                    ? previous.rotation
+                    : next.rotation,
+            }));
         };
         const onMove = (event) => {
-            lastRawRef.current = [event.localPosition[0], 0, event.localPosition[2]];
+            const cursor = accessoryCursor(event, activeLevelId);
+            surfaceNormalRef.current = cursor.normal;
+            surfaceHitRef.current = cursor.surface;
+            lastRawRef.current = cursor.point;
             recompute();
         };
         const onClick = (event) => {
-            lastRawRef.current = [event.localPosition[0], 0, event.localPosition[2]];
-            const { position, rotation } = resolvePlacement(lastRawRef.current, previewNode, isGridSnapActive() ? useEditor.getState().gridSnapStep : 0, manualQuatRef.current);
+            const cursor = accessoryCursor(event, activeLevelId);
+            surfaceNormalRef.current = cursor.normal;
+            surfaceHitRef.current = cursor.surface;
+            lastRawRef.current = cursor.point;
+            const resolved = resolvePlacement(lastRawRef.current, previewNode, isGridSnapActive() ? useEditor.getState().gridSnapStep : 0, manualQuatRef.current, surfaceHitRef.current, surfaceNormalRef.current, support, { levelId: activeLevelId, nodes: sceneApi.nodes() });
+            if (!resolved.valid)
+                return;
             const fitting = PipeFittingNode.parse({
-                ...pipeFittingDefinition.defaults(),
-                name: 'Pipe fitting',
-                position,
-                rotation,
+                ...resolved.node,
+                id: undefined,
+                name: resolved.node.fittingType.replaceAll('-', ' ').replace(/^./, (c) => c.toUpperCase()),
+                position: resolved.position,
+                rotation: resolved.rotation,
             });
-            useScene.getState().createNode(fitting, activeLevelId);
-            useViewer.getState().setSelection({ selectedIds: [fitting.id] });
+            if (resolved.insertion) {
+                const parentId = resolved.insertion.runTail.parentId ?? activeLevelId;
+                const runTail = PipeSegmentNode.parse({
+                    ...resolved.insertion.runTail,
+                    id: undefined,
+                });
+                if (!sceneApi.applyChanges)
+                    throw new Error('Registry SceneApi must support atomic changes');
+                sceneApi.applyChanges({
+                    update: [resolved.insertion.runUpdate],
+                    create: [
+                        { node: fitting, parentId },
+                        { node: runTail, parentId },
+                    ],
+                });
+            }
+            else {
+                sceneApi.upsert(fitting, activeLevelId);
+            }
+            selectNode(fitting.id);
             triggerSFX('sfx:item-place');
         };
         const onKeyDown = (e) => {
@@ -146,17 +284,24 @@ const PipeFittingTool = () => {
                 cycleRotationAxis();
             }
         };
+        recompute();
+        const unsubscribeSnapping = subscribeAccessorySnapping(recompute);
         emitter.on('grid:move', onMove);
         emitter.on('grid:click', onClick);
         window.addEventListener('keydown', onKeyDown, true);
         return () => {
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'placing' && scope.nodeId === draft.id);
+            unsubscribeSnapping();
+            clearDrawAlignment();
             emitter.off('grid:move', onMove);
             emitter.off('grid:click', onClick);
             window.removeEventListener('keydown', onKeyDown, true);
         };
-    }, [activeLevelId, previewNode]);
+    }, [activeLevelId, previewNode, sceneApi, selectNode, support]);
     if (!activeLevelId || !placement)
         return null;
-    return (_jsxs(LevelOffsetGroup, { children: [_jsx(CursorSphere, { position: placement.position }), _jsx("group", { position: placement.position, rotation: placement.rotation, children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [placement.position[0], placement.position[1] + 1.45, placement.position[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [_jsxs("span", { className: "font-medium text-foreground", children: ["Axis ", axis.toUpperCase()] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "\u2325 axis" })] }) }), placement.snapPort && (_jsxs("mesh", { layers: EDITOR_LAYER, position: placement.snapPort.position, children: [_jsx("sphereGeometry", { args: [0.18, 24, 16] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: 0.35, transparent: true })] }))] }));
+    return (_jsxs(LevelOffsetGroup, { children: [_jsx(ConnectionFeedback, { point: placement.position, target: placement.snapPort, levelId: activeLevelId, profile: displayNode }), _jsx(CursorSphere, { position: placement.position }), _jsx("group", { position: placement.position, rotation: placement.rotation, children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [placement.position[0], placement.position[1] + 1.45, placement.position[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [_jsxs("span", { className: "font-medium text-foreground", children: ["Axis ", axis.toUpperCase()] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "\u2325 axis" })] }) }), placement.snapPort && (_jsxs("mesh", { layers: EDITOR_LAYER, position: placement.snapPort.position, children: [_jsx("sphereGeometry", { args: [0.18, 24, 16] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: 0.35, transparent: true })] }))] }));
 };
 export default PipeFittingTool;

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

@@ -0,0 +1,22 @@
+import { type AnyNode, type AnyNodeId, type FloorplanAffordance } from '@pascal-app/core';
+import type { PipeFittingNode } from '../pipe-fitting/schema';
+import { type RunContinuationHandlePlan } from '../shared/elbow-branch-continuation';
+import type { RunBodyHit, ScenePort } from '../shared/ports';
+import type { PipeSegmentNode } from './schema';
+export type PipeEndpoint = 'start' | 'end';
+export type PipeContinuationSeed = {
+    pipe: PipeSegmentNode;
+    port: ScenePort | null;
+    body: RunBodyHit | null;
+    promotedFitting?: PipeFittingNode;
+};
+export declare function pipeEndpointPort(pipe: PipeSegmentNode, endpoint: PipeEndpoint): ScenePort | null;
+export declare function pipeContinuationHandlePoint(pipe: PipeSegmentNode, endpoint: PipeEndpoint, gap?: number): [number, number, number] | null;
+export declare function pipeContinuationHandlePlan(pipe: PipeSegmentNode, endpoint: PipeEndpoint, nodes: Readonly<Record<string, AnyNode>>, gap?: number): RunContinuationHandlePlan | null;
+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 const pipeContinuationAffordance: FloorplanAffordance<PipeSegmentNode>;
+export declare const pipeBranchAffordance: FloorplanAffordance<PipeSegmentNode>;
+export declare function currentPipeContinuationSeed(): PipeContinuationSeed | null;
+//# sourceMappingURL=continuation.d.ts.map

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

@@ -0,0 +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;AAGnG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAIL,KAAK,yBAAyB,EAE/B,MAAM,qCAAqC,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC5D,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"}

package/dist/pipe-segment/continuation.js

@@ -0,0 +1,146 @@
+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';
+export function pipeEndpointPort(pipe, endpoint) {
+    if (pipe.path.length < 2)
+        return null;
+    const index = endpoint === 'start' ? 0 : pipe.path.length - 1;
+    const neighborIndex = endpoint === 'start' ? 1 : pipe.path.length - 2;
+    const position = pipe.path[index];
+    const neighbor = pipe.path[neighborIndex];
+    const dx = position[0] - neighbor[0];
+    const dy = position[1] - neighbor[1];
+    const dz = position[2] - neighbor[2];
+    const length = Math.hypot(dx, dy, dz);
+    return {
+        id: endpoint,
+        nodeId: pipe.id,
+        position,
+        direction: length < 1e-9 ? [1, 0, 0] : [dx / length, dy / length, dz / length],
+        diameter: pipe.diameter,
+        system: pipe.system,
+    };
+}
+export function pipeContinuationHandlePoint(pipe, endpoint, gap = 0.28) {
+    const port = pipeEndpointPort(pipe, endpoint);
+    if (!port)
+        return null;
+    return [
+        port.position[0] + port.direction[0] * gap,
+        port.position[1] + port.direction[1] * gap,
+        port.position[2] + port.direction[2] * gap,
+    ];
+}
+export function pipeContinuationHandlePlan(pipe, endpoint, nodes, gap = 0.28) {
+    const port = pipeEndpointPort(pipe, endpoint);
+    return port ? resolvePipeContinuationHandle(port, nodes, gap) : null;
+}
+export function resolvePipeContinuationSeed(defaults, nodes) {
+    const continuation = defaults?.continuation;
+    const endpoint = continuation?.endpoint;
+    const nodeId = continuation?.nodeId;
+    if (endpoint === 'branch' && typeof nodeId === 'string') {
+        const node = nodes[nodeId];
+        const segmentIndex = continuation?.segmentIndex;
+        const point = continuation?.point;
+        if (node?.type === 'pipe-segment' &&
+            typeof segmentIndex === 'number' &&
+            Array.isArray(point) &&
+            point.length === 3) {
+            return {
+                pipe: node,
+                port: null,
+                body: { nodeId: node.id, segmentIndex, point: point },
+            };
+        }
+    }
+    if ((endpoint !== 'start' && endpoint !== 'end') ||
+        typeof nodeId !== 'string' ||
+        nodeId.length === 0)
+        return null;
+    const node = nodes[nodeId];
+    if (node?.type !== 'pipe-segment')
+        return null;
+    const port = pipeEndpointPort(node, endpoint);
+    if (!port)
+        return null;
+    if (typeof continuation?.fittingId !== 'string')
+        return { pipe: node, port, body: null };
+    const fitting = nodes[continuation.fittingId];
+    if (fitting?.type !== 'pipe-fitting')
+        return null;
+    const fittingPort = findMatedScenePorts(port, nodes).find((mate) => mate.nodeId === fitting.id);
+    if (!fittingPort)
+        return null;
+    if (fitting.fittingType === 'end-cap')
+        return { pipe: node, port, body: null };
+    const promotion = fitting.fittingType === 'elbow'
+        ? planPipeElbowBranchPromotion(fitting, fittingPort.id)
+        : planPipeTeeCrossPromotion(fitting);
+    return promotion
+        ? {
+            pipe: node,
+            port: promotion.continuationPort,
+            body: null,
+            promotedFitting: promotion.fitting,
+        }
+        : null;
+}
+export function activatePipeBranch(pipe, segmentIndex, point) {
+    if (!pipe.path[segmentIndex] || !pipe.path[segmentIndex + 1])
+        return;
+    const editor = useEditor.getState();
+    editor.setToolDefaults('pipe-segment', {
+        continuation: { nodeId: pipe.id, endpoint: 'branch', segmentIndex, point },
+    });
+    useViewer.getState().setSelection({ selectedIds: [] });
+    editor.setTool('pipe-segment');
+}
+export function activatePipeContinuation(pipe, endpoint, fittingId) {
+    if (!pipeEndpointPort(pipe, endpoint))
+        return;
+    const editor = useEditor.getState();
+    editor.setToolDefaults('pipe-segment', {
+        continuation: { nodeId: pipe.id, endpoint, ...(fittingId ? { fittingId } : {}) },
+    });
+    useViewer.getState().setSelection({ selectedIds: [] });
+    editor.setTool('pipe-segment');
+}
+export const pipeContinuationAffordance = {
+    start({ node, payload }) {
+        const data = payload;
+        const endpoint = data?.endpoint;
+        const fittingId = typeof data?.fittingId === 'string' ? data.fittingId : undefined;
+        return {
+            affectedIds: [],
+            apply() { },
+            canCommit: () => endpoint === 'start' || endpoint === 'end',
+            commit() {
+                if (endpoint === 'start' || endpoint === 'end') {
+                    activatePipeContinuation(node, endpoint, fittingId);
+                }
+            },
+        };
+    },
+};
+export const pipeBranchAffordance = {
+    start({ node, payload }) {
+        const data = payload;
+        const segmentIndex = data?.segmentIndex;
+        const point = data?.point;
+        return {
+            affectedIds: [],
+            apply() { },
+            canCommit: () => typeof segmentIndex === 'number' && Array.isArray(point) && point.length === 3,
+            commit() {
+                if (typeof segmentIndex === 'number' && Array.isArray(point) && point.length === 3) {
+                    activatePipeBranch(node, segmentIndex, point);
+                }
+            },
+        };
+    },
+};
+export function currentPipeContinuationSeed() {
+    return resolvePipeContinuationSeed(useEditor.getState().toolDefaults['pipe-segment'], useScene.getState().nodes);
+}

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;AAKtD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAmHxE,CAAA"}
+{"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"}

package/dist/pipe-segment/definition.js

@@ -1,4 +1,6 @@
 import { createPathPointMoveAffordance } from '../shared/path-point-affordance';
+import { createRunHangerToolHint } from '../shared/run-hanger-mode';
+import { pipeBranchAffordance, pipeContinuationAffordance } from './continuation';
 import { buildPipeSegmentFloorplan } from './floorplan';
 import { buildPipeSegmentGeometry } from './geometry';
 import { pipeSegmentParametrics } from './parametrics';
@@ -15,10 +17,11 @@ import { PipeSegmentNode } from './schema';
  */
 export const pipeSegmentDefinition = {
     kind: 'pipe-segment',
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: PipeSegmentNode,
     category: 'utility',
     distributionRole: 'run',
+    drafting: { surfaceQuery: true, cancelOnHistoryJump: true },
     // 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.
@@ -28,9 +31,13 @@ export const pipeSegmentDefinition = {
         parentId: null,
         visible: true,
         metadata: {},
+        autoHangers: false,
+        hangerStyle: 'single',
+        hangerSpacing: 1.5,
+        hangerMaxReach: 2,
         path: [
-            [0, 0, 0],
-            [3, -0.0625, 0],
+            [0, 0.0254, 0],
+            [3, 0.0254, 0],
         ],
         diameter: 2,
         pipeMaterial: 'pvc',
@@ -42,8 +49,13 @@ export const pipeSegmentDefinition = {
         deletable: true,
     },
     parametrics: pipeSegmentParametrics,
+    system: {
+        module: async () => ({
+            default: (await import('../shared/run-hanger-system')).PipeHangerSystem,
+        }),
+    },
+    floorplanDependsOnSiblings: true,
     geometry: buildPipeSegmentGeometry,
-    geometryKey: (n) => JSON.stringify([n.path, n.diameter, n.pipeMaterial, n.system]),
     // Open run ends as typed ports — system 'waste'/'vent' keeps the DWV
     // network invisible to duct / refrigerant tools and vice versa.
     ports: (n) => {
@@ -81,6 +93,8 @@ export const pipeSegmentDefinition = {
     // `endpoint-handle` per path vertex; this drags the matching point.
     floorplanAffordances: {
         'move-path-point': createPathPointMoveAffordance('pipe-segment'),
+        'continue-run': pipeContinuationAffordance,
+        'branch-run': pipeBranchAffordance,
     },
     // Selection-time path-point handles (drag to edit a committed run).
     // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
@@ -97,15 +111,17 @@ export const pipeSegmentDefinition = {
     tool: () => import('./tool'),
     toolHints: [
         { key: 'Click', label: 'Start run' },
-        { key: 'Click again', label: 'Place it (waste falls ¼″/ft)' },
+        { key: 'Click again', label: 'Place and continue' },
         { key: 'Q', label: 'Waste / vent' },
+        { key: 'S', label: 'Slope / level' },
+        createRunHangerToolHint('pipe-segment'),
         { key: '[ / ]', label: 'Pipe size down / up' },
         { key: 'Alt + drag', label: 'Vertical stack ↕, click to place' },
-        { key: 'Esc', label: 'Cancel start point' },
+        { key: 'Esc', label: 'Exit drawing' },
     ],
     presentation: {
         label: 'DWV Pipe',
-        description: 'Drain / waste / vent pipe run — waste lines fall at ¼″ per foot, vents run level or vertical.',
+        description: 'Drain / waste / vent pipe run — draw level or toggle a ¼″ per foot fall with S.',
         icon: { kind: 'url', src: '/icons/dwv-pipes.webp' },
         paletteSection: 'structure',
         paletteOrder: 95,

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

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

package/dist/pipe-segment/floorplan.js

@@ -1,4 +1,6 @@
 import { INCHES_TO_METERS } from '../duct-segment/geometry';
+import { runHangerFloorplan } from '../shared/run-hangers';
+import { pipeContinuationHandlePlan, pipeEndpointPort } from './continuation';
 const WASTE_COLOR = '#57534e';
 const VENT_COLOR = '#78716c';
 /**
@@ -33,6 +35,7 @@ export function buildPipeSegmentFloorplan(node, ctx) {
         return {
             kind: 'group',
             children: [
+                ...runHangerFloorplan(node, ctx),
                 {
                     kind: 'circle',
                     cx: p[0],
@@ -82,6 +85,45 @@ export function buildPipeSegmentFloorplan(node, ctx) {
                 payload: { pointIndex: indexMap[k] },
             });
         }
+        const continuationGap = Math.max(0.28, diameterM / 2 + 0.18);
+        for (const endpoint of ['start', 'end']) {
+            const port = pipeEndpointPort(node, endpoint);
+            const sceneNodes = ctx.sceneNodes ?? { [node.id]: node };
+            const plan = pipeContinuationHandlePlan(node, endpoint, sceneNodes, continuationGap);
+            if (!(port && plan))
+                continue;
+            if (Math.hypot(plan.position[0] - port.position[0], plan.position[2] - port.position[2]) < 1e-6)
+                continue;
+            children.push({
+                kind: 'midpoint-handle',
+                point: [plan.position[0], plan.position[2]],
+                activation: 'action',
+                affordance: 'continue-run',
+                payload: { action: 'continue-run', endpoint, fittingId: plan.fittingId },
+            });
+        }
+        for (let k = 0; k < points.length - 1; k++) {
+            const a = points[k];
+            const b = points[k + 1];
+            const pathIndex = indexMap[k];
+            const nextPathIndex = indexMap[k + 1];
+            children.push({
+                kind: 'midpoint-handle',
+                point: [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2],
+                activation: 'action',
+                affordance: 'branch-run',
+                payload: {
+                    action: 'branch-run',
+                    segmentIndex: pathIndex,
+                    point: [
+                        (a[0] + b[0]) / 2,
+                        (node.path[pathIndex][1] + node.path[nextPathIndex][1]) / 2,
+                        (a[1] + b[1]) / 2,
+                    ],
+                },
+            });
+        }
     }
+    children.push(...runHangerFloorplan(node, ctx));
     return { kind: 'group', children };
 }

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

@@ -1,3 +1,4 @@
+import type { GeometryContext } from '@pascal-app/core';
 import { Group, MeshStandardMaterial } from 'three';
 import type { PipeSegmentNode } from './schema';
 type PipeAppearance = {
@@ -11,6 +12,6 @@ export declare function createPipeMaterial(node: PipeAppearance): MeshStandardMa
  * (proper wyes / sanitary tees come in the next slice). Slope lives in
  * the path's Y coordinates — nothing here is slope-aware.
  */
-export declare function buildPipeSegmentGeometry(node: PipeSegmentNode): Group;
+export declare function buildPipeSegmentGeometry(node: PipeSegmentNode, ctx?: GeometryContext): Group;
 export {};
 //# sourceMappingURL=geometry.d.ts.map