@pascal-app/nodes 1.0.7 → 1.1.1

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

@@ -0,0 +1,91 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { formatFixed, usePascalI18n, useScene, } from '@pascal-app/core';
+import { useState } from 'react';
+import RunHangerInspector from '../shared/run-hanger-inspector.js';
+import { pipeGradeLabel } from './grade-label.js';
+import { editPipeGrade } from './grade-operation.js';
+import PipeOffsetInspector from './offset-inspector.js';
+import PipeResizeInspector from './resize-inspector.js';
+import { pipeGrade } from './slope.js';
+export default function PipeGradeInspector({ node }) {
+    return (_jsxs(_Fragment, { children: [_jsx(PipeResizeInspector, { node: node }, `size:${node.id}:${node.diameter}`), _jsx(GradeForm, { node: node }, `${node.id}:${JSON.stringify(node.path)}`), _jsx(PipeOffsetInspector, { node: node }, `offset:${node.id}`), _jsx(RunHangerInspector, { node: node })] }));
+}
+function GradeForm({ node }) {
+    const i18n = usePascalI18n();
+    const initial = pipeGrade(node.path[0], node.path[1]) ?? 0;
+    const [grade, setGrade] = useState(Math.abs(initial) * 100);
+    const [flow, setFlow] = useState(initial < 0 ? 'reverse' : 'forward');
+    const [anchor, setAnchor] = useState('start');
+    const [elevation, setElevation] = useState(node.path[0][1]);
+    const [message, setMessage] = useState('');
+    const apply = (input) => {
+        try {
+            const outcome = editPipeGrade(useScene.getState().nodes, { nodeId: node.id, action: 'grade', anchor, ...input }, { activeLevelId: node.parentId });
+            useScene.getState().applyNodeChanges({
+                update: outcome.changes?.update?.map((entry) => ({
+                    ...entry,
+                    id: entry.id,
+                })),
+            });
+            setMessage('Applied in one undo step.');
+        }
+        catch (error) {
+            setMessage(error instanceof Error ? error.message : 'Unable to edit 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.gradeInspector.gradeAndFlow', message: 'Grade and flow' }) }), _jsx("p", { children: i18n._({
+                    id: 'node.pipeSegment.gradeInspector.centerlineElevations',
+                    message: 'Centerline elevations above level: start {start} m · end {end} m',
+                    values: {
+                        start: formatFixed(node.path[0][1], 3, i18n.getLocale()),
+                        end: formatFixed(node.path.at(-1)[1], 3, i18n.getLocale()),
+                    },
+                }) }), node.path.slice(1).map((point, index) => (_jsx("p", { children: i18n._({
+                    id: 'node.pipeSegment.gradeInspector.leg',
+                    message: 'Leg {number}: {grade}',
+                    values: {
+                        number: String(index + 1),
+                        grade: pipeGradeLabel(node.path[index], point, i18n),
+                    },
+                }) }, `${index}:${point.join(',')}`))), _jsx("p", { className: "text-muted-foreground", children: i18n._({
+                    id: 'node.pipeSegment.gradeInspector.arrowsShowDownhillDirectionLevelRuns',
+                    message: 'Arrows show downhill direction. Level runs have no gravity fall. Editing a path point preserves each leg’s grade.',
+                }) }), _jsxs("label", { className: "flex justify-between", children: [i18n._({ id: 'node.pipeSegment.gradeInspector.grade', message: 'Grade (%)' }), _jsx("input", { "aria-label": i18n._({
+                            id: 'node.pipeSegment.gradeInspector.pipeGradePercent',
+                            message: 'Pipe grade percent',
+                        }), type: "number", min: 0, step: 0.1, value: Number.isFinite(grade) ? grade : '', onChange: (event) => setGrade(event.target.valueAsNumber), className: "w-24 border bg-background p-1" })] }), _jsxs("select", { "aria-label": i18n._({
+                    id: 'node.pipeSegment.gradeInspector.pipeDownhillFlow',
+                    message: 'Pipe downhill flow',
+                }), className: "w-full border bg-background p-1", value: flow, onChange: (event) => setFlow(event.target.value), children: [_jsx("option", { value: "forward", children: i18n._({ id: 'node.pipeSegment.gradeInspector.startEnd', message: 'Start → end' }) }), _jsx("option", { value: "reverse", children: i18n._({ id: 'node.pipeSegment.gradeInspector.endStart', message: 'End → start' }) })] }), _jsxs("select", { "aria-label": i18n._({
+                    id: 'node.pipeSegment.gradeInspector.fixedPipeEndpoint',
+                    message: 'Fixed pipe endpoint',
+                }), className: "w-full border bg-background p-1", value: anchor, onChange: (event) => {
+                    const next = event.target.value;
+                    setAnchor(next);
+                    setElevation(next === 'start' ? node.path[0][1] : node.path.at(-1)[1]);
+                }, children: [_jsx("option", { value: "start", children: i18n._({
+                            id: 'node.pipeSegment.gradeInspector.keepStartElevation',
+                            message: 'Keep start elevation',
+                        }) }), _jsx("option", { value: "end", children: i18n._({
+                            id: 'node.pipeSegment.gradeInspector.keepEndElevation',
+                            message: 'Keep end elevation',
+                        }) })] }), _jsx("button", { type: "button", className: "w-full rounded border p-1", onClick: () => apply({ gradePercent: grade, flow }), children: i18n._({
+                    id: 'node.pipeSegment.gradeInspector.applyGradeToHorizontalLegs',
+                    message: 'Apply grade to horizontal legs',
+                }) }), _jsxs("label", { className: "flex justify-between", children: [anchor === 'start'
+                        ? i18n._({
+                            id: 'node.pipeSegment.gradeInspector.startElevation',
+                            message: 'Start elevation (m)',
+                        })
+                        : i18n._({
+                            id: 'node.pipeSegment.gradeInspector.endElevation',
+                            message: 'End elevation (m)',
+                        }), _jsx("input", { "aria-label": i18n._({
+                            id: 'node.pipeSegment.gradeInspector.pipeAnchorElevation',
+                            message: 'Pipe anchor elevation',
+                        }), type: "number", step: 0.01, value: Number.isFinite(elevation) ? elevation : '', onChange: (event) => setElevation(event.target.valueAsNumber), className: "w-24 border bg-background p-1" })] }), _jsx("button", { type: "button", className: "w-full rounded border p-1", onClick: () => apply({ action: 'elevation', elevation }), children: i18n._({
+                    id: 'node.pipeSegment.gradeInspector.moveElevationKeepGrades',
+                    message: 'Move elevation, keep grades',
+                }) }), message && _jsx("p", { role: "status", children: message })] }));
+}

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

@@ -0,0 +1,7 @@
+import { type PascalI18n } from '@pascal-app/core';
+type Point = readonly [number, number, number];
+/** A grade's fall as plan labels and inspectors print it: a percentage to two decimals. */
+export declare function formatPipeGradePercent(grade: number, i18n: PascalI18n): string;
+export declare function pipeGradeLabel(start: Point, end: Point, i18n: PascalI18n): string;
+export {};
+//# sourceMappingURL=grade-label.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grade-label.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/grade-label.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAG/D,KAAK,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAE9C,2FAA2F;AAC3F,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAM9E;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAsBjF"}

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

@@ -0,0 +1,32 @@
+import { formatFixed } from '@pascal-app/core';
+import { pipeGrade } from './slope.js';
+/** A grade's fall as plan labels and inspectors print it: a percentage to two decimals. */
+export function formatPipeGradePercent(grade, i18n) {
+    return i18n._({
+        id: 'node.pipeSegment.grade.percent',
+        message: '{percent}%',
+        values: { percent: formatFixed(Math.abs(grade) * 100, 2, i18n.getLocale()) },
+    });
+}
+export function pipeGradeLabel(start, end, i18n) {
+    if (Math.hypot(...start.map((v, i) => v - end[i])) < 1e-6)
+        return i18n._({ id: 'node.pipeSegment.grade.chooseEndpoint', message: 'Choose an endpoint' });
+    const grade = pipeGrade(start, end);
+    if (grade === null)
+        return i18n._({
+            id: 'node.pipeSegment.grade.vertical',
+            message: 'Vertical · {direction, select, forward {start → end} other {end → start}} (down)',
+            values: { direction: start[1] > end[1] ? 'forward' : 'reverse' },
+        });
+    if (Math.abs(grade) < 1e-6)
+        return i18n._({ id: 'node.pipeSegment.grade.level', message: 'Level · no gravity fall' });
+    return i18n._({
+        id: 'node.pipeSegment.grade.sloped',
+        message: '{percent} · 1:{ratio} · {direction, select, forward {start → end} other {end → start}} (down)',
+        values: {
+            percent: formatPipeGradePercent(grade, i18n),
+            ratio: formatFixed(1 / Math.abs(grade), 1, i18n.getLocale()),
+            direction: grade > 0 ? 'forward' : 'reverse',
+        },
+    });
+}

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"}