@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/duct-fitting/tool.js

@@ -1,25 +1,24 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { DuctFittingNode, emitter, useScene } from '@pascal-app/core';
-import { CursorSphere, EDITOR_LAYER, isGridSnapActive, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { CursorSphere, EDITOR_LAYER, isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { Euler, Quaternion, Vector3 } from 'three';
+import { Euler, Mesh, Quaternion, Vector3 } from 'three';
+import { accessoryCursor } from '../shared/accessory-cursor';
+import { accessoryMateQuaternion, inheritFittingProfile, placeAccessPanel, } from '../shared/accessory-placement';
+import { findAccessoryPort, snapAccessoryPoint, subscribeAccessorySnapping, } from '../shared/accessory-snapping';
+import { ConnectionFeedback } from '../shared/connection-feedback';
+import { alignDrawPoint, clearDrawAlignment } from '../shared/draw-alignment';
 import { AXIS_VECTORS, cycleRotationAxis, getRotationAxis, ROTATE_STEP_RAD, } from '../shared/fitting-rotation';
+import { createFittingSurfaceSupport } from '../shared/fitting-surface-support';
 import { LevelOffsetGroup } from '../shared/level-offset-group';
-import { collectScenePorts, DUCT_PORT_SYSTEMS, findNearestPortXZ, } from '../shared/ports';
+import { collectScenePorts, DUCT_PORT_SYSTEMS } from '../shared/ports';
 import { ductFittingDefinition } from './definition';
 import { buildDuctFittingGeometry } from './geometry';
 import { localFittingPorts } from './ports';
-/** Snap radius (meters, XZ) for mating onto an existing port. */
-const PORT_SNAP_RADIUS_M = 0.5;
 const PREVIEW_OPACITY = 0.55;
-function snap(value, step) {
-    if (step <= 0)
-        return value;
-    return Math.round(value / step) * step;
-}
 /**
  * Resolve where the fitting would land for a cursor at `raw`:
  *   - Near an existing port → mate: orientation aligns the inlet onto
@@ -28,16 +27,41 @@ function snap(value, step) {
  *   - Otherwise → grid-snapped free placement on the floor, manual
  *     rotation only.
  */
-function resolvePlacement(raw, previewNode, gridStep, manualQuat) {
-    const port = findNearestPortXZ(raw, collectScenePorts({ systems: DUCT_PORT_SYSTEMS }), PORT_SNAP_RADIUS_M);
+export function resolvePlacement(raw, previewNode, gridStep, manualQuat, surfaceHit, surfaceNormal, support = createFittingSurfaceSupport()) {
+    const levelId = useViewer.getState().selection.levelId;
+    if (previewNode.fittingType === 'access-panel') {
+        const enabled = isGridSnapActive() || isMagneticSnapActive();
+        const mounted = enabled
+            ? placeAccessPanel(raw, previewNode, useScene.getState().nodes, levelId, surfaceHit, gridStep)
+            : null;
+        const normal = new Vector3(...(surfaceNormal ?? [0, 1, 0])).normalize();
+        const orientation = manualQuat
+            .clone()
+            .multiply(new Quaternion().setFromUnitVectors(new Vector3(0, 0, 1), normal));
+        const euler = new Euler().setFromQuaternion(orientation);
+        const rotation = [euler.x, euler.y, euler.z];
+        return {
+            ...(mounted ?? {
+                position: support(previewNode, rotation, snapAccessoryPoint(raw, gridStep, surfaceNormal), raw, surfaceNormal),
+                rotation,
+            }),
+            snapPort: null,
+            node: previewNode,
+            valid: true,
+        };
+    }
+    const port = levelId
+        ? findAccessoryPort(raw, collectScenePorts({ systems: DUCT_PORT_SYSTEMS, levelId }), isGridSnapActive() || isMagneticSnapActive(), surfaceHit)
+        : null;
     if (port) {
-        const direction = new Vector3(...port.direction).normalize();
+        clearDrawAlignment();
+        const fittedNode = inheritFittingProfile(previewNode, port, useScene.getState().nodes);
         // Local +X must map onto the port's outward direction so the inlet
         // (local -X) faces back into the run it's joining. Manual rotation
         // composes in the world frame on top of the mate orientation.
-        const mate = new Quaternion().setFromUnitVectors(new Vector3(1, 0, 0), direction);
+        const mate = accessoryMateQuaternion(fittedNode, port, useScene.getState().nodes);
         const final = manualQuat.clone().multiply(mate);
-        const inlet = localFittingPorts(previewNode)[0];
+        const inlet = localFittingPorts(fittedNode)[0];
         const inletWorldOffset = inlet.position.clone().applyQuaternion(final);
         const position = new Vector3(...port.position).sub(inletWorldOffset);
         const euler = new Euler().setFromQuaternion(final);
@@ -45,13 +69,22 @@ function resolvePlacement(raw, previewNode, gridStep, manualQuat) {
             position: [position.x, position.y, position.z],
             rotation: [euler.x, euler.y, euler.z],
             snapPort: port,
+            node: fittedNode,
+            valid: true,
         };
     }
     const euler = new Euler().setFromQuaternion(manualQuat);
+    const rotation = [euler.x, euler.y, euler.z];
+    const snapped = alignDrawPoint(snapAccessoryPoint(raw, gridStep, surfaceNormal), {
+        applySnap: !surfaceHit && isMagneticSnapActive(),
+        bypass: surfaceHit || !isMagneticSnapActive(),
+    });
     return {
-        position: [snap(raw[0], gridStep), 0, snap(raw[2], gridStep)],
-        rotation: [euler.x, euler.y, euler.z],
+        position: support(previewNode, rotation, snapped, raw, surfaceNormal),
+        rotation,
         snapPort: null,
+        node: previewNode,
+        valid: true,
     };
 }
 /**
@@ -72,51 +105,103 @@ function resolvePlacement(raw, previewNode, gridStep, manualQuat) {
 const DuctFittingTool = () => {
     const activeLevelId = useViewer((s) => s.selection.levelId);
     const [placement, setPlacement] = useState(null);
+    const toolDefaults = useEditor((s) => s.toolDefaults['duct-fitting']);
     const axis = useEditor((s) => s.rotationAxis);
     // Accumulated manual rotation from R/T presses. Ref (not state) so the
     // emitter callbacks always read the latest without re-subscribing; a
     // placement recompute is triggered explicitly after each change.
+    const support = useMemo(createFittingSurfaceSupport, []);
     const manualQuatRef = useRef(new Quaternion());
     // Last raw cursor position so a key press can recompute the placement
     // without waiting for the next mouse move.
+    const surfaceNormalRef = useRef(undefined);
+    const surfaceHitRef = useRef(false);
     const lastRawRef = useRef(null);
     // Ghost matches exactly what a click creates (the kind's defaults).
-    const previewNode = useMemo(() => DuctFittingNode.parse({ ...ductFittingDefinition.defaults(), name: 'Duct fitting' }), []);
+    const previewNode = useMemo(() => DuctFittingNode.parse({ ...ductFittingDefinition.defaults(), ...toolDefaults }), [toolDefaults]);
+    const displayNode = placement?.node ?? previewNode;
     const ghost = useMemo(() => {
-        const group = buildDuctFittingGeometry(previewNode);
+        const group = buildDuctFittingGeometry({
+            ...displayNode,
+            rotation: placement?.rotation ?? displayNode.rotation,
+        });
         group.traverse((child) => {
             // Overlay layer keeps the placement ghost out of the ink / SSGI
             // buffers and the thumbnail export, like every other tool preview.
             child.layers.set(EDITOR_LAYER);
-            const mesh = child;
-            if (mesh.material) {
-                mesh.material.transparent = true;
-                mesh.material.opacity = PREVIEW_OPACITY;
+            child.raycast = () => { };
+            if (child instanceof Mesh) {
+                const clone = (material) => {
+                    const copy = material.clone();
+                    copy.transparent = true;
+                    copy.opacity = PREVIEW_OPACITY;
+                    return copy;
+                };
+                child.material = Array.isArray(child.material)
+                    ? child.material.map(clone)
+                    : clone(child.material);
             }
         });
         return group;
-    }, [previewNode]);
+    }, [displayNode, placement?.rotation]);
+    useEffect(() => () => {
+        ghost.traverse((object) => {
+            if (!(object instanceof Mesh))
+                return;
+            object.geometry.dispose();
+            for (const material of Array.isArray(object.material) ? object.material : [object.material])
+                material.dispose();
+        });
+    }, [ghost]);
     useEffect(() => {
         if (!activeLevelId)
             return;
+        const draft = DuctFittingNode.parse({ ...previewNode, parentId: activeLevelId });
+        useInteractionScope.getState().begin({
+            kind: 'placing',
+            node: draft,
+            nodeId: draft.id,
+            nodeType: draft.type,
+            view: '3d',
+            pressDrag: false,
+            driver: 'registry-tool',
+        });
         const recompute = () => {
             const raw = lastRawRef.current;
             if (!raw)
                 return;
-            setPlacement(resolvePlacement(raw, previewNode, isGridSnapActive() ? useEditor.getState().gridSnapStep : 0, manualQuatRef.current));
+            const next = resolvePlacement(raw, previewNode, isGridSnapActive() ? useEditor.getState().gridSnapStep : 0, manualQuatRef.current, surfaceHitRef.current, surfaceNormalRef.current, support);
+            setPlacement((previous) => ({
+                ...next,
+                node: previous && JSON.stringify(previous.node) === JSON.stringify(next.node)
+                    ? previous.node
+                    : next.node,
+                rotation: previous?.rotation.every((v, i) => v === next.rotation[i])
+                    ? previous.rotation
+                    : next.rotation,
+            }));
         };
         const onMove = (event) => {
-            lastRawRef.current = [event.localPosition[0], 0, event.localPosition[2]];
+            const cursor = accessoryCursor(event, activeLevelId);
+            surfaceNormalRef.current = cursor.normal;
+            surfaceHitRef.current = cursor.surface;
+            lastRawRef.current = cursor.point;
             recompute();
         };
         const onClick = (event) => {
-            lastRawRef.current = [event.localPosition[0], 0, event.localPosition[2]];
-            const { position, rotation } = resolvePlacement(lastRawRef.current, previewNode, isGridSnapActive() ? useEditor.getState().gridSnapStep : 0, manualQuatRef.current);
+            const cursor = accessoryCursor(event, activeLevelId);
+            surfaceNormalRef.current = cursor.normal;
+            surfaceHitRef.current = cursor.surface;
+            lastRawRef.current = cursor.point;
+            const resolved = resolvePlacement(lastRawRef.current, previewNode, isGridSnapActive() ? useEditor.getState().gridSnapStep : 0, manualQuatRef.current, surfaceHitRef.current, surfaceNormalRef.current, support);
+            if (!resolved.valid)
+                return;
             const fitting = DuctFittingNode.parse({
-                ...ductFittingDefinition.defaults(),
-                name: 'Duct fitting',
-                position,
-                rotation,
+                ...resolved.node,
+                id: undefined,
+                name: resolved.node.fittingType.replaceAll('-', ' ').replace(/^./, (c) => c.toUpperCase()),
+                position: resolved.position,
+                rotation: resolved.rotation,
             });
             useScene.getState().createNode(fitting, activeLevelId);
             useViewer.getState().setSelection({ selectedIds: [fitting.id] });
@@ -144,17 +229,24 @@ const DuctFittingTool = () => {
                 cycleRotationAxis();
             }
         };
+        recompute();
+        const unsubscribeSnapping = subscribeAccessorySnapping(recompute);
         emitter.on('grid:move', onMove);
         emitter.on('grid:click', onClick);
         window.addEventListener('keydown', onKeyDown, true);
         return () => {
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'placing' && scope.nodeId === draft.id);
+            unsubscribeSnapping();
+            clearDrawAlignment();
             emitter.off('grid:move', onMove);
             emitter.off('grid:click', onClick);
             window.removeEventListener('keydown', onKeyDown, true);
         };
-    }, [activeLevelId, previewNode]);
+    }, [activeLevelId, previewNode, support]);
     if (!activeLevelId || !placement)
         return null;
-    return (_jsxs(LevelOffsetGroup, { children: [_jsx(CursorSphere, { position: placement.position }), _jsx("group", { position: placement.position, rotation: placement.rotation, children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [placement.position[0], placement.position[1] + 1.45, placement.position[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [_jsxs("span", { className: "font-medium text-foreground", children: ["Axis ", axis.toUpperCase()] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "\u2325 axis" })] }) }), placement.snapPort && (_jsxs("mesh", { layers: EDITOR_LAYER, position: placement.snapPort.position, children: [_jsx("sphereGeometry", { args: [0.18, 24, 16] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: 0.35, transparent: true })] }))] }));
+    return (_jsxs(LevelOffsetGroup, { children: [previewNode.fittingType !== 'access-panel' && (_jsx(ConnectionFeedback, { point: placement.position, target: placement.snapPort, levelId: activeLevelId, profile: displayNode })), _jsx(CursorSphere, { position: placement.position }), _jsx("group", { position: placement.position, rotation: placement.rotation, children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [placement.position[0], placement.position[1] + 1.45, placement.position[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [previewNode.fittingType === 'access-panel' && (_jsx("span", { children: placement.valid ? 'Place access door' : 'Hover a duct face that fits the door' })), _jsxs("span", { className: "font-medium text-foreground", children: ["Axis ", axis.toUpperCase()] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "\u2325 axis" })] }) }), placement.snapPort && (_jsxs("mesh", { layers: EDITOR_LAYER, position: placement.snapPort.position, children: [_jsx("sphereGeometry", { args: [0.18, 24, 16] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: 0.35, transparent: true })] }))] }));
 };
 export default DuctFittingTool;

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

@@ -0,0 +1,21 @@
+import { type AnyNode, type AnyNodeId, type DuctFittingNode, type FloorplanAffordance } from '@pascal-app/core';
+import { type RunContinuationHandlePlan } from '../shared/elbow-branch-continuation';
+import type { RunBodyHit, ScenePort } from '../shared/ports';
+import type { DuctSegmentNode } from './schema';
+export type DuctEndpoint = 'start' | 'end';
+export type DuctContinuationSeed = {
+    duct: DuctSegmentNode;
+    port: ScenePort | null;
+    body: RunBodyHit | null;
+    promotedFitting?: DuctFittingNode;
+};
+export declare function ductEndpointPort(duct: DuctSegmentNode, endpoint: DuctEndpoint): ScenePort | null;
+export declare function ductContinuationHandlePoint(duct: DuctSegmentNode, endpoint: DuctEndpoint, gap?: number): [number, number, number] | null;
+export declare function ductContinuationHandlePlan(duct: DuctSegmentNode, endpoint: DuctEndpoint, nodes: Readonly<Record<string, AnyNode>>, gap?: number): RunContinuationHandlePlan | null;
+export declare function resolveDuctContinuationSeed(defaults: unknown, nodes: Record<string, AnyNode>): DuctContinuationSeed | null;
+export declare function activateDuctBranch(duct: DuctSegmentNode, segmentIndex: number, point: [number, number, number]): void;
+export declare function activateDuctContinuation(duct: DuctSegmentNode, endpoint: DuctEndpoint, fittingId?: AnyNodeId): void;
+export declare const ductContinuationAffordance: FloorplanAffordance<DuctSegmentNode>;
+export declare const ductBranchAffordance: FloorplanAffordance<DuctSegmentNode>;
+export declare function currentDuctContinuationSeed(): DuctContinuationSeed | null;
+//# sourceMappingURL=continuation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"continuation.d.ts","sourceRoot":"","sources":["../../src/duct-segment/continuation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,mBAAmB,EAEzB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAIL,KAAK,yBAAyB,EAE/B,MAAM,qCAAqC,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,KAAK,CAAA;AAE1C,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,eAAe,CAAA;IACrB,IAAI,EAAE,SAAS,GAAG,IAAI,CAAA;IACtB,IAAI,EAAE,UAAU,GAAG,IAAI,CAAA;IACvB,eAAe,CAAC,EAAE,eAAe,CAAA;CAClC,CAAA;AAYD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,CAkBhG;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,GAAG,SAAO,GACT,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAQjC;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,GAAG,SAAO,GACT,yBAAyB,GAAG,IAAI,CAGlC;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,oBAAoB,GAAG,IAAI,CAiD7B;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,eAAe,EACrB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAC9B,IAAI,CAmBN;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,SAAS,CAAC,EAAE,SAAS,GACpB,IAAI,CAiBN;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,eAAe,CAiB3E,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,eAAe,CAiBrE,CAAA;AAED,wBAAgB,2BAA2B,IAAI,oBAAoB,GAAG,IAAI,CAKzE"}

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":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,aAAa,EAGnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAIL,eAAe,EACf,KAAK,EACL,KAAK,QAAQ,EAEb,IAAI,EAMJ,OAAO,EACR,MAAM,OAAO,CAAA;AAGd,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,gBAAgB,SAAS,CAAA;AAuBtC;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,kEAAkE;AAClE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,GAAG,MAAM,CAQT;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,SAAI,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAW3F;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,OAAO,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,OAAO,GACd,MAAM,CAeR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,SAAI,GACP,IAAI,GAAG,IAAI,CAcb;AAiBD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,eAAe,CASjB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,SAAI,GACP,IAAI,GAAG,IAAI,CAab;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,GACX,IAAI,GAAG,IAAI,CAcb;AAyED,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE,aAAa,GAAG,QAAQ,GAAG,MAAM,GAAG,YAAY,CAAA;IAC9D,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/B,CAAA;AAMD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,cAAc,EACpB,cAAc,CAAC,EAAE,eAAe,CAAC,WAAW,CAAC,EAC7C,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,QAAQ,CAYV;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,eAAe,EACrB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CA0HP"}

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"}