@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/duct-segment/continuation.js

@@ -0,0 +1,167 @@
+import { useScene, } from '@pascal-app/core';
+import { useEditor } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { findMatedScenePorts, planDuctElbowBranchPromotion, planDuctTeeCrossPromotion, resolveDuctContinuationHandle, } from '../shared/elbow-branch-continuation';
+import { ductPortDiameterIn } from './geometry';
+export function ductEndpointPort(duct, endpoint) {
+    if (duct.path.length < 2)
+        return null;
+    const index = endpoint === 'start' ? 0 : duct.path.length - 1;
+    const neighborIndex = endpoint === 'start' ? 1 : duct.path.length - 2;
+    const position = duct.path[index];
+    const neighbor = duct.path[neighborIndex];
+    const dx = position[0] - neighbor[0];
+    const dy = position[1] - neighbor[1];
+    const dz = position[2] - neighbor[2];
+    const length = Math.hypot(dx, dy, dz);
+    return {
+        id: endpoint,
+        nodeId: duct.id,
+        position,
+        direction: length < 1e-9 ? [1, 0, 0] : [dx / length, dy / length, dz / length],
+        diameter: ductPortDiameterIn(duct),
+        system: duct.system,
+    };
+}
+export function ductContinuationHandlePoint(duct, endpoint, gap = 0.28) {
+    const port = ductEndpointPort(duct, endpoint);
+    if (!port)
+        return null;
+    return [
+        port.position[0] + port.direction[0] * gap,
+        port.position[1] + port.direction[1] * gap,
+        port.position[2] + port.direction[2] * gap,
+    ];
+}
+export function ductContinuationHandlePlan(duct, endpoint, nodes, gap = 0.28) {
+    const port = ductEndpointPort(duct, endpoint);
+    return port ? resolveDuctContinuationHandle(port, nodes, gap) : null;
+}
+export function resolveDuctContinuationSeed(defaults, nodes) {
+    const continuation = defaults?.continuation;
+    const endpoint = continuation?.endpoint;
+    const nodeId = continuation?.nodeId;
+    if (endpoint === 'branch' && typeof nodeId === 'string') {
+        const node = nodes[nodeId];
+        const segmentIndex = continuation?.segmentIndex;
+        const point = continuation?.point;
+        if (node?.type === 'duct-segment' &&
+            typeof segmentIndex === 'number' &&
+            Array.isArray(point) &&
+            point.length === 3) {
+            return {
+                duct: node,
+                port: null,
+                body: { nodeId: node.id, segmentIndex, point: point },
+            };
+        }
+    }
+    if ((endpoint !== 'start' && endpoint !== 'end') ||
+        typeof nodeId !== 'string' ||
+        nodeId.length === 0)
+        return null;
+    const node = nodes[nodeId];
+    if (node?.type !== 'duct-segment')
+        return null;
+    const port = ductEndpointPort(node, endpoint);
+    if (!port)
+        return null;
+    if (typeof continuation?.fittingId !== 'string')
+        return { duct: node, port, body: null };
+    const fitting = nodes[continuation.fittingId];
+    if (fitting?.type !== 'duct-fitting')
+        return null;
+    const fittingPort = findMatedScenePorts(port, nodes).find((mate) => mate.nodeId === fitting.id);
+    if (!fittingPort)
+        return null;
+    if (fitting.fittingType === 'end-cap')
+        return { duct: node, port, body: null };
+    const promotion = fitting.fittingType === 'elbow'
+        ? planDuctElbowBranchPromotion(fitting, fittingPort.id)
+        : planDuctTeeCrossPromotion(fitting);
+    return promotion
+        ? {
+            duct: node,
+            port: promotion.continuationPort,
+            body: null,
+            promotedFitting: promotion.fitting,
+        }
+        : null;
+}
+export function activateDuctBranch(duct, segmentIndex, point) {
+    const segment = duct.path[segmentIndex];
+    const next = duct.path[segmentIndex + 1];
+    if (!segment || !next)
+        return;
+    const editor = useEditor.getState();
+    editor.setToolDefaults('duct-segment', {
+        continuation: { nodeId: duct.id, endpoint: 'branch', segmentIndex, point },
+        shape: duct.shape,
+        diameter: duct.diameter,
+        width: duct.width,
+        height: duct.height,
+        ductMaterial: duct.ductMaterial,
+        seamDetail: duct.seamDetail,
+        insulated: duct.insulated,
+        insulationR: duct.insulationR,
+        system: duct.system,
+    });
+    useViewer.getState().setSelection({ selectedIds: [] });
+    editor.setTool('duct-segment');
+}
+export function activateDuctContinuation(duct, endpoint, fittingId) {
+    if (!ductEndpointPort(duct, endpoint))
+        return;
+    const editor = useEditor.getState();
+    editor.setToolDefaults('duct-segment', {
+        continuation: { nodeId: duct.id, endpoint, ...(fittingId ? { fittingId } : {}) },
+        shape: duct.shape,
+        diameter: duct.diameter,
+        width: duct.width,
+        height: duct.height,
+        ductMaterial: duct.ductMaterial,
+        seamDetail: duct.seamDetail,
+        insulated: duct.insulated,
+        insulationR: duct.insulationR,
+        system: duct.system,
+    });
+    useViewer.getState().setSelection({ selectedIds: [] });
+    editor.setTool('duct-segment');
+}
+export const ductContinuationAffordance = {
+    start({ node, payload }) {
+        const data = payload;
+        const endpoint = data?.endpoint;
+        const fittingId = typeof data?.fittingId === 'string' ? data.fittingId : undefined;
+        return {
+            affectedIds: [],
+            apply() { },
+            canCommit: () => endpoint === 'start' || endpoint === 'end',
+            commit() {
+                if (endpoint === 'start' || endpoint === 'end') {
+                    activateDuctContinuation(node, endpoint, fittingId);
+                }
+            },
+        };
+    },
+};
+export const ductBranchAffordance = {
+    start({ node, payload }) {
+        const data = payload;
+        const segmentIndex = data?.segmentIndex;
+        const point = data?.point;
+        return {
+            affectedIds: [],
+            apply() { },
+            canCommit: () => typeof segmentIndex === 'number' && Array.isArray(point) && point.length === 3,
+            commit() {
+                if (typeof segmentIndex === 'number' && Array.isArray(point) && point.length === 3) {
+                    activateDuctBranch(node, segmentIndex, point);
+                }
+            },
+        };
+    },
+};
+export function currentDuctContinuationSeed() {
+    return resolveDuctContinuationSeed(useEditor.getState().toolDefaults['duct-segment'], useScene.getState().nodes);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/duct-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,cAAc,EAAY,MAAM,kBAAkB,CAAA;AAO9E,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoC1C,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA2JxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/duct-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,cAAc,EAAY,MAAM,kBAAkB,CAAA;AAS9E,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoC1C,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAyJxE,CAAA"}

package/dist/duct-segment/definition.js

@@ -2,6 +2,8 @@ import { useScene } from '@pascal-app/core';
 import { ductBodyPaint, ductBodySlots } from '../shared/duct-body-paint';
 import { createPathPointMoveAffordance } from '../shared/path-point-affordance';
 import { createSegmentMoveAffordance } from '../shared/path-segment-affordance';
+import { createRunHangerToolHint } from '../shared/run-hanger-mode';
+import { ductBranchAffordance, ductContinuationAffordance } from './continuation';
 import { buildDuctSegmentFloorplan } from './floorplan';
 import { buildDuctSegmentGeometry, ductPortDiameterIn } from './geometry';
 import { ductSegmentParametrics } from './parametrics';
@@ -40,10 +42,11 @@ function rollDuctSegment(node, steps) {
 }
 export const ductSegmentDefinition = {
     kind: 'duct-segment',
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: DuctSegmentNode,
     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.
@@ -53,6 +56,10 @@ export const ductSegmentDefinition = {
         parentId: null,
         visible: true,
         metadata: {},
+        autoHangers: false,
+        hangerStyle: 'single',
+        hangerSpacing: 1.5,
+        hangerMaxReach: 2,
         path: [
             [0, 0, 0],
             [3, 0, 0],
@@ -89,21 +96,13 @@ export const ductSegmentDefinition = {
             run: (node) => rollDuctSegment(node, -1),
         },
     },
+    system: {
+        module: async () => ({
+            default: (await import('../shared/run-hanger-system')).DuctHangerSystem,
+        }),
+    },
+    floorplanDependsOnSiblings: true,
     geometry: buildDuctSegmentGeometry,
-    geometryKey: (n) => JSON.stringify([
-        n.path,
-        n.shape,
-        n.diameter,
-        n.width,
-        n.height,
-        n.roll,
-        n.ductMaterial,
-        n.seamDetail,
-        n.insulated,
-        n.insulationR,
-        n.system,
-        n.slots,
-    ]),
     // Open run ends as typed ports — directions point outward along the
     // path tangent so fittings mate flush. Path coords are already
     // level-local, so no transform is needed.
@@ -145,6 +144,8 @@ export const ductSegmentDefinition = {
         // 2D twin of the 3D side-move arrows: slide a segment perpendicular to
         // itself. (Length editing stays on the per-vertex hex handles.)
         'move-segment': createSegmentMoveAffordance('duct-segment'),
+        'continue-run': ductContinuationAffordance,
+        'branch-run': ductBranchAffordance,
     },
     // Selection-time path-point handles (drag to edit a committed run).
     // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
@@ -163,9 +164,9 @@ export const ductSegmentDefinition = {
         { key: 'Click again', label: 'Place and continue' },
         { key: 'Alt + drag', label: 'Go vertical ↕, click to place' },
         { key: '[ / ]', label: 'Duct diameter down / up' },
-        { key: 'Q', label: 'Round / rect trunk' },
-        { key: 'C', label: 'Ceiling / floor height' },
-        { key: 'Esc', label: 'Cancel start point' },
+        { key: 'Q', label: 'Round / rectangular / oval' },
+        createRunHangerToolHint('duct-segment'),
+        { key: 'Esc', label: 'Exit drawing' },
     ],
     presentation: {
         label: 'Duct',

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/duct-segment/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAkB,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAE1F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAU/C;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA4G1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/duct-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;AAU/C;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAwJ1B"}

package/dist/duct-segment/floorplan.js

@@ -1,3 +1,5 @@
+import { runHangerFloorplan } from '../shared/run-hangers';
+import { ductContinuationHandlePlan, ductEndpointPort } from './continuation';
 import { INCHES_TO_METERS } from './geometry';
 const SUPPLY_CENTERLINE = '#d4825a';
 const RETURN_CENTERLINE = '#5a8ad4';
@@ -43,6 +45,7 @@ export function buildDuctSegmentFloorplan(node, ctx) {
         return {
             kind: 'group',
             children: [
+                ...runHangerFloorplan(node, ctx),
                 {
                     kind: 'circle',
                     cx: p[0],
@@ -90,6 +93,45 @@ export function buildDuctSegmentFloorplan(node, ctx) {
                 payload: { pointIndex: indexMap[k] },
             });
         }
+        const continuationGap = Math.max(0.28, diameterM / 2 + 0.18);
+        for (const endpoint of ['start', 'end']) {
+            const port = ductEndpointPort(node, endpoint);
+            const sceneNodes = ctx.sceneNodes ?? { [node.id]: node };
+            const plan = ductContinuationHandlePlan(node, endpoint, sceneNodes, continuationGap);
+            if (!(port && plan))
+                continue;
+            if (Math.hypot(plan.position[0] - port.position[0], plan.position[2] - port.position[2]) < 1e-6)
+                continue;
+            children.push({
+                kind: 'midpoint-handle',
+                point: [plan.position[0], plan.position[2]],
+                activation: 'action',
+                affordance: 'continue-run',
+                payload: { action: 'continue-run', endpoint, fittingId: plan.fittingId },
+            });
+        }
+        for (let k = 0; k < points.length - 1; k++) {
+            const a = points[k];
+            const b = points[k + 1];
+            const t = 0.5;
+            const pathIndex = indexMap[k];
+            const nextPathIndex = indexMap[k + 1];
+            children.push({
+                kind: 'midpoint-handle',
+                point: [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t],
+                activation: 'action',
+                affordance: 'branch-run',
+                payload: {
+                    action: 'branch-run',
+                    segmentIndex: pathIndex,
+                    point: [
+                        a[0] + (b[0] - a[0]) * t,
+                        (node.path[pathIndex][1] + node.path[nextPathIndex][1]) / 2,
+                        a[1] + (b[1] - a[1]) * t,
+                    ],
+                },
+            });
+        }
         // Side-move arrows: a front / back pair at each segment midpoint, sliding
         // that segment perpendicular to itself. 2D twin of the 3D side-move
         // arrows. The arrows stand one duct-radius + gap off the body; `angle`
@@ -117,5 +159,6 @@ export function buildDuctSegmentFloorplan(node, ctx) {
             }
         }
     }
+    children.push(...runHangerFloorplan(node, ctx));
     return { kind: 'group', children };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/duct-segment/geometry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/duct-segment/geometry.ts"],"names":[],"mappings":"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"}

package/dist/duct-segment/geometry.js

@@ -1,6 +1,7 @@
 import { createSurfaceRoleMaterial, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
 import { BoxGeometry, CatmullRomCurve3, CylinderGeometry, ExtrudeGeometry, Group, Matrix4, Mesh, MeshStandardMaterial, Quaternion, Shape, SphereGeometry, TubeGeometry, Vector3, } from 'three';
 import { DUCT_BODY_SLOT_DEFAULT, DUCT_BODY_SLOT_ID } from '../shared/duct-body-paint';
+import { buildRunHangers } from '../shared/run-hangers';
 export const INCHES_TO_METERS = 0.0254;
 // Insulation wraps the duct in a roughly uniform shell. A strictly physical
 // mapping (fiberglass ≈ R-3.2 per inch) makes low R-values nearly invisible
@@ -364,5 +365,7 @@ export function buildDuctSegmentGeometry(node, ctx, shading = 'rendered', textur
         });
         addRun(radius + insulationThickness, widthM + insulationThickness * 2, heightM + insulationThickness * 2, insulationMaterial, 'duct-insulation', 0.01);
     }
+    if (node.autoHangers)
+        group.add(buildRunHangers(node, ctx));
     return group;
 }

package/dist/duct-segment/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/duct-segment/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAQb,MAAM,kBAAkB,CAAA;AAiFzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA4R3D,CAAA;AA0DD,eAAe,mBAAmB,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/duct-segment/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAQb,MAAM,kBAAkB,CAAA;AAkFzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAsT3D,CAAA;AA0DD,eAAe,mBAAmB,CAAA"}

package/dist/duct-segment/move-tool.js

@@ -10,13 +10,14 @@ import { DuctSegmentGhost, FittingGhost } from '../shared/mep-ghost';
 import { collectScenePorts, DUCT_PORT_SYSTEMS } from '../shared/ports';
 import { startRunMoveConnectivity } from '../shared/run-move-connectivity';
 import { planRunTranslationOffsets, } from '../shared/run-translation-offset';
+import { translateWallRun } from '../shared/wall-run-move';
 import { rectSectionAxes } from './geometry';
 const GHOST_COLOR = '#818cf8';
 const GHOST_OPACITY = 0.5;
 const IN_TO_M = 0.0254;
 /** Snap a coordinate to the editor's live grid step. */
 function snapToGridStep(value) {
-    const step = useEditor.getState().gridSnapStep;
+    const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
     if (step <= 0)
         return value;
     return Math.round(value / step) * step;
@@ -88,6 +89,7 @@ export const MoveDuctSegmentTool = ({ node }) => {
     const hasMovedRef = useRef(false);
     const activatedAtRef = useRef(Date.now());
     const prevSnapRef = useRef(null);
+    const previewAttachmentRef = useRef(duct.wallAttachment);
     useEffect(() => {
         const nodeId = node.id;
         const originalPath = originalPathRef.current;
@@ -133,6 +135,20 @@ export const MoveDuctSegmentTool = ({ node }) => {
             setPreviewPath(path);
         };
         const onMove = (event) => {
+            const attachedWall = duct.wallAttachment
+                ? useScene.getState().nodes[duct.wallAttachment.wallId]
+                : undefined;
+            if (duct.wallAttachment && attachedWall?.type === 'wall') {
+                const wallMove = translateWallRun(originalPath, duct.wallAttachment, attachedWall, event);
+                if (wallMove) {
+                    hasMovedRef.current = true;
+                    previewAttachmentRef.current = wallMove.attachment;
+                    setPreview(wallMove.path);
+                    connectivity?.preview({ path: wallMove.path });
+                    setTranslationGhost(null);
+                    return;
+                }
+            }
             const snap = isGridSnapActive() ? snapToGridStep : (v) => v;
             let dx = snap(event.localPosition[0] - centerX);
             let dz = snap(event.localPosition[2] - centerZ);
@@ -206,6 +222,7 @@ export const MoveDuctSegmentTool = ({ node }) => {
                 const created = DuctSegmentNode.parse({
                     ...node,
                     path: finalPath,
+                    wallAttachment: previewAttachmentRef.current,
                     metadata: stripPlacementMetadataFlags(node.metadata),
                     visible: true,
                 });
@@ -229,7 +246,13 @@ export const MoveDuctSegmentTool = ({ node }) => {
                             parentId: node.parentId,
                         })),
                         update: [
-                            { id: nodeId, data: { path: translationPlan.ductPath } },
+                            {
+                                id: nodeId,
+                                data: {
+                                    path: translationPlan.ductPath,
+                                    wallAttachment: previewAttachmentRef.current,
+                                },
+                            },
                             ...translationPlan.updates,
                         ],
                     });
@@ -238,10 +261,14 @@ export const MoveDuctSegmentTool = ({ node }) => {
                     // Fold connected-fitting / sibling-run follow-updates into the SAME
                     // batch as the moved run so the whole joint is one undo step.
                     const followUpdates = connectivity?.commitUpdates({ path: finalPath }) ?? [];
-                    useScene
-                        .getState()
-                        .updateNodes([
-                        { id: nodeId, data: { path: finalPath } },
+                    useScene.getState().updateNodes([
+                        {
+                            id: nodeId,
+                            data: {
+                                path: finalPath,
+                                wallAttachment: previewAttachmentRef.current,
+                            },
+                        },
                         ...followUpdates,
                     ]);
                 }

package/dist/duct-segment/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/duct-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,oBAAoB,EAAY,MAAM,kBAAkB,CAAA;AAI5F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA0E/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CA8FxE,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/duct-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,oBAAoB,EAAY,MAAM,kBAAkB,CAAA;AAM5F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA0E/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAiJxE,CAAA"}

package/dist/duct-segment/parametrics.js

@@ -1,6 +1,8 @@
 import { useScene } from '@pascal-app/core';
 import { Vector3 } from 'three';
 import { getDuctFittingPorts } from '../duct-fitting/ports';
+import { findAutomaticRunEndCapIds } from '../shared/automatic-run-end-cap';
+import { fittingDeletionPlansForRun } from '../shared/fitting-deletion-cleanup';
 import { rollToContinueAcrossElbow } from './geometry';
 /** A run endpoint sitting this close to a collar counts as mated. */
 const MATE_TOL_M = 0.03;
@@ -76,7 +78,13 @@ export const ductSegmentParametrics = {
     // non-round run can never hold it: leaving round (or picking spiral on
     // a rect / oval run) falls back to plain sheet metal.
     derive: (next, patch) => {
-        const out = {};
+        const out = next.autoHangers
+            ? {
+                hangerStyle: next.hangerStyle ?? 'single',
+                hangerSpacing: next.hangerSpacing ?? 1.5,
+                hangerMaxReach: next.hangerMaxReach ?? 2,
+            }
+            : {};
         if (next.ductMaterial === 'spiral' && next.shape !== 'round') {
             out.ductMaterial = 'sheet-metal';
         }
@@ -87,7 +95,47 @@ export const ductSegmentParametrics = {
         }
         return out;
     },
+    onDelete: (duct, nodes, _pendingDeleteIds, requestedDeleteIds) => fittingDeletionPlansForRun(duct, nodes, requestedDeleteIds, true).flatMap((plan) => plan.updates),
+    onDeleteCascade: (duct, nodes, _pendingDeleteIds, requestedDeleteIds) => [
+        ...findAutomaticRunEndCapIds(duct.id, nodes, 'duct-fitting'),
+        ...fittingDeletionPlansForRun(duct, nodes, requestedDeleteIds, false).flatMap((plan) => plan.deleteFitting ? [plan.fittingId, ...plan.cascadeDeleteIds] : []),
+    ],
+    trailingSection: () => import('../shared/run-hanger-inspector'),
     groups: [
+        {
+            label: 'Hangers',
+            fields: [
+                { key: 'autoHangers', label: 'Auto hangers', kind: 'boolean' },
+                {
+                    key: 'hangerStyle',
+                    label: 'Hanger lines',
+                    kind: 'enum',
+                    options: ['single', 'double'],
+                    display: 'segmented',
+                    visibleIf: (n) => !!n.autoHangers,
+                },
+                {
+                    key: 'hangerSpacing',
+                    label: 'Spacing',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.05,
+                    max: 1000,
+                    step: 0.1,
+                    visibleIf: (n) => !!n.autoHangers,
+                },
+                {
+                    key: 'hangerMaxReach',
+                    label: 'Maximum reach',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.01,
+                    max: 1000,
+                    step: 0.1,
+                    visibleIf: (n) => !!n.autoHangers,
+                },
+            ],
+        },
         {
             label: 'Air',
             fields: [

package/dist/duct-segment/selection.d.ts

@@ -22,11 +22,10 @@
  * - **Alt** detaches: the joint breaks for this drag — the elbow does NOT
  *   re-aim and mated fittings / runs do NOT follow; the endpoint moves on its
  *   own (port re-mate still allowed so it can be reattached elsewhere).
- * - **Shift** bypasses grid snapping for a perfectly smooth precision drag.
+ * - Snapping follows the active editor snapping mode.
  *
- * History does the single-undo dance: paused during the drag (the live
- * `updateNode` ticks are untracked), then on release the path is
- * reverted, history resumed, and the final path applied as one tracked
+ * History is paused during the drag while live overrides drive the preview.
+ * On release, history resumes and the final path is applied as one tracked
  * change.
  */
 declare const DuctSegmentSelectionAffordance: () => import("react").JSX.Element | null;

package/dist/duct-segment/selection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/duct-segment/selection.tsx"],"names":[],"mappings":"AAgIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,QAAA,MAAM,8BAA8B,0CAuCnC,CAAA;AAo5CD,eAAe,8BAA8B,CAAA"}
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/duct-segment/selection.tsx"],"names":[],"mappings":"AA+IA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,QAAA,MAAM,8BAA8B,0CAuCnC,CAAA;AA68CD,eAAe,8BAA8B,CAAA"}