@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/pipe-segment/tool.js

@@ -1,598 +1,378 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { emitter, PipeSegmentNode, useScene } from '@pascal-app/core';
-import { CursorSphere, DimensionPill, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useEditor, usePathDraftPreview, } from '@pascal-app/editor';
-import { useViewer } from '@pascal-app/viewer';
-import { Html } from '@react-three/drei';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PipeSegmentNode } from '@pascal-app/core';
+import { EDITOR_LAYER, triggerSFX, useEditor, usePathDraftPreview, useRegistryToolContext, } from '@pascal-app/editor';
 import { useEffect, useRef, useState } from 'react';
 import { Vector3 } from 'three';
 import { planPipeBranchTap, planPipeCrossAtRunBody, planPipeElbowAtPort, } from '../shared/auto-fitting';
-import { alignDrawPoint, clearDrawAlignment } from '../shared/draw-alignment';
+import { createPipeRunEndCap, findMatedRunEndCapIds, isRunEndCapPort, } from '../shared/automatic-run-end-cap';
+import { ConnectionFeedback } from '../shared/connection-feedback';
+import { createRunWallAttachment } from '../shared/distribution-run-contract';
+import { DistributionRunCursor, RUN_PREVIEW_OPACITY, runDistanceSquared, runSectionHalfSizeM, stepNominalRunSize, useDistributionRunTool, } from '../shared/distribution-run-tool';
+import { FITTING_CLEARANCE_MESSAGE, hasFittingClearance } from '../shared/fitting-clearance';
 import { LevelOffsetGroup } from '../shared/level-offset-group';
-import { collectScenePorts, DWV_PORT_SYSTEMS, findNearestPortXZ, findNearestRunBodyXZ, findRunBodyCrossingXZ, } from '../shared/ports';
+import { PipeFittingGhost } from '../shared/mep-ghost';
+import { collectScenePorts, DWV_PORT_SYSTEMS, findNearestRunBody3D, findRunBodyCrossingSurface, } from '../shared/ports';
+import { RunHangerPreview } from '../shared/run-hanger-controls';
+import { useRunHangerMode } from '../shared/run-hanger-mode';
+import { currentPipeContinuationSeed, pipeEndpointPort } from './continuation';
 import { pipeSegmentDefinition } from './definition';
-/**
- * Slope-aware two-click placement tool for DWV pipe runs — the plumbing
- * sibling of the duct tool.
- *
- *   - **First click** anchors the run start (port snap joins onto an
- *     existing pipe end — DWV ports only, duct/refrigerant collars are
- *     invisible to it). The start inherits the snapped port's height.
- *   - **Second click** commits a two-point pipe and re-arms.
- *   - **Slope**: runs draw LEVEL by default. **S** toggles slope mode,
- *     where waste runs fall at ¼" per foot (1:48) of horizontal
- *     distance, the IPC default for residential drains. When sloped, a
- *     freely placed start is RAISED so the run falls onto the grid plane
- *     (nothing clips below); a port/body-snapped start keeps its fixed
- *     height and the end drops instead. Vent runs always stay level.
- *     The pill shows the live drop in the Y part.
- *   - **Q** toggles waste ↔ vent. **[ / ]** steps the pipe size through
- *     nominal DWV diameters.
- *   - Hold **Alt** → vertical mode (stacks): XZ locks to the start,
- *     mouse vertical motion drives Y, click commits the riser.
- *   - The in-flight end follows the active snapping mode: `angles` locks it
- *     to 45° in XZ from the start; `grid`/`lines`/`off` leave it free. Shift
- *     cycles the snapping mode.
- *   - Esc clears an anchored start point.
- */
-const PREVIEW_OPACITY = 0.55;
-/** green-500 — the project's snap accent. The cursor ring + vertical line
- *  recolour to this while the point is snapped onto an existing run / port,
- *  so the coincidence reads with the familiar snap green (matches the duct
- *  tool). */
-const SNAP_CURSOR_COLOR = '#22c55e';
-/** Nominal residential DWV sizes (inches). */
+import { applyPipeGrade } from './slope';
 const PIPE_DIAMETERS_IN = [1.25, 1.5, 2, 3, 4, 6];
-/** IPC default drain slope — ¼" per foot (1:48). */
-const DRAIN_SLOPE = 1 / 48;
-/** Snap radius (meters, XZ) for joining onto an existing pipe end. */
-const PORT_SNAP_RADIUS_M = 0.5;
-/** Snap radius (meters, XZ) for tapping the side of an existing run. */
 const BODY_SNAP_RADIUS_M = 0.3;
-const ANGLE_STEP_RAD = Math.PI / 4;
-const ALT_PIXELS_PER_METER = 100;
-const ALT_Y_MIN_M = -3;
-const ALT_Y_MAX_M = 10;
-function snap(value, step) {
-    if (step <= 0)
-        return value;
-    return Math.round(value / step) * step;
-}
-function dist2(a, b) {
-    const dx = a[0] - b[0];
-    const dy = a[1] - b[1];
-    const dz = a[2] - b[2];
-    return dx * dx + dy * dy + dz * dz;
-}
-function findNearbyPort(point) {
-    return findNearestPortXZ(point, collectScenePorts({ systems: DWV_PORT_SYSTEMS }), PORT_SNAP_RADIUS_M);
-}
-function pipeEndPort(pipe, id) {
-    if (pipe.path.length < 2)
-        return null;
-    const index = id === 'start' ? 0 : pipe.path.length - 1;
-    const neighborIndex = id === '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 len = Math.hypot(dx, dy, dz);
-    const direction = len < 1e-9 ? [1, 0, 0] : [dx / len, dy / len, dz / len];
-    return {
-        id,
-        nodeId: pipe.id,
-        position,
-        direction,
-        diameter: pipe.diameter,
-        system: pipe.system,
-    };
-}
-function projectToAngleLock(from, raw) {
-    const dx = raw[0] - from[0];
-    const dz = raw[2] - from[2];
-    const len = Math.hypot(dx, dz);
-    if (len < 1e-4)
-        return [from[0], from[1], from[2]];
-    const theta = Math.atan2(dz, dx);
-    const snapped = Math.round(theta / ANGLE_STEP_RAD) * ANGLE_STEP_RAD;
-    const proj = dx * Math.cos(snapped) + dz * Math.sin(snapped);
-    const d = Math.max(0, proj);
-    return [from[0] + Math.cos(snapped) * d, from[1], from[2] + Math.sin(snapped) * d];
+function getConnectionPorts(levelId, nodes) {
+    return collectScenePorts({
+        systems: DWV_PORT_SYSTEMS,
+        levelId: levelId ?? undefined,
+    }).filter((port) => !isRunEndCapPort(port, nodes));
 }
 const PipeSegmentTool = () => {
-    const activeLevelId = useViewer((s) => s.selection.levelId);
-    const unit = useViewer((s) => s.unit);
-    const [system, setSystem] = useState('waste');
+    const { activeLevelId, sceneApi, unit } = useRegistryToolContext();
+    const continuationSeedRef = useRef(currentPipeContinuationSeed());
+    const continuationSeed = continuationSeedRef.current;
+    const hangerDefaults = useEditor((state) => state.toolDefaults['pipe-segment']);
+    const initialAutoHangersRef = useRef(Boolean(hangerDefaults?.autoHangers ?? continuationSeed?.pipe.autoHangers ?? false));
+    const autoHangers = useRunHangerMode((state) => state.enabled['pipe-segment']);
+    const hangerStyle = (hangerDefaults?.hangerStyle ?? continuationSeed?.pipe.hangerStyle) === 'double'
+        ? 'double'
+        : 'single';
+    const hangerStyleRef = useRef(hangerStyle);
+    hangerStyleRef.current = hangerStyle;
+    const autoHangersRef = useRef(autoHangers);
+    autoHangersRef.current = autoHangers;
+    const pendingPromotionRef = useRef(continuationSeed?.promotedFitting ?? null);
+    const defaults = pipeSegmentDefinition.defaults();
+    const [system, setSystem] = useState(continuationSeed?.pipe.system ?? defaults.system);
     const [sloped, setSloped] = useState(false);
-    const [diameter, setDiameter] = useState(pipeSegmentDefinition.defaults().diameter);
-    const [draftStart, setDraftStart] = useState(null);
-    const [cursorPos, setCursorPos] = useState(null);
-    const [snapTarget, setSnapTarget] = useState(null);
-    const [altActive, setAltActive] = useState(false);
-    const startRef = useRef(draftStart);
-    startRef.current = draftStart;
+    const slopePercent = 100 / 48;
+    const slopeDirection = 1;
+    const gradeRef = useRef(slopePercent / 100);
+    gradeRef.current = (slopeDirection * slopePercent) / 100;
+    const [diameter, setDiameter] = useState(continuationSeed?.pipe.diameter ?? defaults.diameter);
+    const [pipeMaterial, setPipeMaterial] = useState(continuationSeed?.pipe.pipeMaterial ?? defaults.pipeMaterial);
     const systemRef = useRef(system);
     systemRef.current = system;
     const slopedRef = useRef(sloped);
     slopedRef.current = sloped;
     const diameterRef = useRef(diameter);
     diameterRef.current = diameter;
-    // Port / run-body the anchored start snapped onto — read at commit so
-    // joints mint bends (corner) or wyes / sanitary tees (body tap).
-    const startPortRef = useRef(null);
-    const startBodyRef = useRef(null);
-    const altAnchorRef = useRef(null);
-    const lastClientYRef = useRef(null);
-    const displayStart = draftStart &&
-        cursorPos &&
-        sloped &&
-        system === 'waste' &&
-        !startPortRef.current &&
-        !startBodyRef.current &&
-        !snapTarget &&
-        !altActive
-        ? [
-            draftStart[0],
-            draftStart[1] +
-                Math.hypot(cursorPos[0] - draftStart[0], cursorPos[2] - draftStart[2]) * DRAIN_SLOPE,
-            draftStart[2],
-        ]
-        : draftStart;
-    useEffect(() => {
-        usePathDraftPreview
-            .getState()
-            .setDraft('pipe-segment', displayStart ? [displayStart] : [], cursorPos, { diameter, system });
-    }, [cursorPos, diameter, displayStart, system]);
-    useEffect(() => () => usePathDraftPreview.getState().clear('pipe-segment'), []);
+    const pipeMaterialRef = useRef(pipeMaterial);
+    pipeMaterialRef.current = pipeMaterial;
     useEffect(() => {
+        const mode = useRunHangerMode.getState();
+        mode.setEnabled('pipe-segment', initialAutoHangersRef.current);
+        return () => mode.setEnabled('pipe-segment', false);
+    }, []);
+    const commitSegment = ({ start: rawStart, end, startConnection, endConnection, surfaceTarget, previewOnly = false, }) => {
         if (!activeLevelId)
-            return;
-        /** Corner-bend gate: joints onto another PIPE run's open end. */
-        const bendPlanFor = (port, awayDir) => {
+            return null;
+        const promotedFitting = pendingPromotionRef.current;
+        const bendPlanFor = (port, awayDirection) => {
             if (!port)
                 return null;
-            const owner = useScene.getState().nodes[port.nodeId];
+            const owner = sceneApi.get(port.nodeId);
             if (owner?.type !== 'pipe-segment')
                 return null;
-            const plan = planPipeElbowAtPort(port, awayDir, diameterRef.current, owner.pipeMaterial);
+            const plan = planPipeElbowAtPort(port, awayDirection, diameterRef.current, pipeMaterialRef.current);
             if (!plan)
                 return null;
-            // Trim the run's snapped endpoint back to the bend's inlet collar.
-            const path = owner.path.map((p) => [...p]);
+            const path = owner.path.map((point) => [...point]);
             const index = port.id === 'start' ? 0 : path.length - 1;
             const neighbor = path[index === 0 ? 1 : index - 1];
-            const remaining = Math.hypot(plan.trimmedPortPoint[0] - neighbor[0], plan.trimmedPortPoint[1] - neighbor[1], plan.trimmedPortPoint[2] - neighbor[2]);
             const original = path[index];
-            const originalLen = Math.hypot(original[0] - neighbor[0], original[1] - neighbor[1], original[2] - neighbor[2]);
-            if (remaining < 0.05 || remaining >= originalLen)
-                return null;
+            const direction = [
+                original[0] - neighbor[0],
+                original[1] - neighbor[1],
+                original[2] - neighbor[2],
+            ];
+            const hasClearance = hasFittingClearance(neighbor, plan.trimmedPortPoint, direction, 0.05);
             path[index] = plan.trimmedPortPoint;
-            return { ...plan, trim: { id: port.nodeId, data: { path } } };
+            return {
+                ...plan,
+                hasClearance,
+                trim: { id: port.nodeId, data: { path } },
+            };
         };
-        const commitSegment = (rawStart, end, endPort = null, endBody = null) => {
-            // Free waste start: lift it by the drain fall so the run lands ON
-            // the grid plane instead of sinking below it. Snapped starts are
-            // height-fixed (fixture drain, run end), so their end drops instead.
-            let start = rawStart;
-            if (slopedRef.current &&
-                systemRef.current === 'waste' &&
-                !startPortRef.current &&
-                !startBodyRef.current &&
-                !endPort) {
-                const run = Math.hypot(end[0] - rawStart[0], end[2] - rawStart[2]);
-                start = [rawStart[0], rawStart[1] + run * DRAIN_SLOPE, rawStart[2]];
+        const start = rawStart;
+        const length = Math.hypot(end[0] - start[0], end[1] - start[1], end[2] - start[2]);
+        if (length < 1e-4)
+            return null;
+        const direction = [
+            (end[0] - start[0]) / length,
+            (end[1] - start[1]) / length,
+            (end[2] - start[2]) / length,
+        ];
+        const startBend = bendPlanFor(promotedFitting ? null : startConnection.port, direction);
+        const endBend = bendPlanFor(endConnection.port, [-direction[0], -direction[1], -direction[2]]);
+        const invalidPlan = () => previewOnly
+            ? {
+                validationMessage: FITTING_CLEARANCE_MESSAGE,
+                nextStart: rawStart,
+                nextConnection: startConnection,
+                previewPipes: [],
+                previewFittings: [],
             }
-            const length = Math.hypot(end[0] - start[0], end[1] - start[1], end[2] - start[2]);
-            if (length < 1e-4)
-                return;
-            const dir = [
-                (end[0] - start[0]) / length,
-                (end[1] - start[1]) / length,
-                (end[2] - start[2]) / length,
-            ];
-            const startPlan = bendPlanFor(startPortRef.current, dir);
-            const endPlan = bendPlanFor(endPort, [-dir[0], -dir[1], -dir[2]]);
-            // Body tap (wye / sanitary tee) when the start landed on a run's side.
-            const body = startPlan ? null : startBodyRef.current;
-            const bodyOwner = body ? useScene.getState().nodes[body.nodeId] : null;
-            const tapPlan = body && bodyOwner?.type === 'pipe-segment'
-                ? planPipeBranchTap(bodyOwner, body, dir, diameterRef.current)
-                : null;
-            // End body tap: the END landed on a run's side — split that trunk and
-            // the new run ends at the branch collar, the branch leaving back
-            // toward the drawn run (along -dir, since dir points start→end).
-            const endTapBody = endPlan ? null : endBody;
-            const endTapOwner = endTapBody ? useScene.getState().nodes[endTapBody.nodeId] : null;
-            const endTapPlan = endTapBody && endTapOwner?.type === 'pipe-segment'
-                ? planPipeBranchTap(endTapOwner, endTapBody, [-dir[0], -dir[1], -dir[2]], diameterRef.current)
-                : null;
-            // Both ends tapping the SAME run would split one polyline twice in a
-            // single change — drop the end tap and let the end butt-join instead.
-            const endTap = endTapPlan && endTapBody?.nodeId === body?.nodeId ? null : endTapPlan;
-            let pipeStart = startPlan?.collarPoint ?? tapPlan?.branchCollar ?? start;
-            let pipeEnd = endPlan?.collarPoint ?? endTap?.branchCollar ?? end;
-            const remaining = Math.hypot(pipeEnd[0] - pipeStart[0], pipeEnd[1] - pipeStart[1], pipeEnd[2] - pipeStart[2]);
-            let bends = [startPlan, endPlan].filter((p) => p !== null);
-            let tap = tapPlan;
-            let endTapFinal = endTap;
-            // Cross tap: the drawn run passes straight THROUGH a run's body
-            // (interior crossing, not an end touch). Split that run and the drawn
-            // pipe into two halves meeting the cross's opposed branch collars.
-            // Skip a run already tapped by a start / end tee so one polyline isn't
-            // split twice in a single change.
-            const crossHit = findRunBodyCrossingXZ(start, end, BODY_SNAP_RADIUS_M, {
+            : null;
+        if (startBend?.hasClearance === false || endBend?.hasClearance === false)
+            return invalidPlan();
+        const startBody = startBend ? null : startConnection.body;
+        const startOwner = startBody ? sceneApi.get(startBody.nodeId) : null;
+        const startTap = startBody && startOwner?.type === 'pipe-segment'
+            ? planPipeBranchTap(startOwner, startBody, direction, diameterRef.current)
+            : null;
+        const endBody = endBend ? null : endConnection.body;
+        const endOwner = endBody ? sceneApi.get(endBody.nodeId) : null;
+        let endTap = endBody && endOwner?.type === 'pipe-segment'
+            ? planPipeBranchTap(endOwner, endBody, [-direction[0], -direction[1], -direction[2]], diameterRef.current)
+            : null;
+        if (endBody?.nodeId === startBody?.nodeId)
+            endTap = null;
+        const pipeStart = startBend?.collarPoint ?? startTap?.branchCollar ?? start;
+        const pipeEnd = endBend?.collarPoint ?? endTap?.branchCollar ?? end;
+        const bends = [startBend, endBend].filter((plan) => plan !== null);
+        const crossHit = surfaceTarget
+            ? findRunBodyCrossingSurface(start, end, BODY_SNAP_RADIUS_M, surfaceTarget, {
                 kinds: ['pipe-segment'],
-            });
-            const crossOwner = crossHit ? useScene.getState().nodes[crossHit.nodeId] : null;
-            const crossTappedElsewhere = crossHit?.nodeId === body?.nodeId || crossHit?.nodeId === endTapBody?.nodeId;
-            let cross = crossHit && !crossTappedElsewhere && crossOwner?.type === 'pipe-segment'
-                ? planPipeCrossAtRunBody(crossOwner, crossHit, dir, diameterRef.current)
-                : null;
-            if (remaining <= 0.05) {
-                bends = [];
-                tap = null;
-                endTapFinal = null;
-                cross = null;
-                pipeStart = start;
-                pipeEnd = end;
-            }
-            const makePipe = (from, to) => PipeSegmentNode.parse({
-                ...pipeSegmentDefinition.defaults(),
-                name: systemRef.current === 'vent' ? 'Vent' : 'Drain',
-                path: [from, to],
-                diameter: diameterRef.current,
-                system: systemRef.current,
-            });
-            // A cross splits the drawn run into two halves that meet its opposed
-            // branch collars; otherwise it's one pipe end-to-end. Degenerate
-            // halves (the crossing too near an end) are dropped.
-            const pipes = cross
-                ? [
-                    dist2(pipeStart, cross.branchCollarNear) > 0.05 * 0.05
-                        ? makePipe(pipeStart, cross.branchCollarNear)
-                        : null,
-                    dist2(cross.branchCollarFar, pipeEnd) > 0.05 * 0.05
-                        ? makePipe(cross.branchCollarFar, pipeEnd)
-                        : null,
-                ].filter((p) => p !== null)
-                : [makePipe(pipeStart, pipeEnd)];
-            useScene.getState().applyNodeChanges({
-                create: [
-                    ...bends.map((plan) => ({ node: plan.fitting, parentId: activeLevelId })),
-                    ...(tap
-                        ? [
-                            { node: tap.fitting, parentId: activeLevelId },
-                            { node: tap.runTail, parentId: activeLevelId },
-                        ]
-                        : []),
-                    ...(endTapFinal
-                        ? [
-                            { node: endTapFinal.fitting, parentId: activeLevelId },
-                            { node: endTapFinal.runTail, parentId: activeLevelId },
-                        ]
-                        : []),
-                    ...(cross
-                        ? [
-                            { node: cross.fitting, parentId: activeLevelId },
-                            { node: cross.runTail, parentId: activeLevelId },
-                        ]
-                        : []),
-                    ...pipes.map((node) => ({ node, parentId: activeLevelId })),
-                ],
-                update: [
-                    ...bends.map((plan) => plan.trim),
-                    ...(tap ? [tap.runUpdate] : []),
-                    ...(endTapFinal
-                        ? [endTapFinal.runUpdate]
-                        : []),
-                    ...(cross ? [cross.runUpdate] : []),
-                ],
-            });
-            const nextPipe = pipes.at(-1);
-            const nextStart = nextPipe ? nextPipe.path[nextPipe.path.length - 1] : end;
-            const nextPort = nextPipe ? pipeEndPort(nextPipe, 'end') : endPort;
-            triggerSFX('sfx:item-place');
-            setDraftStart(nextStart);
-            setSnapTarget(null);
-            startPortRef.current = nextPort;
-            startBodyRef.current = nextPort ? null : endBody;
-            altAnchorRef.current = null;
-            setAltActive(false);
+            })
+            : null;
+        const crossOwner = crossHit ? sceneApi.get(crossHit.nodeId) : null;
+        const cross = crossHit &&
+            crossHit.nodeId !== startBody?.nodeId &&
+            crossHit.nodeId !== endBody?.nodeId &&
+            crossOwner?.type === 'pipe-segment'
+            ? planPipeCrossAtRunBody(crossOwner, crossHit, direction, diameterRef.current)
+            : null;
+        if (!hasFittingClearance(pipeStart, pipeEnd, direction, 0.05) ||
+            (startBody && !startTap) ||
+            (endBody && endBody.nodeId !== startBody?.nodeId && !endTap) ||
+            (crossHit &&
+                crossHit.nodeId !== startBody?.nodeId &&
+                crossHit.nodeId !== endBody?.nodeId &&
+                !cross))
+            return invalidPlan();
+        if (cross &&
+            (!hasFittingClearance(pipeStart, cross.branchCollarNear, direction, 0.05) ||
+                !hasFittingClearance(cross.branchCollarFar, pipeEnd, direction, 0.05)))
+            return invalidPlan();
+        const makePipe = (from, to) => PipeSegmentNode.parse({
+            ...pipeSegmentDefinition.defaults(),
+            ...useEditor.getState().toolDefaults['pipe-segment'],
+            autoHangers: autoHangersRef.current,
+            hangerStyle: hangerStyleRef.current,
+            name: systemRef.current === 'vent' ? 'Vent' : 'Drain',
+            path: [from, to],
+            diameter: diameterRef.current,
+            pipeMaterial: pipeMaterialRef.current,
+            system: systemRef.current,
+        });
+        const pipes = cross
+            ? [
+                runDistanceSquared(pipeStart, cross.branchCollarNear) > 0.05 * 0.05
+                    ? makePipe(pipeStart, cross.branchCollarNear)
+                    : null,
+                runDistanceSquared(cross.branchCollarFar, pipeEnd) > 0.05 * 0.05
+                    ? makePipe(cross.branchCollarFar, pipeEnd)
+                    : null,
+            ].filter((pipe) => pipe !== null)
+            : [makePipe(pipeStart, pipeEnd)];
+        const attachPipe = (pipe) => {
+            const wallAttachment = surfaceTarget?.kind === 'wall'
+                ? createRunWallAttachment(surfaceTarget.hostId, surfaceTarget.side, pipe.path[0], pipe.path.at(-1), surfaceTarget, (diameterRef.current * 0.0254) / 2)
+                : undefined;
+            return { ...pipe, wallAttachment };
         };
-        /** Apply the drain fall to an XZ-resolved end point. Only snapped
-         *  starts (fixture drain, run end/body) drop the end — they're
-         *  height-fixed. A free start keeps the end on the grid plane and
-         *  gets LIFTED at commit instead, so the run never sinks below it. */
-        const applySlope = (start, end) => {
-            if (!slopedRef.current || systemRef.current !== 'waste')
-                return end;
-            if (!startPortRef.current && !startBodyRef.current)
-                return end;
-            const run = Math.hypot(end[0] - start[0], end[2] - start[2]);
-            return [end[0], start[1] - run * DRAIN_SLOPE, end[2]];
+        const attachedPipes = pipes.map(attachPipe);
+        const sceneNodes = sceneApi.nodes();
+        const consumedEndCapIds = Array.from(new Set([
+            ...findMatedRunEndCapIds(startConnection.port, sceneNodes, 'pipe-fitting'),
+            ...findMatedRunEndCapIds(endConnection.port, sceneNodes, 'pipe-fitting'),
+        ]));
+        const firstPipe = attachedPipes[0];
+        const nextPipe = attachedPipes.at(-1);
+        const startEndCap = firstPipe && !startConnection.port && !startConnection.body
+            ? createPipeRunEndCap(firstPipe, 'start')
+            : null;
+        const nextEndCap = nextPipe && !endConnection.port && !endConnection.body ? createPipeRunEndCap(nextPipe) : null;
+        const changes = {
+            create: [
+                ...bends.map((plan) => ({
+                    node: plan.fitting,
+                    parentId: activeLevelId,
+                })),
+                ...(startTap
+                    ? [
+                        { node: startTap.fitting, parentId: activeLevelId },
+                        { node: startTap.runTail, parentId: activeLevelId },
+                    ]
+                    : []),
+                ...(endTap
+                    ? [
+                        { node: endTap.fitting, parentId: activeLevelId },
+                        { node: endTap.runTail, parentId: activeLevelId },
+                    ]
+                    : []),
+                ...(cross
+                    ? [
+                        { node: cross.fitting, parentId: activeLevelId },
+                        { node: cross.runTail, parentId: activeLevelId },
+                    ]
+                    : []),
+                ...attachedPipes.map((node) => ({ node, parentId: activeLevelId })),
+                ...(startEndCap ? [{ node: startEndCap, parentId: activeLevelId }] : []),
+                ...(nextEndCap ? [{ node: nextEndCap, parentId: activeLevelId }] : []),
+            ],
+            update: [
+                ...(promotedFitting
+                    ? [
+                        {
+                            id: promotedFitting.id,
+                            data: {
+                                name: promotedFitting.name,
+                                fittingType: promotedFitting.fittingType,
+                                rotation: promotedFitting.rotation,
+                                diameter2: promotedFitting.diameter2,
+                            },
+                        },
+                    ]
+                    : []),
+                ...bends.map((plan) => plan.trim),
+                ...(startTap
+                    ? [
+                        startTap.runUpdate,
+                    ]
+                    : []),
+                ...(endTap ? [endTap.runUpdate] : []),
+                ...(cross ? [cross.runUpdate] : []),
+            ],
+            delete: consumedEndCapIds,
         };
-        const resolveSnappedPoint = (event) => {
-            // Port / body mating is the run's primary affordance; it stays on in
-            // every snapping mode except `off` (the raw-cursor bypass).
-            const snapEnabled = isGridSnapActive() || isMagneticSnapActive() || isAngleSnapActive();
-            const start = startRef.current;
-            if (!start) {
-                const raw = [event.localPosition[0], 0, event.localPosition[2]];
-                const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
-                if (event.nativeEvent?.altKey !== true && snapEnabled) {
-                    const port = findNearbyPort(raw);
-                    if (port) {
-                        const p = [
-                            port.position[0],
-                            port.position[1],
-                            port.position[2],
-                        ];
-                        return { point: p, snapped: p, port, body: null };
-                    }
-                    // No open end nearby — try the side of a run (wye / santee tap).
-                    // Probe with a grid-snapped cursor so the tap steps along the run
-                    // like every other placement; `off` mode (step 0) rides smoothly.
-                    const probe = [snap(raw[0], step), 0, snap(raw[2], step)];
-                    const body = findNearestRunBodyXZ(probe, BODY_SNAP_RADIUS_M, {
-                        kinds: ['pipe-segment'],
-                    });
-                    if (body)
-                        return { point: body.point, snapped: body.point, port: null, body };
-                }
-                return {
-                    point: [snap(raw[0], step), 0, snap(raw[2], step)],
-                    snapped: null,
-                    port: null,
-                    body: null,
-                };
-            }
-            const rawXZ = [
-                event.localPosition[0],
-                start[1],
-                event.localPosition[2],
-            ];
-            // The 45° lock is now the `angles` snapping mode (Shift cycles to it),
-            // not a held key.
-            const angleLocked = isAngleSnapActive();
-            const angled = angleLocked ? projectToAngleLock(start, rawXZ) : rawXZ;
-            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
-            if (event.nativeEvent?.altKey !== true && snapEnabled) {
-                const port = findNearbyPort(rawXZ);
-                if (port) {
-                    const p = [port.position[0], port.position[1], port.position[2]];
-                    return { point: p, snapped: p, port, body: null };
-                }
-                // No open end nearby — landing on the side of a run taps a wye /
-                // sanitary tee there (mirror of the first-point tap). Probe with a
-                // grid-snapped cursor so the tap steps along the run; checked against
-                // the cursor, not the 45° projection, so a slightly-off trunk captures.
-                const probe = [
-                    snap(rawXZ[0], step),
-                    rawXZ[1],
-                    snap(rawXZ[2], step),
-                ];
-                const body = findNearestRunBodyXZ(probe, BODY_SNAP_RADIUS_M, { kinds: ['pipe-segment'] });
-                if (body)
-                    return { point: body.point, snapped: body.point, port: null, body };
-            }
-            let end;
-            if (!angleLocked) {
-                end = [snap(angled[0], step), angled[1], snap(angled[2], step)];
-            }
-            else {
-                // Snap the run LENGTH along the locked ray, not each axis — an
-                // off-grid start (port / body snap) plus per-axis rounding pulls
-                // the end off the 45° ray, bending the run as the cursor moves.
-                const dx = angled[0] - start[0];
-                const dz = angled[2] - start[2];
-                const len = Math.hypot(dx, dz);
-                if (len < 1e-6) {
-                    end = angled;
-                }
-                else {
-                    const s = snap(len, step) / len;
-                    end = [start[0] + dx * s, angled[1], start[2] + dz * s];
-                }
-            }
-            return { point: applySlope(start, end), snapped: null, port: null, body: null };
+        if (!previewOnly) {
+            if (!sceneApi.applyChanges)
+                throw new Error('Registry SceneApi must support atomic changes');
+            sceneApi.applyChanges(changes);
+            pendingPromotionRef.current = null;
+        }
+        const nextStart = nextPipe ? nextPipe.path[nextPipe.path.length - 1] : end;
+        const nextPort = nextPipe ? pipeEndpointPort(nextPipe, 'end') : endConnection.port;
+        return {
+            validationMessage: null,
+            nextStart,
+            previewPipes: attachedPipes,
+            previewFittings: changes.create
+                .map(({ node }) => node)
+                .filter((node) => node.type === 'pipe-fitting'),
+            nextConnection: {
+                port: nextPort,
+                body: nextPort ? null : endConnection.body,
+            },
         };
-        const resolveAltVerticalPoint = (clientY) => {
-            const anchor = altAnchorRef.current;
-            const start = startRef.current;
-            if (!anchor || !start)
-                return null;
-            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
-            const dy = (anchor.clientY - clientY) / ALT_PIXELS_PER_METER;
-            const snappedDy = snap(dy, step);
-            const y = Math.min(ALT_Y_MAX_M, Math.max(ALT_Y_MIN_M, anchor.baseY + snappedDy));
-            return [start[0], y, start[2]];
-        };
-        // Resolve the cursor point (port / body / grid / angle snap) then layer
-        // Figma-style alignment so a run lines up with other runs, fittings, and
-        // items as it's drawn. A free point (first vertex, or no angle lock) snaps;
-        // an angle-locked continuation shows the guide passively. Alignment follows
-        // the `lines` mode; a port / body snap or Alt-vertical bypasses it.
-        const resolveAlignedPoint = (event) => {
-            const r = resolveSnappedPoint(event);
-            const hasStart = !!startRef.current;
-            const alt = event.nativeEvent?.altKey === true;
-            const point = alignDrawPoint(r.point, {
-                applySnap: isMagneticSnapActive() && (!hasStart || !isAngleSnapActive()),
-                bypass: alt || r.snapped !== null,
-            });
-            return { ...r, point };
-        };
-        const onMove = (event) => {
-            const clientY = event.nativeEvent?.clientY;
-            if (typeof clientY === 'number')
-                lastClientYRef.current = clientY;
-            if (altAnchorRef.current && typeof clientY === 'number') {
-                const point = resolveAltVerticalPoint(clientY);
-                if (point) {
-                    clearDrawAlignment();
-                    setCursorPos(point);
-                    setSnapTarget(null);
-                    return;
-                }
-            }
-            const { point, snapped } = resolveAlignedPoint(event);
-            setCursorPos(point);
-            setSnapTarget(snapped);
-        };
-        const onClick = (event) => {
-            const start = startRef.current;
-            if (altAnchorRef.current && start) {
-                const clientY = event.nativeEvent?.clientY ?? lastClientYRef.current;
-                if (typeof clientY === 'number') {
-                    const point = resolveAltVerticalPoint(clientY);
-                    if (point && Math.abs(point[1] - start[1]) >= 1e-4)
-                        commitSegment(start, point);
-                }
+    };
+    const run = useDistributionRunTool({
+        active: !!activeLevelId,
+        levelId: activeLevelId,
+        toolName: 'pipe-segment',
+        initialStart: continuationSeed
+            ? [
+                ...(continuationSeed.port?.position ?? continuationSeed.body?.point ?? [0, 0, 0]),
+            ]
+            : null,
+        initialConnection: continuationSeed
+            ? { port: continuationSeed.port, body: continuationSeed.body }
+            : null,
+        getPorts: () => getConnectionPorts(activeLevelId, sceneApi.nodes()),
+        findBody: (point) => findNearestRunBody3D(point, BODY_SNAP_RADIUS_M, {
+            kinds: ['pipe-segment'],
+            levelId: activeLevelId ?? undefined,
+        }),
+        surfaceClearance: (surface) => (surface ? runSectionHalfSizeM(diameterRef.current) : 0),
+        minimumSegmentLength: 0.05,
+        resolveFreeEnd: (start, end, startConnection) => {
+            if (!slopedRef.current || systemRef.current !== 'waste')
+                return end;
+            return applyPipeGrade(start, end, gradeRef.current);
+        },
+        inheritFromConnection: ({ port, body }) => {
+            const ownerId = port?.nodeId ?? body?.nodeId;
+            const owner = ownerId ? sceneApi.get(ownerId) : null;
+            if (owner?.type !== 'pipe-segment')
                 return;
-            }
-            const { point, port, body } = resolveAlignedPoint(event);
-            if (!start) {
-                // First click: anchor the start, remembering the port / run body
-                // it snapped to so the commit can mint a bend / wye.
+            setDiameter(owner.diameter);
+            setPipeMaterial(owner.pipeMaterial);
+            setSystem(owner.system);
+        },
+        commit: commitSegment,
+        onShortcut: (event) => {
+            if (event.key === '[' || event.key === ']') {
+                event.preventDefault();
+                const next = stepNominalRunSize(PIPE_DIAMETERS_IN, diameterRef.current, event.key === ']' ? 1 : -1);
+                if (next !== diameterRef.current)
+                    setDiameter(next);
                 triggerSFX('sfx:grid-snap');
-                startPortRef.current = port;
-                startBodyRef.current = port ? null : body;
-                // Continue an existing run at its true size: adopt the snapped
-                // pipe's diameter so the new segment carries on at the same gauge
-                // instead of whatever size the tool last drew.
-                const ownerId = port?.nodeId ?? (port ? null : body?.nodeId);
-                const owner = ownerId ? useScene.getState().nodes[ownerId] : null;
-                if (owner?.type === 'pipe-segment' && owner.diameter !== diameterRef.current) {
-                    setDiameter(owner.diameter);
-                }
-                setDraftStart(point);
-                return;
-            }
-            commitSegment(start, point, port, port ? null : body);
-        };
-        const enterAltMode = () => {
-            const start = startRef.current;
-            if (!start || lastClientYRef.current === null)
-                return;
-            if (altAnchorRef.current)
-                return;
-            altAnchorRef.current = { clientY: lastClientYRef.current, baseY: start[1] };
-            setAltActive(true);
-        };
-        const exitAltMode = () => {
-            if (!altAnchorRef.current)
-                return;
-            altAnchorRef.current = null;
-            setAltActive(false);
-        };
-        const stepDiameter = (step) => {
-            const sizes = PIPE_DIAMETERS_IN;
-            const current = diameterRef.current;
-            let nearest = 0;
-            for (let i = 1; i < sizes.length; i++) {
-                if (Math.abs(sizes[i] - current) < Math.abs(sizes[nearest] - current))
-                    nearest = i;
-            }
-            const next = sizes[Math.min(sizes.length - 1, Math.max(0, nearest + step))];
-            if (next === current)
-                return;
-            setDiameter(next);
-            triggerSFX('sfx:grid-snap');
-        };
-        const onKeyDown = (e) => {
-            const tag = e.target?.tagName;
-            if (tag === 'INPUT' || tag === 'TEXTAREA')
-                return;
-            if (e.key === 'Alt') {
-                e.preventDefault();
-                enterAltMode();
-            }
-            else if (e.key === '[') {
-                e.preventDefault();
-                stepDiameter(-1);
             }
-            else if (e.key === ']') {
-                e.preventDefault();
-                stepDiameter(1);
-            }
-            else if (e.key === 'q' || e.key === 'Q') {
-                e.preventDefault();
-                setSystem((s) => (s === 'waste' ? 'vent' : 'waste'));
+            else if (event.key === 'q' || event.key === 'Q') {
+                event.preventDefault();
+                setSystem((value) => (value === 'waste' ? 'vent' : 'waste'));
                 triggerSFX('sfx:grid-snap');
             }
-            else if (e.key === 's' || e.key === 'S') {
-                e.preventDefault();
-                setSloped((s) => !s);
+            else if (event.key === 's' || event.key === 'S') {
+                event.preventDefault();
+                setSloped((value) => !value);
                 triggerSFX('sfx:grid-snap');
             }
-        };
-        const onKeyUp = (e) => {
-            if (e.key === 'Alt') {
-                e.preventDefault();
-                exitAltMode();
+            else if (event.key === 'h' || event.key === 'H') {
+                event.preventDefault();
+                useRunHangerMode.getState().toggle('pipe-segment');
+                triggerSFX('sfx:grid-snap');
             }
-        };
-        const onCancel = () => {
-            clearDrawAlignment();
-            if (!startRef.current)
-                return;
-            markToolCancelConsumed();
-            setDraftStart(null);
-            setCursorPos(null);
-            setSnapTarget(null);
-            startPortRef.current = null;
-            startBodyRef.current = null;
-        };
-        emitter.on('grid:move', onMove);
-        emitter.on('grid:click', onClick);
-        emitter.on('tool:cancel', onCancel);
-        window.addEventListener('keydown', onKeyDown);
-        window.addEventListener('keyup', onKeyUp);
-        return () => {
-            emitter.off('grid:move', onMove);
-            emitter.off('grid:click', onClick);
-            emitter.off('tool:cancel', onCancel);
-            window.removeEventListener('keydown', onKeyDown);
-            window.removeEventListener('keyup', onKeyUp);
-            altAnchorRef.current = null;
-            clearDrawAlignment();
-        };
-    }, [activeLevelId]);
+        },
+    });
+    const refreshCursor = run.refreshCursor;
+    // Slope settings are read through refs by the cursor resolver; refresh after those refs update.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: settings must refresh a stationary cursor
+    useEffect(() => {
+        if (!run.altActive)
+            refreshCursor();
+    }, [sloped, system, run.altActive, refreshCursor]);
+    const displayStart = run.start;
+    const previewPlan = run.start && run.cursor
+        ? commitSegment({
+            start: run.start,
+            end: run.cursor,
+            startConnection: run.startConnection,
+            endConnection: run.endConnection,
+            surfaceTarget: run.surfaceTarget,
+            previewOnly: true,
+        })
+        : null;
+    useEffect(() => {
+        usePathDraftPreview
+            .getState()
+            .setDraft('pipe-segment', displayStart ? [displayStart] : [], run.cursor, {
+            autoHangers,
+            hangerStyle,
+            diameter,
+            system,
+        });
+    }, [autoHangers, hangerStyle, diameter, displayStart, run.cursor, system]);
+    useEffect(() => () => usePathDraftPreview.getState().clear('pipe-segment'), []);
+    useEffect(() => () => useEditor.getState().setToolDefaults('pipe-segment', null), []);
     if (!activeLevelId)
         return null;
-    const pillParts = cursorPos
-        ? [
-            ...['x', 'y', 'z'].map((axis, i) => ({
-                key: axis,
-                prefix: axis.toUpperCase(),
-                value: displayStart ? cursorPos[i] - displayStart[i] : cursorPos[i],
-                signed: !!displayStart,
-            })),
-            { key: 'diameter', prefix: 'Ø', value: diameter * 0.0254, signed: false },
-        ]
-        : null;
-    const pillPrimary = draftStart && cursorPos ? (altActive ? 'y' : 'y') : undefined;
-    return (_jsxs(LevelOffsetGroup, { children: [cursorPos && (_jsxs(_Fragment, { children: [_jsx(CursorSphere, { color: snapTarget ? SNAP_CURSOR_COLOR : undefined, position: cursorPos }), pillParts && (_jsx("group", { position: cursorPos, children: _jsx(Html, { center: true, position: [0, 1.45, 0], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex flex-col items-center gap-1", children: [_jsx(DimensionPill, { parts: pillParts, primary: pillPrimary, unit: unit }), _jsxs("div", { className: "whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-3 py-0.5 text-[10px] text-muted-foreground shadow-sm backdrop-blur", children: [system === 'waste'
-                                                ? sloped
-                                                    ? 'Waste · ¼″/ft fall'
-                                                    : 'Waste · level'
-                                                : 'Vent · level', ' ', "\u00B7 Q system", system === 'waste' ? ' · S slope' : ''] })] }) }) }))] })), snapTarget && (_jsxs("mesh", { layers: EDITOR_LAYER, position: snapTarget, children: [_jsx("sphereGeometry", { args: [0.1, 24, 16] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: 0.35, transparent: true })] })), displayStart && (_jsxs("mesh", { layers: EDITOR_LAYER, position: displayStart, children: [_jsx("sphereGeometry", { args: [0.05, 16, 12] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false })] })), displayStart && cursorPos && (_jsx(PreviewPipe, { a: displayStart, b: cursorPos, diameterIn: diameter }))] }));
+    return (_jsxs(LevelOffsetGroup, { children: [_jsx(ConnectionFeedback, { point: run.cursor, target: run.endConnection.port, levelId: activeLevelId, profile: { diameter, system } }), _jsx(DistributionRunCursor, { altActive: run.altActive, cursor: run.cursor, directionMode: run.directionMode, extraParts: [{ key: 'diameter', prefix: 'Ø', value: diameter * 0.0254 }], lengthInput: run.lengthInput, onLengthInputChange: run.onLengthInputChange, onDirectionSelect: run.onDirectionSelect, validationMessage: previewPlan?.validationMessage ?? run.validationMessage, snapTarget: run.snapTarget, snapScreen: run.snapScreen, start: displayStart, startDirection: run.startConnection.port?.direction ?? null, unit: unit }), run.snapTarget && (_jsxs("mesh", { layers: EDITOR_LAYER, position: run.snapTarget, children: [_jsx("sphereGeometry", { args: [0.1, 24, 16] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: 0.35, transparent: true })] })), displayStart && (_jsxs("mesh", { layers: EDITOR_LAYER, position: displayStart, children: [_jsx("sphereGeometry", { args: [0.05, 16, 12] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false })] })), previewPlan?.previewPipes.map((pipe, index) => (_jsx(PreviewPipe, { a: pipe.path[0], b: pipe.path.at(-1), diameterIn: diameter }, index))), previewPlan?.previewPipes.map((pipe, index) => (_jsx(RunHangerPreview, { run: pipe, levelId: activeLevelId }, `hanger-${index}`))), previewPlan?.previewFittings.map((fitting, index) => (_jsx(PipeFittingGhost, { fitting: fitting }, index)))] }));
 };
-function PreviewPipe({ a, b, diameterIn, }) {
+function PreviewPipe({ a, b, diameterIn }) {
     const start = new Vector3(...a);
     const end = new Vector3(...b);
-    const dir = new Vector3().subVectors(end, start);
-    const length = dir.length();
+    const direction = new Vector3().subVectors(end, start);
+    const length = direction.length();
     if (length < 1e-4)
         return null;
-    dir.normalize();
-    const mid = new Vector3().addVectors(start, end).multiplyScalar(0.5);
+    direction.normalize();
+    const midpoint = new Vector3().addVectors(start, end).multiplyScalar(0.5);
     const radius = (diameterIn * 0.0254) / 2;
-    return (_jsxs("mesh", { layers: EDITOR_LAYER, position: mid.toArray(), ref: (m) => {
-            if (!m)
-                return;
-            m.quaternion.setFromUnitVectors(new Vector3(0, 1, 0), dir);
-        }, children: [_jsx("cylinderGeometry", { args: [radius, radius, length, 20, 1, false] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: PREVIEW_OPACITY, transparent: true })] }));
+    return (_jsxs("mesh", { layers: EDITOR_LAYER, position: midpoint.toArray(), ref: (mesh) => {
+            if (mesh)
+                mesh.quaternion.setFromUnitVectors(new Vector3(0, 1, 0), direction);
+        }, children: [_jsx("cylinderGeometry", { args: [radius, radius, length, 20, 1, false] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: RUN_PREVIEW_OPACITY, transparent: true })] }));
 }
 export default PipeSegmentTool;