@pascal-app/nodes 1.0.6 → 1.1.0

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

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

package/dist/pipe-segment/definition.edit.js

@@ -0,0 +1,48 @@
+import { createRunHangerToolHint } from '../shared/run-hanger-mode.js';
+import { pipeRunToolOptions } from '../shared/run-tool-options.js';
+import { pipeBranchAffordance, pipeContinuationAffordance } from './continuation.js';
+import { buildPipeSegmentFloorplan } from './floorplan.js';
+import { pipeGradePointAffordance } from './grade-affordance.js';
+import { pipeSegmentParametrics } from './parametrics.js';
+export const pipeSegmentEditContribution = {
+    drafting: { surfaceQuery: true, cancelOnHistoryJump: true },
+    // Directional run: like a wall, drafting sets a direction, so it takes the
+    // structural snapping context (grid / lines / angles / off) with a 45° angle
+    // lock available as a cyclable mode.
+    snapProfile: 'structural',
+    parametrics: pipeSegmentParametrics,
+    floorplanDependsOnSiblings: true,
+    floorplan: buildPipeSegmentFloorplan,
+    // 2D selection-time path-point handles — the floor-plan twin of the 3D
+    // `affordanceTools.selection` handles. The builder emits an
+    // `endpoint-handle` per path vertex; this drags the matching point.
+    floorplanAffordances: {
+        'move-path-point': pipeGradePointAffordance,
+        'continue-run': pipeContinuationAffordance,
+        'branch-run': pipeBranchAffordance,
+    },
+    // Selection-time path-point handles (drag to edit a committed run).
+    // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
+    // mounts via the editor's SelectionAffordanceManager — not `def.system`,
+    // which the viewer package mounts for the read-only route.
+    affordanceTools: {
+        selection: () => import('./selection.js'),
+        // Ghost-preview duplicate / move (the plumbing sibling of duct-segment's
+        // mover). Duplicate is pure drag-to-place: a translucent copy of the run,
+        // wrapped in a footprint bounding box, follows the cursor and only lands
+        // on the commit click — nothing is inserted into the scene before that.
+        move: () => import('./move-tool.js'),
+    },
+    tool: () => import('./tool.js'),
+    toolOptions: pipeRunToolOptions,
+    toolHints: [
+        { key: 'Click', label: 'Start run' },
+        { key: 'Click again', label: 'Place and continue' },
+        { key: 'Q', label: 'Waste / vent' },
+        { key: 'S', label: 'Slope / level' },
+        createRunHangerToolHint('pipe-segment'),
+        { key: '[ / ]', label: 'Pipe size down / up' },
+        { key: 'Alt + drag', label: 'Vertical stack ↕, click to place' },
+        { key: 'Esc', label: 'Exit drawing' },
+    ],
+};

package/dist/pipe-segment/definition.js

@@ -1,132 +1,4 @@
-import { createPathPointMoveAffordance } from '../shared/path-point-affordance.js';
-import { createRunHangerToolHint } from '../shared/run-hanger-mode.js';
-import { pipeBranchAffordance, pipeContinuationAffordance } from './continuation.js';
-import { buildPipeSegmentFloorplan } from './floorplan.js';
-import { buildPipeSegmentGeometry } from './geometry.js';
-import { pipeSegmentParametrics } from './parametrics.js';
-import { PipeSegmentNode } from './schema.js';
-/**
- * Phase 4 of the distribution-system effort (the research doc's Phase 2)
- * — DWV plumbing's first kind: the pipe run. The plumbing sibling of
- * `duct-segment`: same polyline + typed-ports model, with SLOPE as the
- * new ingredient (the draw tool drops waste runs ¼"/ft; vents run level
- * or vertical).
- *
- * Deferred to later slices: DWV fittings (wye / sanitary tee / closet
- * bend), fixtures, traps, cleanouts, IPC validators, riser view.
- */
-export const pipeSegmentDefinition = {
-    kind: 'pipe-segment',
-    schemaVersion: 2,
-    schema: PipeSegmentNode,
-    category: 'utility',
-    distributionRole: 'run',
-    drafting: { surfaceQuery: true, cancelOnHistoryJump: true },
-    // Directional run: like a wall, drafting sets a direction, so it takes the
-    // structural snapping context (grid / lines / angles / off) with a 45° angle
-    // lock available as a cyclable mode.
-    snapProfile: 'structural',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        autoHangers: false,
-        hangerStyle: 'single',
-        hangerSpacing: 1.5,
-        hangerMaxReach: 2,
-        path: [
-            [0, 0.0254, 0],
-            [3, 0.0254, 0],
-        ],
-        diameter: 2,
-        pipeMaterial: 'pvc',
-        system: 'waste',
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-    },
-    parametrics: pipeSegmentParametrics,
-    system: {
-        module: async () => ({
-            default: (await import('../shared/run-hanger-system.js')).PipeHangerSystem,
-        }),
-    },
-    floorplanDependsOnSiblings: true,
-    geometry: buildPipeSegmentGeometry,
-    // Open run ends as typed ports — system 'waste'/'vent' keeps the DWV
-    // network invisible to duct / refrigerant tools and vice versa.
-    ports: (n) => {
-        if (n.path.length < 2)
-            return [];
-        const unit = (a, b) => {
-            const d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-            const len = Math.hypot(d[0], d[1], d[2]);
-            return len < 1e-9 ? [1, 0, 0] : [d[0] / len, d[1] / len, d[2] / len];
-        };
-        const first = n.path[0];
-        const second = n.path[1];
-        const last = n.path[n.path.length - 1];
-        const prev = n.path[n.path.length - 2];
-        return [
-            {
-                id: 'start',
-                position: first,
-                direction: unit(first, second),
-                diameter: n.diameter,
-                system: n.system,
-            },
-            {
-                id: 'end',
-                position: last,
-                direction: unit(last, prev),
-                diameter: n.diameter,
-                system: n.system,
-            },
-        ];
-    },
-    floorplan: buildPipeSegmentFloorplan,
-    // 2D selection-time path-point handles — the floor-plan twin of the 3D
-    // `affordanceTools.selection` handles. The builder emits an
-    // `endpoint-handle` per path vertex; this drags the matching point.
-    floorplanAffordances: {
-        'move-path-point': createPathPointMoveAffordance('pipe-segment'),
-        'continue-run': pipeContinuationAffordance,
-        'branch-run': pipeBranchAffordance,
-    },
-    // Selection-time path-point handles (drag to edit a committed run).
-    // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
-    // mounts via the editor's SelectionAffordanceManager — not `def.system`,
-    // which the viewer package mounts for the read-only route.
-    affordanceTools: {
-        selection: () => import('./selection.js'),
-        // Ghost-preview duplicate / move (the plumbing sibling of duct-segment's
-        // mover). Duplicate is pure drag-to-place: a translucent copy of the run,
-        // wrapped in a footprint bounding box, follows the cursor and only lands
-        // on the commit click — nothing is inserted into the scene before that.
-        move: () => import('./move-tool.js'),
-    },
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Click', label: 'Start run' },
-        { key: 'Click again', label: 'Place and continue' },
-        { key: 'Q', label: 'Waste / vent' },
-        { key: 'S', label: 'Slope / level' },
-        createRunHangerToolHint('pipe-segment'),
-        { key: '[ / ]', label: 'Pipe size down / up' },
-        { key: 'Alt + drag', label: 'Vertical stack ↕, click to place' },
-        { key: 'Esc', label: 'Exit drawing' },
-    ],
-    presentation: {
-        label: 'DWV Pipe',
-        description: 'Drain / waste / vent pipe run — draw level or toggle a ¼″ per foot fall with S.',
-        icon: { kind: 'url', src: '/icons/dwv-pipes.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 95,
-    },
-    mcp: {
-        description: 'A DWV (drain-waste-vent) pipe run defined as a polyline. Waste runs slope downward (slope lives in the path Y coordinates); vents run level or vertical. Sized in nominal inches.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { pipeSegmentEditContribution } from './definition.edit.js';
+import { pipeSegmentRenderDefinition } from './definition.render.js';
+export const pipeSegmentDefinition = composeNodeDefinition(pipeSegmentRenderDefinition, pipeSegmentEditContribution);

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

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { PipeSegmentNode } from './schema.js';
+export declare const pipeSegmentRenderDefinition: NodeRenderDefinition<typeof PipeSegmentNode> & {
+    kind: 'pipe-segment';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAAC,GAAG;IACvF,IAAI,EAAE,cAAc,CAAA;CAgFrB,CAAA"}

package/dist/pipe-segment/definition.render.js

@@ -0,0 +1,78 @@
+import { buildPipeSegmentGeometry } from './geometry.js';
+import { PipeSegmentNode } from './schema.js';
+export const pipeSegmentRenderDefinition = {
+    kind: 'pipe-segment',
+    schemaVersion: 2,
+    schema: PipeSegmentNode,
+    category: 'utility',
+    distributionRole: 'run',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        autoHangers: false,
+        hangerStyle: 'single',
+        hangerSpacing: 1.5,
+        hangerMaxReach: 2,
+        path: [
+            [0, 0.0254, 0],
+            [3, 0.0254, 0],
+        ],
+        diameter: 2,
+        pipeMaterial: 'pvc',
+        system: 'waste',
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+    },
+    system: {
+        module: async () => ({
+            default: (await import('../shared/run-hanger-system.js')).PipeHangerSystem,
+        }),
+    },
+    geometry: buildPipeSegmentGeometry,
+    // Open run ends as typed ports — system 'waste'/'vent' keeps the DWV
+    // network invisible to duct / refrigerant tools and vice versa.
+    ports: (n) => {
+        if (n.path.length < 2)
+            return [];
+        const unit = (a, b) => {
+            const d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+            const len = Math.hypot(d[0], d[1], d[2]);
+            return len < 1e-9 ? [1, 0, 0] : [d[0] / len, d[1] / len, d[2] / len];
+        };
+        const first = n.path[0];
+        const second = n.path[1];
+        const last = n.path[n.path.length - 1];
+        const prev = n.path[n.path.length - 2];
+        return [
+            {
+                id: 'start',
+                position: first,
+                direction: unit(first, second),
+                diameter: n.diameter,
+                system: n.system,
+            },
+            {
+                id: 'end',
+                position: last,
+                direction: unit(last, prev),
+                diameter: n.diameter,
+                system: n.system,
+            },
+        ];
+    },
+    presentation: {
+        label: 'DWV Pipe',
+        description: 'Drain / waste / vent pipe run — draw level or choose grade and downhill direction.',
+        icon: { kind: 'url', src: '/icons/dwv-pipes.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 95,
+    },
+    mcp: {
+        description: 'A DWV (drain-waste-vent) pipe run defined as a polyline. Waste runs slope downward (slope lives in the path Y coordinates); vents run level or vertical. Sized in nominal inches.',
+    },
+};

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

@@ -1,4 +1,4 @@
-import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import { type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
 import type { PipeSegmentNode } from './schema.js';
 /**
  * Floor-plan representation of a DWV run, following drafting convention:

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

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

package/dist/pipe-segment/floorplan.js

@@ -1,6 +1,9 @@
-import { INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { defaultI18n, } from '@pascal-app/core';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 import { runHangerFloorplan } from '../shared/run-hangers.js';
 import { pipeContinuationHandlePlan, pipeEndpointPort } from './continuation.js';
+import { formatPipeGradePercent } from './grade-label.js';
+import { pipeGrade } from './slope.js';
 const WASTE_COLOR = '#57534e';
 const VENT_COLOR = '#78716c';
 /**
@@ -76,6 +79,36 @@ export function buildPipeSegmentFloorplan(node, ctx) {
     // Selection chrome: one draggable handle per path vertex (2D twin of the
     // 3D selection handles). Routes to the shared `move-path-point` affordance.
     if (view?.selected) {
+        for (let i = 1; i < node.path.length; i++) {
+            const a = node.path[i - 1], b = node.path[i];
+            const grade = pipeGrade(a, b);
+            if (grade === null || Math.abs(grade) < 1e-6)
+                continue;
+            const length = Math.hypot(b[0] - a[0], b[2] - a[2]);
+            const sign = Math.sign(grade), dx = ((b[0] - a[0]) / length) * sign, dz = ((b[2] - a[2]) / length) * sign;
+            const x = (a[0] + b[0]) / 2, z = (a[2] + b[2]) / 2, size = Math.min(0.12, length / 5);
+            children.push({
+                kind: 'polyline',
+                points: [
+                    [x - dx * size - (dz * size) / 2, z - dz * size + (dx * size) / 2],
+                    [x, z],
+                    [x - dx * size + (dz * size) / 2, z - dz * size - (dx * size) / 2],
+                ],
+                stroke,
+                strokeWidth: 2,
+                vectorEffect: 'non-scaling-stroke',
+            });
+            children.push({
+                kind: 'text',
+                x: x - dz * 0.18,
+                y: z + dx * 0.18,
+                text: formatPipeGradePercent(grade, defaultI18n),
+                fontSize: 0.12,
+                fill: stroke,
+                textAnchor: 'middle',
+                upright: true,
+            });
+        }
         for (let k = 0; k < points.length; k++) {
             children.push({
                 kind: 'endpoint-handle',

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAE,KAAK,EAAQ,oBAAoB,EAA2B,MAAM,OAAO,CAAA;AAGlF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAW/C,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE,KAAK,GAAG,KAAK,GAAG,WAAW,CAAA;IACzC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAA;CACzB,CAAA;AAQD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,oBAAoB,CAQ7E;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,KAAK,CAwB5F"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,EAAE,KAAK,EAAQ,oBAAoB,EAA2B,MAAM,OAAO,CAAA;AAIlF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAW/C,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE,KAAK,GAAG,KAAK,GAAG,WAAW,CAAA;IACzC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAA;CACzB,CAAA;AAQD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,oBAAoB,CAQ7E;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,KAAK,CAwB5F"}

package/dist/pipe-segment/geometry.js

@@ -1,5 +1,6 @@
 import { Group, Mesh, MeshStandardMaterial, SphereGeometry, Vector3 } from 'three';
-import { buildSection, INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { buildSection } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 import { buildRunHangers } from '../shared/run-hangers.js';
 const PVC_COLOR = '#f5f5f5';
 const ABS_COLOR = '#3a3a3a';

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

@@ -0,0 +1,8 @@
+import { type FloorplanAffordance, type PipeSegmentNode } from '@pascal-app/core';
+/** Shown when an endpoint drag (2D or 3D) is held because it would regrade or turn a collar. */
+export declare const pipeGradeBlockedNotice: {
+    id: string;
+    message: string;
+};
+export declare const pipeGradePointAffordance: FloorplanAffordance<PipeSegmentNode>;
+//# sourceMappingURL=grade-affordance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grade-affordance.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/grade-affordance.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,mBAAmB,EACxB,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AAUzB,gGAAgG;AAChG,eAAO,MAAM,sBAAsB;IACjC,EAAE;IACF,OAAO;CAER,CAAA;AAED,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,eAAe,CAoHzE,CAAA"}

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

@@ -0,0 +1,116 @@
+import { analyzePortConnectivity, defaultI18n, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { isGridSnapActive, snapPointToGrid, useFloorplanMode } from '@pascal-app/editor';
+import { planRunEndCapFollowUpdates } from '../shared/automatic-run-end-cap.js';
+import { detectFittingEndpoint, planFittingEndpointReaim } from '../shared/fitting-endpoint-reaim.js';
+import { editPipeGrade, pipeUpdatesPreserveGrades } from './grade-operation.js';
+import { pipeGradesMatch, preservePipeGrades } from './slope.js';
+/** Shown when an endpoint drag (2D or 3D) is held because it would regrade or turn a collar. */
+export const pipeGradeBlockedNotice = /* i18n */ {
+    id: 'node.pipeSegment.gradeNotice.blocked',
+    message: 'This edit cannot preserve the pipe grade and connected collars. Adjust the fitting or use Grade and flow.',
+};
+export const pipeGradePointAffordance = {
+    start({ node, payload, nodes }) {
+        const index = payload.pointIndex;
+        const initialPath = node.path.map((p) => [...p]);
+        const point = initialPath[index];
+        const isEndpoint = index === 0 || index === initialPath.length - 1;
+        // Like the 3D handles: a straight run whose other end sits on an elbow
+        // swings that elbow to follow the drag instead of refusing the turn.
+        const fittingEndpoint = isEndpoint
+            ? detectFittingEndpoint('pipe-segment', initialPath, index, nodes)
+            : null;
+        let updates = [];
+        let noticeId = null;
+        const previewIds = new Set();
+        const clear = () => {
+            for (const id of previewIds) {
+                useLiveNodeOverrides.getState().clear(id);
+                useScene.getState().markDirty(id);
+            }
+            previewIds.clear();
+        };
+        const showNotice = () => {
+            const floorplan = useFloorplanMode.getState();
+            if (noticeId !== null && floorplan.notice?.id === noticeId)
+                return;
+            floorplan.showNotice(defaultI18n._(pipeGradeBlockedNotice));
+            noticeId = useFloorplanMode.getState().notice?.id ?? null;
+        };
+        const dismissNotice = () => {
+            const floorplan = useFloorplanMode.getState();
+            if (noticeId !== null && floorplan.notice?.id === noticeId)
+                floorplan.dismissNotice();
+            noticeId = null;
+        };
+        const reaimUpdates = (dragged) => {
+            if (!fittingEndpoint)
+                return null;
+            const constrained = preservePipeGrades(initialPath, initialPath.map((p, i) => (i === index ? dragged : p)), index);
+            const plan = constrained
+                ? planFittingEndpointReaim(fittingEndpoint, index, constrained[index])
+                : null;
+            if (!plan || !pipeGradesMatch(initialPath, plan.path))
+                return null;
+            const next = [
+                { id: node.id, data: { path: plan.path, wallAttachment: undefined } },
+                plan.fittingUpdate,
+                ...planRunEndCapFollowUpdates(node, { ...node, path: plan.path }, index === 0 ? 'start' : 'end', nodes),
+            ];
+            return pipeUpdatesPreserveGrades(nodes, next) ? next : null;
+        };
+        const gradedUpdates = (dragged, detach) => {
+            try {
+                const outcome = editPipeGrade(nodes, { nodeId: node.id, action: 'endpoint', pointIndex: index, point: dragged, detach }, { activeLevelId: node.parentId });
+                return (outcome.changes?.update ?? []).map((entry) => ({
+                    ...entry,
+                    id: entry.id,
+                }));
+            }
+            catch {
+                return null;
+            }
+        };
+        return {
+            affectedIds: [
+                ...new Set([
+                    node.id,
+                    ...(fittingEndpoint ? [fittingEndpoint.fitting.id] : []),
+                    ...analyzePortConnectivity(node, nodes).connections.map((connection) => connection.nodeId),
+                ]),
+            ],
+            apply({ planPoint, modifiers }) {
+                if (!point)
+                    return;
+                const [x, z] = isGridSnapActive()
+                    ? snapPointToGrid([planPoint[0], planPoint[1]])
+                    : planPoint;
+                const dragged = [x, point[1], z];
+                const next = fittingEndpoint && !modifiers.altKey
+                    ? reaimUpdates(dragged)
+                    : gradedUpdates(dragged, modifiers.altKey);
+                // A refused frame keeps the last valid preview, as the 3D handles do.
+                if (!next) {
+                    showNotice();
+                    return;
+                }
+                dismissNotice();
+                clear();
+                updates = next;
+                useLiveNodeOverrides
+                    .getState()
+                    .setMany(updates.map((entry) => [entry.id, entry.data]));
+                for (const entry of updates) {
+                    previewIds.add(entry.id);
+                    useScene.getState().markDirty(entry.id);
+                }
+            },
+            canCommit: () => updates.length > 0,
+            commit() {
+                dismissNotice();
+                clear();
+                useScene.getState().updateNodes(updates);
+            },
+        };
+    },
+};

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

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

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

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

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',
+        },
+    });
+}