@pascal-app/nodes 1.0.7 → 1.1.1

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

@@ -1,14 +1,79 @@
-import type { NodeDefinition } from '@pascal-app/core';
-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 declare const pipeSegmentDefinition: NodeDefinition<typeof PipeSegmentNode>;
+export declare const pipeSegmentDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`pipe-segment_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"pipe-segment">>;
+    path: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    autoHangers: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    hangerOverrides: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        fraction: import("zod").ZodOptional<import("zod").ZodNumber>;
+        skipped: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        hostId: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>>;
+    hangerStyle: import("zod").ZodOptional<import("zod").ZodEnum<{
+        double: "double";
+        single: "single";
+    }>>;
+    hangerSpacing: import("zod").ZodOptional<import("zod").ZodNumber>;
+    hangerMaxReach: import("zod").ZodOptional<import("zod").ZodNumber>;
+    wallAttachment: import("zod").ZodOptional<import("zod").ZodObject<{
+        wallId: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`wall_${string}`>>;
+        side: import("zod").ZodEnum<{
+            back: "back";
+            front: "front";
+        }>;
+        startUV: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        endUV: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        offset: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+    diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    pipeMaterial: import("zod").ZodDefault<import("zod").ZodEnum<{
+        abs: "abs";
+        "cast-iron": "cast-iron";
+        pvc: "pvc";
+    }>>;
+    system: import("zod").ZodDefault<import("zod").ZodEnum<{
+        vent: "vent";
+        waste: "waste";
+    }>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAOtD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAgIxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGjC,CAAA"}

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

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { PipeSegmentNode } from './schema.js';
+export declare const pipeSegmentEditContribution: NodeEditContribution<typeof PipeSegmentNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

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;AAMvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAwCpF,CAAA"}

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

@@ -0,0 +1,46 @@
+import { createRunHangerToolHint } from '../shared/run-hanger-mode.js';
+import { pipeRunToolOptions } from '../shared/run-tool-options.js';
+import { pipeBranchAffordance, pipeContinuationAffordance } from './continuation.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,
+    // 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;AAGvE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAAC,GAAG;IACvF,IAAI,EAAE,cAAc,CAAA;CAiFrB,CAAA"}

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

@@ -0,0 +1,80 @@
+import { buildPipeSegmentFloorplan } from './floorplan.js';
+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,
+            },
+        ];
+    },
+    floorplan: buildPipeSegmentFloorplan,
+    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 { pipeContinuationHandlePlan, pipeEndpointPort } from './continuation-handle.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"}