@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/pipe-segment/tool.js

@@ -1,9 +1,9 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { PipeSegmentNode } from '@pascal-app/core';
+import { formatFixed, PipeSegmentNode, usePascalI18n, } from '@pascal-app/core';
 import { EDITOR_LAYER, triggerSFX, useEditor, usePathDraftPreview, useRegistryToolContext, } from '@pascal-app/editor';
 import { collectScenePorts, createRunWallAttachment, DistributionRunCursor, findNearestRunBody3D, findRunBodyCrossingSurface, RUN_PREVIEW_OPACITY, runDistanceSquared, stepNominalRunSize, useDistributionRunTool, } from '@pascal-app/editor/distribution';
-import { useEffect, useRef, useState } from 'react';
+import { useEffect, useRef } from 'react';
 import { Vector3 } from 'three';
 import { planPipeBranchTap, planPipeCrossAtRunBody, planPipeElbowAtPort, } from '../shared/auto-fitting.js';
 import { createPipeRunEndCap, findMatedRunEndCapIds, isRunEndCapPort, } from '../shared/automatic-run-end-cap.js';
@@ -14,9 +14,13 @@ import { PipeFittingGhost } from '../shared/mep-ghost.js';
 import { DWV_PORT_SYSTEMS, runSectionHalfSizeM } from '../shared/port-systems.js';
 import { RunHangerPreview } from '../shared/run-hanger-controls.js';
 import { useRunHangerMode } from '../shared/run-hanger-mode.js';
-import { currentPipeContinuationSeed, pipeEndpointPort } from './continuation.js';
+import { clearRunContinuation, updateRunDefaults } from '../shared/run-tool-options.js';
+import { planPipeCollarConnection } from './collar-connection.js';
+import { currentPipeContinuationSeed } from './continuation.js';
+import { pipeEndpointPort } from './continuation-handle.js';
 import { pipeSegmentDefinition } from './definition.js';
-import { applyPipeGrade } from './slope.js';
+import { pipeGradeLabel } from './grade-label.js';
+import { applyPipeGrade, pipeGrade } from './slope.js';
 const PIPE_DIAMETERS_IN = [1.25, 1.5, 2, 3, 4, 6];
 const BODY_SNAP_RADIUS_M = 0.3;
 function getConnectionPorts(levelId, nodes) {
@@ -26,6 +30,7 @@ function getConnectionPorts(levelId, nodes) {
     }).filter((port) => !isRunEndCapPort(port, nodes));
 }
 const PipeSegmentTool = () => {
+    const i18n = usePascalI18n();
     const { activeLevelId, sceneApi, unit } = useRegistryToolContext();
     const toolDefaults = useEditor((s) => s.toolDefaults['pipe-segment']);
     const continuationSeedRef = useRef(currentPipeContinuationSeed());
@@ -42,14 +47,20 @@ const PipeSegmentTool = () => {
     autoHangersRef.current = autoHangers;
     const pendingPromotionRef = useRef(continuationSeed?.promotedFitting ?? null);
     const defaults = pipeSegmentDefinition.defaults();
-    const [system, setSystem] = useState(continuationSeed?.pipe.system ?? toolDefaults?.system ?? defaults.system);
-    const [sloped, setSloped] = useState(false);
-    const slopePercent = 100 / 48;
-    const slopeDirection = 1;
+    const system = toolDefaults?.system ?? continuationSeed?.pipe.system ?? defaults.system;
+    const setSystem = (value) => updateRunDefaults('pipe-segment', {
+        system: typeof value === 'function' ? value(system) : value,
+    });
+    const sloped = hangerDefaults?.fall === 'sloped';
+    const setSloped = (value) => updateRunDefaults('pipe-segment', { fall: value(sloped) ? 'sloped' : 'level' });
+    const slopePercent = typeof hangerDefaults?.gradePercent === 'number' ? hangerDefaults.gradePercent : 100 / 48;
+    const slopeDirection = hangerDefaults?.flowDirection === 'reverse' ? -1 : 1;
     const gradeRef = useRef(slopePercent / 100);
     gradeRef.current = (slopeDirection * slopePercent) / 100;
-    const [diameter, setDiameter] = useState(continuationSeed?.pipe.diameter ?? toolDefaults?.diameter ?? defaults.diameter);
-    const [pipeMaterial, setPipeMaterial] = useState(continuationSeed?.pipe.pipeMaterial ?? toolDefaults?.pipeMaterial ?? defaults.pipeMaterial);
+    const diameter = toolDefaults?.diameter ?? continuationSeed?.pipe.diameter ?? defaults.diameter;
+    const setDiameter = (diameter) => updateRunDefaults('pipe-segment', { diameter });
+    const pipeMaterial = toolDefaults?.pipeMaterial ?? continuationSeed?.pipe.pipeMaterial ?? defaults.pipeMaterial;
+    const setPipeMaterial = (pipeMaterial) => updateRunDefaults('pipe-segment', { pipeMaterial });
     const systemRef = useRef(system);
     systemRef.current = system;
     const slopedRef = useRef(sloped);
@@ -61,18 +72,21 @@ const PipeSegmentTool = () => {
     useEffect(() => {
         const mode = useRunHangerMode.getState();
         mode.setEnabled('pipe-segment', initialAutoHangersRef.current);
-        return () => mode.setEnabled('pipe-segment', false);
+        return () => {
+            updateRunDefaults('pipe-segment', {
+                autoHangers: useRunHangerMode.getState().enabled['pipe-segment'],
+            });
+            mode.setEnabled('pipe-segment', false);
+        };
     }, []);
     useEffect(() => {
-        if (!toolDefaults)
-            return;
-        if (toolDefaults.system)
-            setSystem(toolDefaults.system);
-        if (typeof toolDefaults.diameter === 'number')
-            setDiameter(toolDefaults.diameter);
-        if (toolDefaults.pipeMaterial)
-            setPipeMaterial(toolDefaults.pipeMaterial);
-    }, [toolDefaults]);
+        if (continuationSeed)
+            updateRunDefaults('pipe-segment', {
+                system: continuationSeed.pipe.system,
+                diameter: continuationSeed.pipe.diameter,
+                pipeMaterial: continuationSeed.pipe.pipeMaterial,
+            });
+    }, [continuationSeed]);
     const commitSegment = ({ start: rawStart, end, startConnection, endConnection, surfaceTarget, previewOnly = false, }) => {
         if (!activeLevelId)
             return null;
@@ -114,15 +128,35 @@ const PipeSegmentTool = () => {
         ];
         const startBend = bendPlanFor(promotedFitting ? null : startConnection.port, direction);
         const endBend = bendPlanFor(endConnection.port, [-direction[0], -direction[1], -direction[2]]);
-        const invalidPlan = () => previewOnly
+        const invalidPlan = (message = FITTING_CLEARANCE_MESSAGE) => previewOnly
             ? {
-                validationMessage: FITTING_CLEARANCE_MESSAGE,
+                validationMessage: message,
                 nextStart: rawStart,
                 nextConnection: startConnection,
                 previewPipes: [],
                 previewFittings: [],
             }
             : null;
+        const fixedConnection = (port, toward) => {
+            const owner = port && sceneApi.get(port.nodeId);
+            return port && owner && owner.type !== 'pipe-segment'
+                ? planPipeCollarConnection(sceneApi.nodes(), port, toward, diameterRef.current, systemRef.current, pipeMaterialRef.current)
+                : null;
+        };
+        let startCollar, endCollar;
+        try {
+            startCollar = fixedConnection(promotedFitting ? null : startConnection.port, end);
+            endCollar = fixedConnection(endConnection.port, start);
+        }
+        catch (error) {
+            return invalidPlan(error instanceof Error ? error.message : 'Unable to connect collar.');
+        }
+        const actualGrade = pipeGrade(start, end);
+        if (slopedRef.current &&
+            systemRef.current === 'waste' &&
+            actualGrade !== null &&
+            Math.abs(actualGrade - gradeRef.current) > 1e-5)
+            return invalidPlan('The connection elevation conflicts with the chosen grade. Adjust the grade or target elevation.');
         if (startBend?.hasClearance === false || endBend?.hasClearance === false)
             return invalidPlan();
         const startBody = startBend ? null : startConnection.body;
@@ -137,10 +171,10 @@ const PipeSegmentTool = () => {
             : null;
         if (endBody?.nodeId === startBody?.nodeId)
             endTap = null;
-        const pipeStart = startBend?.collarPoint ?? startTap?.branchCollar ?? start;
-        const pipeEnd = endBend?.collarPoint ?? endTap?.branchCollar ?? end;
+        const pipeStart = startBend?.collarPoint ?? startTap?.branchCollar ?? startCollar?.point ?? start;
+        const pipeEnd = endBend?.collarPoint ?? endTap?.branchCollar ?? endCollar?.point ?? end;
         const bends = [startBend, endBend].filter((plan) => plan !== null);
-        const crossHit = surfaceTarget
+        const crossHit = surfaceTarget && hangerDefaults?.crossingMode !== 'cross'
             ? findRunBodyCrossingSurface(start, end, BODY_SNAP_RADIUS_M, surfaceTarget, {
                 kinds: ['pipe-segment'],
             })
@@ -192,6 +226,13 @@ const PipeSegmentTool = () => {
             return { ...pipe, wallAttachment };
         };
         const attachedPipes = pipes.map(attachPipe);
+        if (slopedRef.current &&
+            systemRef.current === 'waste' &&
+            attachedPipes.some((pipe) => {
+                const grade = pipeGrade(pipe.path[0], pipe.path.at(-1));
+                return grade !== null && Math.abs(grade - gradeRef.current) > 1e-5;
+            }))
+            return invalidPlan('The fitting collars cannot maintain the chosen grade. Adjust the connection or grade.');
         const sceneNodes = sceneApi.nodes();
         const consumedEndCapIds = Array.from(new Set([
             ...findMatedRunEndCapIds(startConnection.port, sceneNodes, 'pipe-fitting'),
@@ -205,6 +246,10 @@ const PipeSegmentTool = () => {
         const nextEndCap = nextPipe && !endConnection.port && !endConnection.body ? createPipeRunEndCap(nextPipe) : null;
         const changes = {
             create: [
+                ...[...(startCollar?.fittings ?? []), ...(endCollar?.fittings ?? [])].map((node) => ({
+                    node,
+                    parentId: activeLevelId,
+                })),
                 ...bends.map((plan) => ({
                     node: plan.fitting,
                     parentId: activeLevelId,
@@ -261,6 +306,10 @@ const PipeSegmentTool = () => {
                 throw new Error('Registry SceneApi must support atomic changes');
             sceneApi.applyChanges(changes);
             pendingPromotionRef.current = null;
+            // A riser out of a fixed collar reaches the target; staying vertical would aim the
+            // next section at the riser's own top.
+            if (startCollar && hangerDefaults?.routingMode === 'vertical')
+                updateRunDefaults('pipe-segment', { routingMode: 'horizontal' });
         }
         const nextStart = nextPipe ? nextPipe.path[nextPipe.path.length - 1] : end;
         const nextPort = nextPipe ? pipeEndpointPort(nextPipe, 'end') : endConnection.port;
@@ -281,6 +330,12 @@ const PipeSegmentTool = () => {
         active: !!activeLevelId,
         levelId: activeLevelId,
         toolName: 'pipe-segment',
+        routingMode: hangerDefaults?.routingMode === 'horizontal' || hangerDefaults?.routingMode === 'vertical'
+            ? hangerDefaults.routingMode
+            : 'surface',
+        elevation: typeof hangerDefaults?.elevation === 'number' ? hangerDefaults.elevation : 0,
+        targetElevation: typeof hangerDefaults?.targetElevation === 'number' ? hangerDefaults.targetElevation : 3,
+        connectCrossings: hangerDefaults?.crossingMode !== 'cross',
         initialStart: continuationSeed
             ? [
                 ...(continuationSeed.port?.position ?? continuationSeed.body?.point ?? [0, 0, 0]),
@@ -297,6 +352,14 @@ const PipeSegmentTool = () => {
         surfaceClearance: (surface) => (surface ? runSectionHalfSizeM(diameterRef.current) : 0),
         minimumSegmentLength: 0.05,
         resolveFreeEnd: (start, end, startConnection) => {
+            const port = startConnection.port;
+            if (port &&
+                sceneApi.get(port.nodeId)?.type !== 'pipe-segment' &&
+                !pendingPromotionRef.current) {
+                const axis = new Vector3(...port.direction).normalize();
+                const distance = Math.max(0, new Vector3(...end).sub(new Vector3(...start)).dot(axis));
+                return new Vector3(...start).addScaledVector(axis, distance).toArray();
+            }
             if (!slopedRef.current || systemRef.current !== 'waste')
                 return end;
             return applyPipeGrade(start, end, gradeRef.current);
@@ -304,11 +367,34 @@ const PipeSegmentTool = () => {
         inheritFromConnection: ({ port, body }) => {
             const ownerId = port?.nodeId ?? body?.nodeId;
             const owner = ownerId ? sceneApi.get(ownerId) : null;
-            if (owner?.type !== 'pipe-segment')
+            if (owner?.type !== 'pipe-segment') {
+                if (port && (port.system === 'waste' || port.system === 'vent')) {
+                    setDiameter(port.diameter);
+                    setSystem(port.system);
+                    if (owner && 'pipeMaterial' in owner)
+                        setPipeMaterial(owner.pipeMaterial);
+                    const grade = pipeGrade([0, 0, 0], [...port.direction]) ?? 0;
+                    updateRunDefaults('pipe-segment', {
+                        fall: Math.abs(grade) > 1e-6 ? 'sloped' : 'level',
+                        gradePercent: Math.abs(grade) * 100,
+                        flowDirection: grade < 0 ? 'reverse' : 'forward',
+                    });
+                }
                 return;
+            }
             setDiameter(owner.diameter);
             setPipeMaterial(owner.pipeMaterial);
             setSystem(owner.system);
+            const index = body?.segmentIndex ?? (port?.id === 'start' ? 0 : owner.path.length - 2);
+            const grade = pipeGrade(owner.path[index], owner.path[index + 1]);
+            if (grade !== null) {
+                const inherited = port?.id === 'start' ? -grade : grade;
+                updateRunDefaults('pipe-segment', {
+                    fall: Math.abs(grade) > 1e-6 ? 'sloped' : 'level',
+                    gradePercent: Math.abs(grade) * 100,
+                    flowDirection: inherited < 0 ? 'reverse' : 'forward',
+                });
+            }
         },
         commit: commitSegment,
         onShortcut: (event) => {
@@ -342,7 +428,7 @@ const PipeSegmentTool = () => {
     useEffect(() => {
         if (!run.altActive)
             refreshCursor();
-    }, [sloped, system, run.altActive, refreshCursor]);
+    }, [sloped, slopePercent, slopeDirection, system, diameter, run.altActive, refreshCursor]);
     const displayStart = run.start;
     const previewPlan = run.start && run.cursor
         ? commitSegment({
@@ -365,10 +451,20 @@ const PipeSegmentTool = () => {
         });
     }, [autoHangers, hangerStyle, diameter, displayStart, run.cursor, system]);
     useEffect(() => () => usePathDraftPreview.getState().clear('pipe-segment'), []);
-    useEffect(() => () => useEditor.getState().setToolDefaults('pipe-segment', null), []);
+    useEffect(() => () => clearRunContinuation('pipe-segment'), []);
     if (!activeLevelId)
         return null;
-    return (_jsxs(LevelOffsetGroup, { children: [_jsx(ConnectionFeedback, { point: run.cursor, target: run.endConnection.port, levelId: activeLevelId, profile: { diameter, system } }), _jsx(DistributionRunCursor, { altActive: run.altActive, cursor: run.cursor, directionMode: run.directionMode, extraParts: [{ key: 'diameter', prefix: 'Ø', value: diameter * 0.0254 }], lengthInput: run.lengthInput, onLengthInputChange: run.onLengthInputChange, onDirectionSelect: run.onDirectionSelect, validationMessage: previewPlan?.validationMessage ?? run.validationMessage, snapTarget: run.snapTarget, snapScreen: run.snapScreen, start: displayStart, startDirection: run.startConnection.port?.direction ?? null, unit: unit }), run.snapTarget && (_jsxs("mesh", { layers: EDITOR_LAYER, position: run.snapTarget, children: [_jsx("sphereGeometry", { args: [0.1, 24, 16] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: 0.35, transparent: true })] })), displayStart && (_jsxs("mesh", { layers: EDITOR_LAYER, position: displayStart, children: [_jsx("sphereGeometry", { args: [0.05, 16, 12] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false })] })), previewPlan?.previewPipes.map((pipe, index) => (_jsx(PreviewPipe, { a: pipe.path[0], b: pipe.path.at(-1), diameterIn: diameter }, index))), previewPlan?.previewPipes.map((pipe, index) => (_jsx(RunHangerPreview, { run: pipe, levelId: activeLevelId }, `hanger-${index}`))), previewPlan?.previewFittings.map((fitting, index) => (_jsx(PipeFittingGhost, { fitting: fitting }, index)))] }));
+    return (_jsxs(LevelOffsetGroup, { children: [_jsx(ConnectionFeedback, { detail: displayStart && run.cursor
+                    ? i18n._({
+                        id: 'node.pipeSegment.tool.gradeDetail',
+                        message: '{grade} · Start {start} m · End {end} m above level',
+                        values: {
+                            grade: pipeGradeLabel(displayStart, run.cursor, i18n),
+                            start: formatFixed(displayStart[1], 3, i18n.getLocale()),
+                            end: formatFixed(run.cursor[1], 3, i18n.getLocale()),
+                        },
+                    })
+                    : undefined, point: run.cursor, target: run.endConnection.port, screen: run.snapScreen ?? run.cursorScreen, error: run.cursorScreen ? (previewPlan?.validationMessage ?? run.validationMessage) : undefined, levelId: activeLevelId, profile: { diameter, system } }), _jsx(DistributionRunCursor, { altActive: run.altActive, cursor: run.cursor, directionMode: run.directionMode, routingMode: run.routingMode, extraParts: [{ key: 'diameter', prefix: 'Ø', value: diameter * 0.0254 }], lengthInput: run.lengthInput, onLengthInputChange: run.onLengthInputChange, onDirectionSelect: run.onDirectionSelect, validationMessage: previewPlan?.validationMessage ?? run.validationMessage, snapTarget: run.snapTarget, snapScreen: run.snapScreen, start: displayStart, startDirection: run.startConnection.port?.direction ?? null, unit: unit }), run.snapTarget && (_jsxs("mesh", { layers: EDITOR_LAYER, position: run.snapTarget, children: [_jsx("sphereGeometry", { args: [0.1, 24, 16] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: 0.35, transparent: true })] })), displayStart && (_jsxs("mesh", { layers: EDITOR_LAYER, position: displayStart, children: [_jsx("sphereGeometry", { args: [0.05, 16, 12] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false })] })), previewPlan?.previewPipes.map((pipe, index) => (_jsx(PreviewPipe, { a: pipe.path[0], b: pipe.path.at(-1), diameterIn: diameter }, index))), previewPlan?.previewPipes.map((pipe, index) => (_jsx(RunHangerPreview, { run: pipe, levelId: activeLevelId }, `hanger-${index}`))), previewPlan?.previewFittings.map((fitting, index) => (_jsx(PipeFittingGhost, { fitting: fitting }, index)))] }));
 };
 function PreviewPipe({ a, b, diameterIn }) {
     const start = new Vector3(...a);

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

@@ -1,10 +1,55 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { PipeTrapNode } from './schema.js';
-/**
- * DWV P-trap — the water-seal fitting on the waste line. Placed by its
- * own click tool; the pipe tool then draws the trap arm off the outlet.
- * Modeled explicitly so the IPC 909.1 trap-arm rule has a node to
- * validate.
- */
-export declare const pipeTrapDefinition: NodeDefinition<typeof PipeTrapNode>;
+export declare const pipeTrapDefinition: 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-trap_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"pipe-trap">>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    pipeMaterial: import("zod").ZodDefault<import("zod").ZodEnum<{
+        abs: "abs";
+        "cast-iron": "cast-iron";
+        pvc: "pvc";
+    }>>;
+    armLengthM: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,YAAY,CAyDlE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG9B,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE5C,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,OAAO,YAAY,CAS9E,CAAA"}

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

@@ -0,0 +1,11 @@
+import { pipeTrapParametrics } from './parametrics.js';
+export const pipeTrapEditContribution = {
+    snapProfile: 'item',
+    parametrics: pipeTrapParametrics,
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Click', label: 'Place trap' },
+        { key: 'R / T', label: 'Rotate ±45°' },
+        { key: 'Esc', label: 'Exit' },
+    ],
+};

package/dist/pipe-trap/definition.js

@@ -1,59 +1,4 @@
-import { buildPipeTrapFloorplan } from './floorplan.js';
-import { buildPipeTrapGeometry } from './geometry.js';
-import { pipeTrapParametrics } from './parametrics.js';
-import { getPipeTrapPorts } from './ports.js';
-import { PipeTrapNode } from './schema.js';
-/**
- * DWV P-trap — the water-seal fitting on the waste line. Placed by its
- * own click tool; the pipe tool then draws the trap arm off the outlet.
- * Modeled explicitly so the IPC 909.1 trap-arm rule has a node to
- * validate.
- */
-export const pipeTrapDefinition = {
-    kind: 'pipe-trap',
-    schemaVersion: 1,
-    schema: PipeTrapNode,
-    category: 'utility',
-    distributionRole: 'fitting',
-    snapProfile: 'item',
-    portConnectivityFollow: false, // trap is anchored; dragging a connected run stretches the arm, not the trap
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        position: [0, 0, 0],
-        rotation: 0,
-        diameter: 2,
-        pipeMaterial: 'pvc',
-        armLengthM: 0,
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        movable: { axes: ['x', 'y', 'z'], gridSnap: true, portSnap: { systems: ['waste'] } },
-        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
-        duplicable: true,
-        deletable: true,
-    },
-    parametrics: pipeTrapParametrics,
-    geometry: buildPipeTrapGeometry,
-    geometryKey: (n) => JSON.stringify([n.diameter, n.pipeMaterial, n.armLengthM]),
-    ports: getPipeTrapPorts,
-    floorplan: buildPipeTrapFloorplan,
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Click', label: 'Place trap' },
-        { key: 'R / T', label: 'Rotate ±45°' },
-        { key: 'Esc', label: 'Exit' },
-    ],
-    presentation: {
-        label: 'Trap',
-        description: 'DWV P-trap — water seal on the waste line. The trap arm runs to the vent.',
-        icon: { kind: 'url', src: '/icons/dwv-pipes.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 98,
-    },
-    mcp: {
-        description: 'A DWV P-trap with inlet (up) and outlet (trap arm) ports. Position is level-local meters; rotation is yaw radians. armLengthM is the trap-arm developed length checked against IPC 909.1.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { pipeTrapEditContribution } from './definition.edit.js';
+import { pipeTrapRenderDefinition } from './definition.render.js';
+export const pipeTrapDefinition = composeNodeDefinition(pipeTrapRenderDefinition, pipeTrapEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,OAAO,YAAY,CAAC,GAAG;IACjF,IAAI,EAAE,WAAW,CAAA;CA2ClB,CAAA"}

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

@@ -0,0 +1,45 @@
+import { buildPipeTrapFloorplan } from './floorplan.js';
+import { buildPipeTrapGeometry } from './geometry.js';
+import { getPipeTrapPorts } from './ports.js';
+import { PipeTrapNode } from './schema.js';
+export const pipeTrapRenderDefinition = {
+    kind: 'pipe-trap',
+    schemaVersion: 1,
+    schema: PipeTrapNode,
+    category: 'utility',
+    distributionRole: 'fitting',
+    portConnectivityFollow: false,
+    // trap is anchored; dragging a connected run stretches the arm, not the trap
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: 0,
+        diameter: 2,
+        pipeMaterial: 'pvc',
+        armLengthM: 0,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        movable: { axes: ['x', 'y', 'z'], gridSnap: true, portSnap: { systems: ['waste'] } },
+        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
+        duplicable: true,
+        deletable: true,
+    },
+    geometry: buildPipeTrapGeometry,
+    geometryKey: (n) => JSON.stringify([n.diameter, n.pipeMaterial, n.armLengthM]),
+    ports: getPipeTrapPorts,
+    floorplan: buildPipeTrapFloorplan,
+    presentation: {
+        label: 'Trap',
+        description: 'DWV P-trap — water seal on the waste line. The trap arm runs to the vent.',
+        icon: { kind: 'url', src: '/icons/dwv-pipes.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 98,
+    },
+    mcp: {
+        description: 'A DWV P-trap with inlet (up) and outlet (trap arm) ports. Position is level-local meters; rotation is yaw radians. armLengthM is the trap-arm developed length checked against IPC 909.1.',
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,EAAuC,OAAO,EAAE,MAAM,OAAO,CAAA;AAGvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAc5C;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,GAAG,KAAK,CAmD/D;AAED;sEACsE;AACtE,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG;IAClD,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;CAChB,CASA"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,EAAuC,OAAO,EAAE,MAAM,OAAO,CAAA;AAIvF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAc5C;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,GAAG,KAAK,CAmD/D;AAED;sEACsE;AACtE,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG;IAClD,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;CAChB,CASA"}

package/dist/pipe-trap/geometry.js

@@ -1,5 +1,6 @@
 import { DoubleSide, Group, Mesh, SphereGeometry, TorusGeometry, 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 { createPipeMaterial } from '../pipe-segment/geometry.js';
 const BEND_SEGMENTS = 24;
 const RADIAL_SEGMENTS = 20;

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

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE5C,eAAO,MAAM,mBAAmB,EAAE,oBAAoB,CAAC,YAAY,CAelE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-trap/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE5C,eAAO,MAAM,mBAAmB,EAAE,oBAAoB,CAAC,YAAY,CAgBlE,CAAA"}

package/dist/pipe-trap/parametrics.js

@@ -1,4 +1,5 @@
 export const pipeTrapParametrics = {
+    trailingSection: () => import('../shared/pipe-collar-inspector.js'),
     groups: [
         {
             label: 'Trap',