@pascal-app/nodes 1.0.6 → 1.1.0

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

@@ -0,0 +1,22 @@
+import { type AnyNode } from '@pascal-app/core';
+import type { AgentOperation } from '@pascal-app/core/agent-operations';
+type Point = [number, number, number];
+export type PipeGradeInput = {
+    nodeId: string;
+    action: 'grade' | 'endpoint' | 'elevation';
+    gradePercent?: number;
+    flow?: 'forward' | 'reverse';
+    anchor?: 'start' | 'end';
+    pointIndex?: number;
+    point?: Point;
+    elevation?: number;
+    detach?: boolean;
+};
+/** Refuse a connected edit that would silently regrade another run. */
+export declare function pipeUpdatesPreserveGrades(nodes: Readonly<Record<string, AnyNode>>, updates: {
+    id: string;
+    data: Partial<AnyNode>;
+}[], exceptId?: string): boolean;
+export declare const editPipeGrade: AgentOperation<PipeGradeInput>;
+export {};
+//# sourceMappingURL=grade-operation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grade-operation.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/grade-operation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAMb,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAA;AAKvE,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AACrC,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,OAAO,GAAG,UAAU,GAAG,WAAW,CAAA;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,CAAA;IAC5B,MAAM,CAAC,EAAE,OAAO,GAAG,KAAK,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,uEAAuE;AACvE,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,EACjD,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAWT;AAED,eAAO,MAAM,aAAa,EAAE,cAAc,CAAC,cAAc,CAyHxD,CAAA"}

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

@@ -0,0 +1,114 @@
+import { analyzePortConnectivity, nodeRegistry, resolveConnectivityUpdates, } from '@pascal-app/core';
+import { refuse } from '@pascal-app/core/agent-tools';
+import { planRunEndCapFollowUpdates } from '../shared/automatic-run-end-cap.js';
+import { applyPipeGrade, pipeGradesMatch, preservePipeGrades } from './slope.js';
+/** Refuse a connected edit that would silently regrade another run. */
+export function pipeUpdatesPreserveGrades(nodes, updates, exceptId) {
+    return updates.every((update) => {
+        const node = nodes[update.id];
+        return (update.id === exceptId ||
+            node?.type !== 'pipe-segment' ||
+            !('path' in update.data) ||
+            !update.data.path ||
+            pipeGradesMatch(node.path, update.data.path));
+    });
+}
+export const editPipeGrade = (nodes, input) => {
+    const pipe = nodes[input.nodeId];
+    if (pipe?.type !== 'pipe-segment')
+        return refuse('pipe_not_found', 'Select a pipe run.');
+    if (!nodeRegistry.get('pipe-segment')?.ports)
+        return refuse('node_capability_unavailable', 'Register pipe node definitions before editing.');
+    let path = pipe.path.map((p) => [...p]);
+    if (input.action === 'grade') {
+        const grade = input.gradePercent;
+        if (grade === undefined || !Number.isFinite(grade) || grade < 0)
+            return refuse('pipe_grade_invalid', 'Enter a finite, non-negative grade percentage.');
+        const signed = (grade / 100) * (input.flow === 'reverse' ? -1 : 1);
+        for (let i = 1; i < path.length; i++) {
+            const previous = pipe.path[i - 1];
+            const current = pipe.path[i];
+            // Vertical legs keep their height; grades describe horizontal travel only.
+            path[i] =
+                Math.hypot(current[0] - previous[0], current[2] - previous[2]) < 1e-6
+                    ? [current[0], path[i - 1][1] + current[1] - previous[1], current[2]]
+                    : applyPipeGrade(path[i - 1], current, signed);
+        }
+        if (input.anchor === 'end') {
+            const dy = pipe.path.at(-1)[1] - path.at(-1)[1];
+            path = path.map((p) => [p[0], p[1] + dy, p[2]]);
+        }
+    }
+    else if (input.action === 'elevation') {
+        if (input.elevation === undefined || !Number.isFinite(input.elevation))
+            return refuse('pipe_elevation_invalid', 'Enter a finite elevation above the level.');
+        const index = input.anchor === 'end' ? path.length - 1 : 0;
+        const dy = input.elevation - path[index][1];
+        path = path.map((p) => [p[0], p[1] + dy, p[2]]);
+    }
+    else {
+        const index = input.pointIndex;
+        if (index === undefined ||
+            !Number.isInteger(index) ||
+            !path[index] ||
+            !input.point ||
+            input.point.some((v) => !Number.isFinite(v)))
+            return refuse('pipe_endpoint_invalid', 'Choose a valid path point and finite coordinates.');
+        path[index] = input.point;
+        const constrained = preservePipeGrades(pipe.path, path, index);
+        if (!constrained)
+            return refuse('pipe_grade_conflict', 'This edit collapses a run or tilts a vertical stack. Move the whole stack instead.');
+        path = constrained;
+    }
+    const detached = input.action === 'endpoint' && input.detach === true;
+    const next = { ...pipe, path, wallAttachment: undefined };
+    const connectivity = analyzePortConnectivity(pipe, nodes);
+    for (const endpoint of ['start', 'end']) {
+        if (detached)
+            continue;
+        const mates = connectivity.adjacency[pipe.id]?.[endpoint] ?? [];
+        if (!mates.some((mate) => {
+            const owner = nodes[mate.nodeId];
+            return owner?.type !== 'pipe-fitting' || owner.fittingType !== 'end-cap';
+        }))
+            continue;
+        const index = endpoint === 'start' ? 0 : path.length - 1;
+        const neighbor = endpoint === 'start' ? 1 : path.length - 2;
+        const oldDirection = pipe.path[index].map((v, i) => v - pipe.path[neighbor][i]);
+        const newDirection = path[index].map((v, i) => v - path[neighbor][i]);
+        const oldLength = Math.hypot(...oldDirection), newLength = Math.hypot(...newDirection);
+        const dot = oldDirection.reduce((sum, v, i) => sum + v * newDirection[i], 0) / (oldLength * newLength);
+        if (!Number.isFinite(dot) || dot < 0.999999)
+            return refuse('pipe_connection_angle', 'This would turn a connected collar. Adjust the fitting or detach the run before changing its direction or grade.');
+    }
+    const follow = !detached && connectivity ? resolveConnectivityUpdates(connectivity, next) : [];
+    if (!follow)
+        return refuse('pipe_connection_split', 'Connected pipes and fittings cannot follow this edit without pulling a joint apart. Adjust the connected route explicitly first.');
+    const caps = detached
+        ? []
+        : ['start', 'end'].flatMap((end) => planRunEndCapFollowUpdates(pipe, next, end, nodes));
+    const capIds = new Set(caps.map((cap) => cap.id));
+    const update = [
+        { id: pipe.id, data: { path, wallAttachment: undefined } },
+        ...follow.filter((entry) => !capIds.has(entry.id)),
+        ...caps,
+    ];
+    if (!pipeUpdatesPreserveGrades(nodes, update, pipe.id))
+        return refuse('pipe_connected_grade', 'This would change a connected pipe’s grade. Adjust the connected route explicitly first.');
+    if (update.some((entry) => {
+        const owner = nodes[entry.id];
+        return (owner &&
+            owner.id !== pipe.id &&
+            owner.type !== 'pipe-segment' &&
+            owner.type !== 'pipe-fitting');
+    }))
+        return refuse('pipe_fixed_connection', 'This edit would move a fixture or equipment connection. Keep that endpoint fixed.');
+    return {
+        result: {
+            message: 'Pipe elevations updated; grades preserved on connected runs.',
+            startElevation: path[0][1],
+            endElevation: path.at(-1)[1],
+        },
+        changes: { update },
+    };
+};

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AAsEzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA8N3D,CAAA;eAiCc,mBAAmB"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAQb,MAAM,kBAAkB,CAAA;AAyEzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA4P3D,CAAA;eAsCc,mBAAmB"}

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

@@ -1,13 +1,16 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { emitter, PipeSegmentNode, sceneRegistry, useScene, } from '@pascal-app/core';
+import { emitter, PipeSegmentNode, sceneRegistry, usePascalI18n, useScene, } from '@pascal-app/core';
 import { copyCollectionIds, DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
+import { Html } from '@react-three/drei';
 import { useEffect, useRef, useState } from 'react';
 import { Vector3 } from 'three';
 import { collectGhostAlignmentCandidates, resolveGhostAlignment, } from '../shared/ghost-alignment.js';
+import { INVALID_GHOST_COLOR, VALID_GHOST_COLOR } from '../shared/ghost-materials.js';
 import { startRunMoveConnectivity } from '../shared/run-move-connectivity.js';
 import { translateWallRun } from '../shared/wall-run-move.js';
+import { pipeUpdatesPreserveGrades } from './grade-operation.js';
 const GHOST_COLOR = '#818cf8';
 const GHOST_OPACITY = 0.5;
 const IN_TO_M = 0.0254;
@@ -71,6 +74,7 @@ function pathAabb(path, r) {
  * Wired via `def.affordanceTools.move`.
  */
 export const MovePipeSegmentTool = ({ node }) => {
+    const i18n = usePascalI18n();
     const pipe = node;
     const originalPathRef = useRef(pipe.path.map((p) => [...p]));
     const isNew = typeof node.metadata === 'object' &&
@@ -83,6 +87,7 @@ export const MovePipeSegmentTool = ({ node }) => {
     const activatedAtRef = useRef(Date.now());
     const prevSnapRef = useRef(null);
     const previewAttachmentRef = useRef(pipe.wallAttachment);
+    const [gradeBlocked, setGradeBlocked] = useState(false);
     useEffect(() => {
         const nodeId = node.id;
         const originalPath = originalPathRef.current;
@@ -109,9 +114,17 @@ export const MovePipeSegmentTool = ({ node }) => {
         const connectivity = existedAtStart
             ? startRunMoveConnectivity(node)
             : null;
-        const setPreview = (path) => {
+        // A frame the connected joints cannot follow is not shown: the ghost holds
+        // its last frame, which is what a click commits.
+        const showFrame = (path) => {
+            const followers = connectivity ? connectivity.preview({ path }) : [];
+            if (!followers)
+                return false;
+            hasMovedRef.current = true;
             previewPathRef.current = path;
             setPreviewPath(path);
+            setGradeBlocked(!pipeUpdatesPreserveGrades(useScene.getState().nodes, followers));
+            return true;
         };
         const onMove = (event) => {
             const attachedWall = pipe.wallAttachment
@@ -120,10 +133,8 @@ export const MovePipeSegmentTool = ({ node }) => {
             if (pipe.wallAttachment && attachedWall?.type === 'wall') {
                 const wallMove = translateWallRun(originalPath, pipe.wallAttachment, attachedWall, event);
                 if (wallMove) {
-                    hasMovedRef.current = true;
-                    previewAttachmentRef.current = wallMove.attachment;
-                    setPreview(wallMove.path);
-                    connectivity?.preview({ path: wallMove.path });
+                    if (showFrame(wallMove.path))
+                        previewAttachmentRef.current = wallMove.attachment;
                     return;
                 }
             }
@@ -158,10 +169,7 @@ export const MovePipeSegmentTool = ({ node }) => {
                 triggerSFX('sfx:grid-snap');
             }
             prevSnapRef.current = cur;
-            hasMovedRef.current = true;
-            const nextPath = originalPath.map(([x, y, z]) => [x + dx, y, z + dz]);
-            setPreview(nextPath);
-            connectivity?.preview({ path: nextPath });
+            showFrame(originalPath.map(([x, y, z]) => [x + dx, y, z + dz]));
         };
         const commit = (event) => {
             if (committed)
@@ -174,8 +182,19 @@ export const MovePipeSegmentTool = ({ node }) => {
                 event.nativeEvent?.stopPropagation?.();
                 return;
             }
-            committed = true;
             const finalPath = previewPathRef.current;
+            const followUpdates = connectivity ? connectivity.commitUpdates({ path: finalPath }) : [];
+            // The drag stays live (history paused, Esc cancels) so the run can be placed elsewhere.
+            if (!followUpdates) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            if (!pipeUpdatesPreserveGrades(useScene.getState().nodes, followUpdates)) {
+                setGradeBlocked(true);
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            committed = true;
             useScene.temporal.getState().resume();
             let selectId = nodeId;
             if (isNew && !useScene.getState().nodes[nodeId]) {
@@ -198,7 +217,6 @@ export const MovePipeSegmentTool = ({ node }) => {
             else {
                 // Fold connected-fitting / sibling-run follow-updates into the SAME
                 // batch as the moved run so the whole joint is one undo step.
-                const followUpdates = connectivity?.commitUpdates({ path: finalPath }) ?? [];
                 useScene.getState().updateNodes([
                     {
                         id: nodeId,
@@ -258,11 +276,16 @@ export const MovePipeSegmentTool = ({ node }) => {
     const r = pipeRadiusM(pipe);
     const box = pathAabb(previewPath, r);
     const boxY = previewPath[0]?.[1] ?? 0;
-    return (_jsxs("group", { children: [segments.map((seg, i) => (_jsx(GhostSegment, { a: seg.a, b: seg.b, radius: r }, `ghost-${i}`))), _jsx(DragBoundingBox, { centerY: 0, nodeId: node.id, position: [(box.minX + box.maxX) / 2, boxY, (box.minZ + box.maxZ) / 2], size: [box.maxX - box.minX, pipe.diameter * IN_TO_M, box.maxZ - box.minZ] })] }));
+    const boxCenter = [(box.minX + box.maxX) / 2, boxY, (box.minZ + box.maxZ) / 2];
+    const ghostColor = gradeBlocked ? INVALID_GHOST_COLOR : GHOST_COLOR;
+    return (_jsxs("group", { children: [segments.map((seg, i) => (_jsx(GhostSegment, { a: seg.a, b: seg.b, color: ghostColor, radius: r }, `ghost-${i}`))), _jsx(DragBoundingBox, { centerY: 0, color: gradeBlocked ? INVALID_GHOST_COLOR : VALID_GHOST_COLOR, nodeId: node.id, position: boxCenter, size: [box.maxX - box.minX, pipe.diameter * IN_TO_M, box.maxZ - box.minZ] }), gradeBlocked && (_jsx(Html, { center: true, position: boxCenter, style: { pointerEvents: 'none' }, children: _jsx("div", { role: "status", className: "pointer-events-none w-64 rounded border bg-background p-2 text-xs", children: i18n._({
+                        id: 'node.pipeSegment.moveTool.connectedGradeBlocked',
+                        message: 'This move would change a connected pipe’s grade. Choose another position or press Esc to cancel.',
+                    }) }) }))] }));
 };
 /** Translucent stand-in for one pipe section — mirrors the draw tool's
  *  `PreviewPipe` so the ghost matches what actually lands. */
-function GhostSegment({ a, b, radius }) {
+function GhostSegment({ a, b, color, radius, }) {
     const start = new Vector3(...a);
     const end = new Vector3(...b);
     const dir = new Vector3().subVectors(end, start);
@@ -275,6 +298,6 @@ function GhostSegment({ a, b, radius }) {
             if (!m)
                 return;
             m.quaternion.setFromUnitVectors(new Vector3(0, 1, 0), dir);
-        }, children: [_jsx("cylinderGeometry", { args: [radius, radius, length, 24, 1, false] }), _jsx("meshBasicMaterial", { color: GHOST_COLOR, depthTest: false, opacity: GHOST_OPACITY, transparent: true })] }));
+        }, children: [_jsx("cylinderGeometry", { args: [radius, radius, length, 24, 1, false] }), _jsx("meshBasicMaterial", { color: color, depthTest: false, opacity: GHOST_OPACITY, transparent: true })] }));
 }
 export default MovePipeSegmentTool;

package/dist/pipe-segment/offset-inspector.d.ts

@@ -0,0 +1,5 @@
+import { type PipeSegmentNode } from '@pascal-app/core';
+export default function PipeOffsetInspector({ node }: {
+    node: PipeSegmentNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=offset-inspector.d.ts.map

package/dist/pipe-segment/offset-inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offset-inspector.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/offset-inspector.tsx"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,eAAe,EAA2B,MAAM,kBAAkB,CAAA;AAKhG,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,+BAmB9E"}

package/dist/pipe-segment/offset-inspector.js

@@ -0,0 +1,112 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { usePascalI18n, useScene } from '@pascal-app/core';
+import { useMemo, useState } from 'react';
+import { offsetPipe } from './offset-operation.js';
+export default function PipeOffsetInspector({ node }) {
+    const i18n = usePascalI18n();
+    const [open, setOpen] = useState(false);
+    return (_jsxs("section", { className: "space-y-2 border-t pt-3 text-xs", children: [_jsx("button", { type: "button", "aria-expanded": open, className: "w-full text-left text-sm font-medium", onClick: () => setOpen(!open), children: i18n._({
+                    id: 'node.pipeSegment.offsetInspector.offsetAroundObstacle',
+                    message: 'Offset around obstacle',
+                }) }), open && _jsx(OffsetForm, { node: node })] }));
+}
+function OffsetForm({ node }) {
+    const i18n = usePascalI18n();
+    const nodes = useScene((state) => state.nodes);
+    const start = node.path[0], end = node.path.at(-1);
+    const length = Math.hypot(end[0] - start[0], end[2] - start[2]);
+    const [input, setInput] = useState({
+        nodeId: node.id,
+        from: Number((length / 4).toFixed(3)),
+        to: Number(((length * 3) / 4).toFixed(3)),
+        offset: Number(Math.min(0.5, length / 8).toFixed(3)),
+    });
+    const [notice, setNotice] = useState('');
+    const [appliedPath, setAppliedPath] = useState(null);
+    const fieldLabels = {
+        from: i18n._({ id: 'node.pipeSegment.offsetInspector.firstBend', message: 'First bend (m)' }),
+        to: i18n._({ id: 'node.pipeSegment.offsetInspector.lastBend', message: 'Last bend (m)' }),
+        offset: i18n._({
+            id: 'node.pipeSegment.offsetInspector.verticalOffset',
+            message: 'Vertical offset (m)',
+        }),
+    };
+    const preview = useMemo(() => {
+        try {
+            return { outcome: offsetPipe(nodes, input, { activeLevelId: node.parentId }), error: '' };
+        }
+        catch (error) {
+            return {
+                outcome: null,
+                error: error instanceof Error
+                    ? error.message
+                    : i18n._({
+                        id: 'node.pipeSegment.offsetInspector.unableToPlanOffset',
+                        message: 'Unable to plan offset.',
+                    }),
+            };
+        }
+    }, [nodes, input, node.parentId, i18n]);
+    const paths = (preview.outcome?.result.paths ?? []);
+    const all = [start, end, ...paths.flat()];
+    const minY = Math.min(...all.map((p) => p[1])), maxY = Math.max(...all.map((p) => p[1]));
+    const project = (p) => {
+        const distance = ((p[0] - start[0]) * (end[0] - start[0]) + (p[2] - start[2]) * (end[2] - start[2])) /
+            (length || 1);
+        return `${16 + (228 * distance) / (length || 1)},${100 - (80 * (p[1] - minY)) / (maxY - minY || 1)}`;
+    };
+    const apply = () => {
+        try {
+            const outcome = offsetPipe(useScene.getState().nodes, input, { activeLevelId: node.parentId });
+            useScene.getState().applyNodeChanges({
+                create: outcome.changes?.create?.map((entry) => ({
+                    ...entry,
+                    parentId: entry.parentId,
+                })),
+                update: outcome.changes?.update?.map((entry) => ({ ...entry, id: entry.id })),
+            });
+            setNotice(i18n._({
+                id: 'node.pipeSegment.offsetInspector.offsetAppliedInOneUndoStep',
+                message: 'Offset applied in one undo step. End connections stayed fixed.',
+            }));
+            const appliedNode = useScene.getState().nodes[node.id];
+            setAppliedPath(appliedNode?.type === 'pipe-segment' ? JSON.stringify(appliedNode.path) : null);
+        }
+        catch (error) {
+            setNotice(error instanceof Error
+                ? error.message
+                : i18n._({
+                    id: 'node.pipeSegment.offsetInspector.unableToApplyOffset',
+                    message: 'Unable to apply offset.',
+                }));
+        }
+    };
+    if (appliedPath === JSON.stringify(node.path))
+        return _jsx("p", { role: "status", children: notice });
+    return (_jsxs("div", { className: "space-y-2", children: [_jsx("p", { children: i18n._({
+                    id: 'node.pipeSegment.offsetInspector.chooseTheFirstAndLastBend',
+                    message: 'Choose the first and last bend by horizontal distance from the start. Positive offset goes up; negative goes down. Each connector uses the offset height in horizontal travel.',
+                }) }), ['from', 'to', 'offset'].map((key) => (_jsxs("label", { className: "flex justify-between gap-2", children: [fieldLabels[key], _jsx("input", { "aria-label": fieldLabels[key], type: "number", step: 0.05, className: "w-24 border bg-background p-1", value: Number.isFinite(input[key]) ? input[key] : '', onChange: (event) => {
+                            setInput({ ...input, [key]: event.target.valueAsNumber });
+                            setNotice('');
+                        } })] }, key))), paths.length > 0 && (_jsxs(_Fragment, { children: [_jsxs("svg", { viewBox: "0 0 260 120", role: "img", "aria-label": i18n._({
+                            id: 'node.pipeSegment.offsetInspector.pipeOffsetSideProfilePreview',
+                            message: 'Pipe offset side profile preview',
+                        }), className: "w-full rounded border", children: [_jsx("polyline", { points: [start, end].map(project).join(' '), fill: "none", stroke: "currentColor", strokeDasharray: "4 4", opacity: 0.4 }), _jsx("polyline", { points: paths.flat().map(project).join(' '), fill: "none", stroke: "currentColor", strokeWidth: 2 }), [start, end].map((point, index) => {
+                                const [cx, cy] = project(point).split(',');
+                                return _jsx("circle", { cx: cx, cy: cy, r: 3, fill: "currentColor" }, index);
+                            })] }), _jsx("p", { children: i18n._({
+                            id: 'node.pipeSegment.offsetInspector.sideProfileSchematicFourBendsFive',
+                            message: 'Side profile (schematic). Four bends · five pipe sections. Parallel sections keep the original grade; both end connections stay fixed.',
+                        }) }), preview.outcome?.result.uphill === true && (_jsx("p", { role: "note", children: i18n._({
+                            id: 'node.pipeSegment.offsetInspector.thisOffsetIncludesAnUphillWaste',
+                            message: 'This offset includes an uphill waste section. It does not provide continuous downhill drainage.',
+                        }) }))] })), _jsx("p", { className: "text-muted-foreground", children: i18n._({
+                    id: 'node.pipeSegment.offsetInspector.checkObstacleClearanceThePreviewDoes',
+                    message: 'Check obstacle clearance. The preview does not detect collisions.',
+                }) }), preview.error && _jsx("p", { role: "alert", children: preview.error }), _jsx("button", { type: "button", disabled: !preview.outcome, className: "w-full rounded border p-1 disabled:opacity-50", onClick: apply, children: i18n._({
+                    id: 'node.pipeSegment.offsetInspector.applyPipeOffset',
+                    message: 'Apply pipe offset',
+                }) }), notice && _jsx("p", { role: "status", children: notice })] }));
+}

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

@@ -0,0 +1,9 @@
+import type { AgentOperation } from '@pascal-app/core/agent-operations';
+export type PipeOffsetInput = {
+    nodeId: string;
+    from: number;
+    to: number;
+    offset: number;
+};
+export declare const offsetPipe: AgentOperation<PipeOffsetInput>;
+//# sourceMappingURL=offset-operation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"offset-operation.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/offset-operation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,mCAAmC,CAAA;AASrF,MAAM,MAAM,eAAe,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAG1F,eAAO,MAAM,UAAU,EAAE,cAAc,CAAC,eAAe,CAuHtD,CAAA"}

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

@@ -0,0 +1,104 @@
+import { nodeRegistry, PipeSegmentNode } from '@pascal-app/core';
+import { refuse } from '@pascal-app/core/agent-tools';
+import { queryNodes } from '@pascal-app/core/runtime';
+import { Vector3 } from 'three';
+import { planPipeElbowAtPort } from '../shared/auto-fitting.js';
+import { autoOffsetInvalidationUpdates } from '../shared/auto-offset-tag.js';
+import { transferRunEndCapOwnership } from '../shared/automatic-run-end-cap.js';
+import { pipeGrade, pipeGradesMatch } from './slope.js';
+export const offsetPipe = (nodes, input) => {
+    const pipe = nodes[input.nodeId];
+    if (pipe?.type !== 'pipe-segment')
+        return refuse('pipe_not_found', 'Select a pipe run.');
+    if (!nodeRegistry.get('pipe-segment')?.ports || !nodeRegistry.get('pipe-fitting')?.ports)
+        return refuse('node_capability_unavailable', 'Register pipe and fitting definitions before editing.');
+    if (pipe.path.length !== 2 || ![input.from, input.to, input.offset].every(Number.isFinite))
+        return refuse('pipe_offset_route', 'Choose a straight run and enter finite offset dimensions.');
+    if (queryNodes(nodes, { parentId: pipe.id }).length > 0 ||
+        Object.keys(pipe.hangerOverrides ?? {}).length)
+        return refuse('pipe_offset_attachments', 'Remove custom hanger adjustments or hosted children before splitting this run.');
+    const start = new Vector3(...pipe.path[0]), end = new Vector3(...pipe.path[1]);
+    const delta = end.clone().sub(start);
+    const length = Math.hypot(delta.x, delta.z);
+    if (length < 0.001 || Math.abs(input.offset) < 0.001)
+        return refuse('pipe_offset_route', 'Choose a non-vertical run and a non-zero vertical offset.');
+    const axis = delta.clone().divideScalar(length);
+    const at = (distance) => start.clone().addScaledVector(axis, distance);
+    const travel = Math.abs(input.offset);
+    const a = at(input.from), b = at(input.from + travel).add(new Vector3(0, input.offset, 0));
+    const d = at(input.to), c = at(input.to - travel).add(new Vector3(0, input.offset, 0));
+    const corners = [start, a, b, c, d, end];
+    if (input.from <= 0 || input.to >= length || input.to - input.from <= 2 * travel)
+        return refuse('pipe_offset_space', 'Place the bends inside the run and allow more than twice the offset height between the first and last bend.');
+    const directions = corners.slice(1).map((point, i) => point.clone().sub(corners[i]).normalize());
+    const elbows = [a, b, c, d].map((corner, i) => {
+        const plan = planPipeElbowAtPort({
+            id: 'end',
+            nodeId: pipe.id,
+            position: corner.toArray(),
+            direction: directions[i].toArray(),
+            diameter: pipe.diameter,
+            system: pipe.system,
+        }, directions[i + 1].toArray(), pipe.diameter, pipe.pipeMaterial);
+        if (!plan)
+            return refuse('pipe_offset_angle', 'The requested bends cannot be formed on this route.');
+        return plan;
+    });
+    const paths = [
+        [start.toArray(), elbows[0].trimmedPortPoint],
+        [elbows[0].collarPoint, elbows[1].trimmedPortPoint],
+        [elbows[1].collarPoint, elbows[2].trimmedPortPoint],
+        [elbows[2].collarPoint, elbows[3].trimmedPortPoint],
+        [elbows[3].collarPoint, end.toArray()],
+    ];
+    for (const [i, path] of paths.entries()) {
+        const segment = new Vector3(...path[1]).sub(new Vector3(...path[0]));
+        if (!segment.toArray().every(Number.isFinite) ||
+            segment.length() < 0.001 ||
+            segment.normalize().dot(directions[i]) < 0.999999)
+            return refuse('pipe_offset_space', 'Not enough straight pipe between the bends. Increase the offset height or spacing, or move the bends away from the endpoints.');
+    }
+    if ([0, 2, 4].some((i) => !pipeGradesMatch(pipe.path, paths[i])))
+        return refuse('pipe_offset_grade', 'This offset cannot preserve the existing grade.');
+    const { id: _id, ...defaults } = pipe;
+    const newRuns = paths.slice(1).map((path) => PipeSegmentNode.parse({
+        ...defaults,
+        metadata: {},
+        path,
+        wallAttachment: undefined,
+        hangerOverrides: undefined,
+    }));
+    const changes = {
+        update: [
+            {
+                id: pipe.id,
+                data: { path: paths[0], wallAttachment: undefined, hangerOverrides: undefined },
+            },
+        ],
+        create: [
+            ...newRuns,
+            ...elbows.map((elbow) => ({ ...elbow.fitting, parentId: pipe.parentId })),
+        ].map((node) => ({ node, parentId: pipe.parentId ?? undefined })),
+    };
+    changes.update.push(...transferRunEndCapOwnership(nodes, pipe.id, newRuns.at(-1).id, 'end'));
+    for (const entry of autoOffsetInvalidationUpdates(nodes, pipe.id)) {
+        const existing = changes.update.find((update) => update.id === entry.id);
+        if (existing)
+            existing.data = { ...existing.data, ...entry.data };
+        else
+            changes.update.push(entry);
+    }
+    const grade = pipeGrade(pipe.path[0], pipe.path[1]);
+    const uphill = grade === 0 || paths.some((path) => (path[1][1] - path[0][1]) * Math.sign(grade) > 1e-6);
+    return {
+        changes,
+        result: {
+            message: 'Four-bend offset; boundary connections and parallel-run grades preserved.',
+            paths,
+            uphill: pipe.system === 'waste' && uphill,
+            offset: input.offset,
+            fittings: 4,
+            runs: 5,
+        },
+    };
+};

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

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAG5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAqFxE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAG5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CA6ExE,CAAA"}

package/dist/pipe-segment/parametrics.js

@@ -13,7 +13,7 @@ export const pipeSegmentParametrics = {
         ...findAutomaticRunEndCapIds(pipe.id, nodes, 'pipe-fitting'),
         ...fittingDeletionPlansForRun(pipe, nodes, requestedDeleteIds, false).flatMap((plan) => plan.deleteFitting ? [plan.fittingId, ...plan.cascadeDeleteIds] : []),
     ],
-    trailingSection: () => import('../shared/run-hanger-inspector.js'),
+    trailingSection: () => import('./grade-inspector.js'),
     groups: [
         {
             label: 'Hangers',
@@ -58,14 +58,6 @@ export const pipeSegmentParametrics = {
                     options: ['waste', 'vent'],
                     display: 'segmented',
                 },
-                {
-                    key: 'diameter',
-                    kind: 'number',
-                    unit: 'in',
-                    min: 1.25,
-                    max: 6,
-                    step: 0.25,
-                },
             ],
         },
         {

package/dist/pipe-segment/resize-inspector.d.ts

@@ -0,0 +1,5 @@
+import { type PipeSegmentNode } from '@pascal-app/core';
+export default function PipeResizeInspector({ node }: {
+    node: PipeSegmentNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=resize-inspector.d.ts.map

package/dist/pipe-segment/resize-inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-inspector.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/resize-inspector.tsx"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AAIzB,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,+BA+H9E"}

package/dist/pipe-segment/resize-inspector.js

@@ -0,0 +1,75 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { formatNumber, usePascalI18n, useScene, } from '@pascal-app/core';
+import { useState } from 'react';
+import { resizePipe } from './resize-operation.js';
+export default function PipeResizeInspector({ node }) {
+    const i18n = usePascalI18n();
+    const [diameter, setDiameter] = useState(node.diameter);
+    const [scope, setScope] = useState('segment');
+    const [message, setMessage] = useState('');
+    const apply = (preview) => {
+        try {
+            const outcome = resizePipe(useScene.getState().nodes, { nodeId: node.id, diameter, scope }, { activeLevelId: node.parentId });
+            if (preview || !outcome.changes) {
+                setMessage(outcome.changes
+                    ? i18n._({
+                        id: 'node.pipeSegment.resizeInspector.resizeSummary',
+                        message: '{runs, plural, one {# run} other {# runs}}, {fittings, plural, one {# fitting} other {# fittings}}, {reducers, plural, one {# new reducer} other {# new reducers}}. Grades stay unchanged.',
+                        values: {
+                            runs: Number(outcome.result.runs),
+                            fittings: Number(outcome.result.fittings),
+                            reducers: Number(outcome.result.reducers),
+                        },
+                    })
+                    : String(outcome.result.message));
+                return;
+            }
+            useScene.getState().applyNodeChanges({
+                create: outcome.changes.create?.map((entry) => ({
+                    ...entry,
+                    parentId: entry.parentId,
+                })),
+                update: outcome.changes.update?.map((entry) => ({ ...entry, id: entry.id })),
+            });
+            setMessage(i18n._({
+                id: 'node.pipeSegment.resizeInspector.resized',
+                message: 'Resized in one undo step. Grades and boundary connections preserved.',
+            }));
+        }
+        catch (error) {
+            setMessage(error instanceof Error
+                ? error.message
+                : i18n._({
+                    id: 'node.pipeSegment.resizeInspector.unableToResize',
+                    message: 'Unable to resize pipe.',
+                }));
+        }
+    };
+    return (_jsxs("section", { className: "space-y-2 border-t pt-3 text-xs", children: [_jsx("h3", { className: "text-sm font-medium", children: i18n._({ id: 'node.pipeSegment.resizeInspector.pipeSize', message: 'Pipe size' }) }), _jsx("p", { children: i18n._({
+                    id: 'node.pipeSegment.resizeInspector.currentDiameter',
+                    message: 'Current diameter: {diameter} in',
+                    values: { diameter: formatNumber(node.diameter, { locale: i18n.getLocale() }) },
+                }) }), _jsxs("label", { className: "flex justify-between", children: [i18n._({ id: 'node.pipeSegment.resizeInspector.diameterIn', message: 'Diameter (in)' }), _jsx("input", { "aria-label": i18n._({
+                            id: 'node.pipeSegment.resizeInspector.pipeResizeDiameter',
+                            message: 'Pipe resize diameter',
+                        }), type: "number", min: 1.25, max: 8, step: 0.25, value: Number.isFinite(diameter) ? diameter : '', onChange: (event) => {
+                            setDiameter(event.target.valueAsNumber);
+                            setMessage('');
+                        }, className: "w-24 border bg-background p-1" })] }), _jsxs("select", { "aria-label": i18n._({
+                    id: 'node.pipeSegment.resizeInspector.pipeResizeScope',
+                    message: 'Pipe resize scope',
+                }), value: scope, onChange: (event) => {
+                    setScope(event.target.value);
+                    setMessage('');
+                }, className: "w-full border bg-background p-1", children: [_jsx("option", { value: "segment", children: i18n._({ id: 'node.pipeSegment.resizeInspector.thisSegment', message: 'This segment' }) }), _jsx("option", { value: "branch", children: i18n._({
+                            id: 'node.pipeSegment.resizeInspector.connectedBranch',
+                            message: 'Connected branch',
+                        }) })] }), _jsx("p", { className: "text-muted-foreground", children: i18n._({
+                    id: 'node.pipeSegment.resizeInspector.branchesStopAtJunctionsSizeOr',
+                    message: 'Branches stop at junctions, size or material changes, and fixture connections. Reducers keep boundary collars fixed.',
+                }) }), _jsxs("div", { className: "flex gap-2", children: [_jsx("button", { type: "button", className: "flex-1 rounded border p-1", onClick: () => apply(true), children: i18n._({ id: 'node.pipeSegment.resizeInspector.checkResize', message: 'Check resize' }) }), _jsx("button", { type: "button", className: "flex-1 rounded border p-1", onClick: () => apply(false), children: i18n._({
+                            id: 'node.pipeSegment.resizeInspector.applyPipeSize',
+                            message: 'Apply pipe size',
+                        }) })] }), message && _jsx("p", { role: "status", children: message })] }));
+}