@pascal-app/nodes 1.0.7 → 1.1.0

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

@@ -1,10 +1,74 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { PipeFittingNode } from './schema.js';
-/**
- * DWV fittings — minted automatically by the pipe draw tool (corner
- * joints → elbows, body taps → wyes on horizontal drains / sanitary
- * tees on stacks), or click-placed via the tool (armed from the Build
- * tab's DWV Pipe panel). Editable after the fact via the inspector.
- */
-export declare const pipeFittingDefinition: NodeDefinition<typeof PipeFittingNode>;
+export declare const pipeFittingDefinition: 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-fitting_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"pipe-fitting">>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    fittingType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        cleanout: "cleanout";
+        coupling: "coupling";
+        cross: "cross";
+        elbow: "elbow";
+        "end-cap": "end-cap";
+        reducer: "reducer";
+        "sanitary-tee": "sanitary-tee";
+        wye: "wye";
+    }>>;
+    angle: import("zod").ZodDefault<import("zod").ZodNumber>;
+    diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    diameter2: import("zod").ZodDefault<import("zod").ZodNumber>;
+    cleanoutStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        end: "end";
+        inline: "inline";
+    }>>;
+    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-fitting/definition.d.ts.map

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/definition.edit.ts"],"names":[],"mappings":"AACA,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,CA0CpF,CAAA"}

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

@@ -0,0 +1,47 @@
+import { useScene } from '@pascal-app/core';
+import { getRotationAxis, rotateEulerWorld } from '../shared/fitting-rotation.js';
+import { pipeFittingToolOptions } from '../shared/fitting-tool-options.js';
+import { pipeFittingQuickActions } from '../shared/mep-fitting-actions.js';
+import { buildPipeFittingFloorplan } from './floorplan.js';
+import { pipeFittingParametrics } from './parametrics.js';
+export const pipeFittingEditContribution = {
+    snapProfile: 'item',
+    parametrics: pipeFittingParametrics,
+    floorplan: buildPipeFittingFloorplan,
+    quickActions: pipeFittingQuickActions,
+    quickActionNodeScope: 'level',
+    // R/T rotate a selected fitting ±45° around the shared active axis —
+    // same scheme as duct fittings (the default editor rotate only knows
+    // Y; DWV stacks need X/Z). Alt-cycling lives in `./selection.tsx`.
+    keyboardActions: {
+        r: {
+            appliesTo: (node) => node.type === 'pipe-fitting',
+            run: (node) => useScene.getState().updateNode(node.id, {
+                rotation: rotateEulerWorld(node.rotation, getRotationAxis(), 1),
+            }),
+        },
+        t: {
+            appliesTo: (node) => node.type === 'pipe-fitting',
+            run: (node) => useScene.getState().updateNode(node.id, {
+                rotation: rotateEulerWorld(node.rotation, getRotationAxis(), -1),
+            }),
+        },
+        axisCycling: true,
+    },
+    // Alt-cycles the active rotation axis while a fitting is selected.
+    // Editor-only (drives `useEditor.rotationAxis`), so it mounts via the
+    // editor's SelectionAffordanceManager rather than `def.system`.
+    affordanceTools: {
+        selection: () => import('./selection.js'),
+        move: () => import('./move-tool.js'),
+    },
+    toolOptions: pipeFittingToolOptions,
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Click', label: 'Place fitting' },
+        { key: 'Hover a pipe end', label: 'Snap onto the run' },
+        { key: 'R / T', label: 'Rotate ±45°' },
+        { key: 'Alt', label: 'Switch rotation axis (Y → X → Z)' },
+        { key: 'Esc', label: 'Exit' },
+    ],
+};

package/dist/pipe-fitting/definition.js

@@ -1,105 +1,4 @@
-import { useScene } from '@pascal-app/core';
-import { getRotationAxis, rotateEulerWorld } from '../shared/fitting-rotation.js';
-import { pipeFittingToolOptions } from '../shared/fitting-tool-options.js';
-import { pipeFittingQuickActions } from '../shared/mep-fitting-actions.js';
-import { buildPipeFittingFloorplan } from './floorplan.js';
-import { buildPipeFittingGeometry } from './geometry.js';
-import { pipeFittingParametrics } from './parametrics.js';
-import { getPipeFittingPorts } from './ports.js';
-import { PipeFittingNode } from './schema.js';
-/**
- * DWV fittings — minted automatically by the pipe draw tool (corner
- * joints → elbows, body taps → wyes on horizontal drains / sanitary
- * tees on stacks), or click-placed via the tool (armed from the Build
- * tab's DWV Pipe panel). Editable after the fact via the inspector.
- */
-export const pipeFittingDefinition = {
-    kind: 'pipe-fitting',
-    schemaVersion: 2,
-    schema: PipeFittingNode,
-    category: 'utility',
-    distributionRole: 'fitting',
-    snapProfile: 'item',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        position: [0, 0, 0],
-        rotation: [0, 0, 0],
-        cleanoutStyle: 'end',
-        fittingType: 'elbow',
-        angle: 90,
-        diameter: 2,
-        diameter2: 2,
-        pipeMaterial: 'pvc',
-        system: 'waste',
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        movable: { axes: ['x', 'y', 'z'], gridSnap: true, cursorAttached: true },
-        duplicable: true,
-        deletable: true,
-    },
-    parametrics: pipeFittingParametrics,
-    geometry: buildPipeFittingGeometry,
-    geometryKey: (n) => JSON.stringify([
-        n.fittingType,
-        n.cleanoutStyle,
-        n.angle,
-        n.diameter,
-        n.diameter2,
-        n.pipeMaterial,
-        n.system,
-    ]),
-    ports: getPipeFittingPorts,
-    floorplan: buildPipeFittingFloorplan,
-    quickActions: pipeFittingQuickActions,
-    quickActionNodeScope: 'level',
-    // R/T rotate a selected fitting ±45° around the shared active axis —
-    // same scheme as duct fittings (the default editor rotate only knows
-    // Y; DWV stacks need X/Z). Alt-cycling lives in `./selection.tsx`.
-    keyboardActions: {
-        r: {
-            appliesTo: (node) => node.type === 'pipe-fitting',
-            run: (node) => useScene.getState().updateNode(node.id, {
-                rotation: rotateEulerWorld(node.rotation, getRotationAxis(), 1),
-            }),
-        },
-        t: {
-            appliesTo: (node) => node.type === 'pipe-fitting',
-            run: (node) => useScene.getState().updateNode(node.id, {
-                rotation: rotateEulerWorld(node.rotation, getRotationAxis(), -1),
-            }),
-        },
-        axisCycling: true,
-    },
-    // Alt-cycles the active rotation axis while a fitting is selected.
-    // Editor-only (drives `useEditor.rotationAxis`), so it mounts via the
-    // editor's SelectionAffordanceManager rather than `def.system`.
-    affordanceTools: {
-        selection: () => import('./selection.js'),
-        move: () => import('./move-tool.js'),
-    },
-    toolOptions: pipeFittingToolOptions,
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Click', label: 'Place fitting' },
-        { key: 'Hover a pipe end', label: 'Snap onto the run' },
-        { key: 'R / T', label: 'Rotate ±45°' },
-        { key: 'Alt', label: 'Switch rotation axis (Y → X → Z)' },
-        { key: 'Esc', label: 'Exit' },
-    ],
-    presentation: {
-        label: 'Pipe Fitting',
-        description: 'DWV joint — elbow bend, 45° wye, or sanitary tee.',
-        // Reuses the duct-fitting artwork — DWV fittings read the same in the UI.
-        icon: { kind: 'url', src: '/icons/duct-fitting.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 96,
-        hidden: true,
-    },
-    mcp: {
-        description: 'A DWV pipe fitting (elbow, wye, or sanitary tee) with typed ports. Minted automatically at drain joints; position is level-local meters, rotation an XYZ euler.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { pipeFittingEditContribution } from './definition.edit.js';
+import { pipeFittingRenderDefinition } from './definition.render.js';
+export const pipeFittingDefinition = composeNodeDefinition(pipeFittingRenderDefinition, pipeFittingEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/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;CAqDrB,CAAA"}

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

@@ -0,0 +1,54 @@
+import { buildPipeFittingGeometry } from './geometry.js';
+import { getPipeFittingPorts } from './ports.js';
+import { PipeFittingNode } from './schema.js';
+export const pipeFittingRenderDefinition = {
+    kind: 'pipe-fitting',
+    schemaVersion: 2,
+    schema: PipeFittingNode,
+    category: 'utility',
+    distributionRole: 'fitting',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        cleanoutStyle: 'end',
+        fittingType: 'elbow',
+        angle: 90,
+        diameter: 2,
+        diameter2: 2,
+        pipeMaterial: 'pvc',
+        system: 'waste',
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        movable: { axes: ['x', 'y', 'z'], gridSnap: true, cursorAttached: true },
+        duplicable: true,
+        deletable: true,
+    },
+    geometry: buildPipeFittingGeometry,
+    geometryKey: (n) => JSON.stringify([
+        n.fittingType,
+        n.cleanoutStyle,
+        n.angle,
+        n.diameter,
+        n.diameter2,
+        n.pipeMaterial,
+        n.system,
+    ]),
+    ports: getPipeFittingPorts,
+    presentation: {
+        label: 'Pipe Fitting',
+        description: 'DWV joint — elbow bend, 45° wye, or sanitary tee.',
+        // Reuses the duct-fitting artwork — DWV fittings read the same in the UI.
+        icon: { kind: 'url', src: '/icons/duct-fitting.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 96,
+        hidden: true,
+    },
+    mcp: {
+        description: 'A DWV pipe fitting (elbow, wye, or sanitary tee) with typed ports. Minted automatically at drain joints; position is level-local meters, rotation an XYZ euler.',
+    },
+};

package/dist/pipe-fitting/floorplan.js

@@ -1,4 +1,4 @@
-import { INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 import { accessoryFloorplan } from '../shared/accessory-floorplan.js';
 import { buildPipeFittingGeometry } from './geometry.js';
 import { getPipeFittingPorts } from './ports.js';

package/dist/pipe-fitting/geometry.js

@@ -1,5 +1,5 @@
 import { CubicBezierCurve3, CylinderGeometry, Group, LineCurve3, Mesh, Quaternion, RingGeometry, SphereGeometry, TubeGeometry, Vector3, } from 'three';
-import { INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 import { createPipeMaterial } from '../pipe-segment/geometry.js';
 import { addPlug, addProfile } from '../shared/accessory-geometry.js';
 import { localPipeFittingPorts } from './ports.js';

package/dist/pipe-fitting/move-tool.d.ts

@@ -19,7 +19,7 @@ import { type AnyNode } from '@pascal-app/core';
  *   on its own, leaving every mated run where it sits.
  * - **Ctrl / Cmd** switches to vertical movement (stack / riser editing): XZ
  *   holds and the cursor's screen-Y drives the riser height.
- * - **Shift** bypasses grid snapping / alignment.
+ * - Snapping follows the active editor snapping mode.
  *
  * Wired via `def.affordanceTools.move`.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AA4EzB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAoQ3D,CAAA;eAEc,mBAAmB"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AA6EzB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA6Q3D,CAAA;eAEc,mBAAmB"}

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

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, PipeFittingNode, sceneRegistry, useScene, } from '@pascal-app/core';
-import { copyCollectionIds, DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { copyCollectionIds, DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useState } from 'react';
 import { Box3, Euler, MeshBasicMaterial, Vector3 } from 'three';
@@ -75,7 +75,7 @@ function rotatedBounds(box, rotation) {
  *   on its own, leaving every mated run where it sits.
  * - **Ctrl / Cmd** switches to vertical movement (stack / riser editing): XZ
  *   holds and the cursor's screen-Y drives the riser height.
- * - **Shift** bypasses grid snapping / alignment.
+ * - Snapping follows the active editor snapping mode.
  *
  * Wired via `def.affordanceTools.move`.
  */
@@ -170,7 +170,6 @@ export const MovePipeFittingTool = ({ node }) => {
         // when Ctrl is released. Mirrors the draw tool's Alt-vertical anchor.
         let verticalAnchor = null;
         const onMove = (event) => {
-            const bypass = event.nativeEvent?.shiftKey === true;
             // Alt = detach: drop the connected-pipe follow so the fitting moves on
             // its own, leaving every mated run where it sits.
             const detached = event.nativeEvent?.altKey === true;
@@ -178,7 +177,7 @@ export const MovePipeFittingTool = ({ node }) => {
             // screen-Y drives the riser height (connected pipes still follow).
             const vertical = event.nativeEvent?.ctrlKey === true || event.nativeEvent?.metaKey === true;
             const clientY = event.nativeEvent?.clientY;
-            const snap = bypass ? (v) => v : snapToGridStep;
+            const snap = isGridSnapActive() ? snapToGridStep : (v) => v;
             let next;
             if (vertical && typeof clientY === 'number') {
                 if (!verticalAnchor)
@@ -194,10 +193,10 @@ export const MovePipeFittingTool = ({ node }) => {
                 let x = snap(event.localPosition[0]);
                 let z = snap(event.localPosition[2]);
                 // Alignment: snap the footprint box edges onto nearby geometry and
-                // publish guides (Alt / Shift bypass). Guides are DISPLAYED in every
-                // snapping mode (isAlignmentGuideActive); the magnetic pull toward them
-                // applies only in 'lines' mode (isMagneticSnapActive).
-                if (!bypass && isAlignmentGuideActive()) {
+                // publish guides. Guides are DISPLAYED in every snapping mode
+                // (isAlignmentGuideActive); the magnetic pull toward them applies only
+                // in 'lines' mode (isMagneticSnapActive).
+                if (isAlignmentGuideActive()) {
                     const proposed = {
                         minX: x + ox - hx,
                         maxX: x + ox + hx,
@@ -216,19 +215,21 @@ export const MovePipeFittingTool = ({ node }) => {
                 }
                 next = [x, lastPos[1], z];
             }
-            if (next[0] !== lastPos[0] || next[1] !== lastPos[1] || next[2] !== lastPos[2]) {
+            if ((isGridSnapActive() || isMagneticSnapActive()) &&
+                (next[0] !== lastPos[0] || next[1] !== lastPos[1] || next[2] !== lastPos[2])) {
                 triggerSFX('sfx:grid-snap');
             }
+            // Detached: keep the followers at their origin (drop any live overrides
+            // from a prior non-detached frame). Otherwise preview the follow; joints
+            // that cannot follow hold the last shown frame.
+            if (detached)
+                connectivity?.clear();
+            else if (connectivity && !connectivity.preview({ position: next }))
+                return;
             lastPos = next;
             lastDetached = detached;
             hasMoved = true;
             setCursorPos(next);
-            // Detached: keep the followers at their origin (drop any live overrides
-            // from a prior non-detached frame). Otherwise preview the follow.
-            if (detached)
-                connectivity?.clear();
-            else
-                connectivity?.preview({ position: next });
         };
         const commit = (event) => {
             if (committed)
@@ -241,10 +242,21 @@ export const MovePipeFittingTool = ({ node }) => {
                 event.nativeEvent?.stopPropagation?.();
                 return;
             }
+            const creating = isNew && !useScene.getState().nodes[nodeId];
+            // Fold connected-pipe / sibling-run follow-updates into the SAME batch
+            // as the moved fitting so the whole joint is one undo step. Detached
+            // (Alt on the final frame): the joint is broken, so nothing follows.
+            const followUpdates = creating || lastDetached || !connectivity
+                ? []
+                : connectivity.commitUpdates({ position: lastPos });
+            if (!followUpdates) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
             committed = true;
             useScene.temporal.getState().resume();
             let selectId = nodeId;
-            if (isNew && !useScene.getState().nodes[nodeId]) {
+            if (creating) {
                 const created = PipeFittingNode.parse({
                     ...node,
                     position: lastPos,
@@ -261,12 +273,6 @@ export const MovePipeFittingTool = ({ node }) => {
                 selectId = created.id;
             }
             else {
-                // Fold connected-pipe / sibling-run follow-updates into the SAME batch
-                // as the moved fitting so the whole joint is one undo step. Detached
-                // (Alt on the final frame): the joint is broken, so nothing follows.
-                const followUpdates = lastDetached
-                    ? []
-                    : (connectivity?.commitUpdates({ position: lastPos }) ?? []);
                 useScene
                     .getState()
                     .updateNodes([

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

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,oBAAoB,EAAmB,MAAM,kBAAkB,CAAA;AAEjG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAkC/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAwFxE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,oBAAoB,EAAmB,MAAM,kBAAkB,CAAA;AAEjG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAkC/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAyFxE,CAAA"}

package/dist/pipe-fitting/parametrics.js

@@ -51,6 +51,7 @@ export const pipeFittingParametrics = {
         }
         return updates;
     },
+    trailingSection: () => import('../shared/pipe-collar-inspector.js'),
     groups: [
         {
             label: 'Fitting',

package/dist/pipe-fitting/ports.js

@@ -1,5 +1,5 @@
 import { Euler, Vector3 } from 'three';
-import { INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 /** Hub stub length in meters — pipe fittings are stubbier than duct
  *  fittings (a 2" wye hub is ~7 cm to the collar). */
 export function pipeFittingLegLength(diameterInches) {

package/dist/pipe-fitting/selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/selection.tsx"],"names":[],"mappings":"AAwPA,QAAA,MAAM,8BAA8B,0CAyCnC,CAAA;eAmfc,8BAA8B"}
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/selection.tsx"],"names":[],"mappings":"AA+PA,QAAA,MAAM,8BAA8B,0CA2CnC,CAAA;eAmiBc,8BAA8B"}