@pascal-app/nodes 0.1.1

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

@@ -0,0 +1,347 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { analyzePortConnectivity, DuctSegmentNode, emitter, sceneRegistry, useScene, } from '@pascal-app/core';
+import { consumePlacementDragRelease, DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useRef, useState } from 'react';
+import { Matrix4, Vector3 } from 'three';
+import { collectGhostAlignmentCandidates, resolveGhostAlignment, } from '../shared/ghost-alignment';
+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 { 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;
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+function pathCenterXZ(path) {
+    let x = 0;
+    let z = 0;
+    for (const p of path) {
+        x += p[0];
+        z += p[2];
+    }
+    const n = path.length || 1;
+    return [x / n, z / n];
+}
+/** Half the run's cross-section (meters) — the box / footprint padding. */
+function runRadiusM(duct) {
+    if (duct.shape === 'round')
+        return (duct.diameter * IN_TO_M) / 2;
+    return (Math.max(duct.width, duct.height) * IN_TO_M) / 2;
+}
+/** The run's vertical box extent (meters). */
+function runHeightM(duct) {
+    return (duct.shape === 'round' ? duct.diameter : duct.height) * IN_TO_M;
+}
+/** XZ bounds of a path padded by the run's radius. */
+function pathAabb(path, r) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const p of path) {
+        if (p[0] < minX)
+            minX = p[0];
+        if (p[0] > maxX)
+            maxX = p[0];
+        if (p[2] < minZ)
+            minZ = p[2];
+        if (p[2] > maxZ)
+            maxZ = p[2];
+    }
+    return { minX: minX - r, maxX: maxX + r, minZ: minZ - r, maxZ: maxZ + r };
+}
+/**
+ * Ghost-preview duplicate / move tool for duct runs.
+ *
+ * **Duplicate** (`metadata.isNew`): pure drag-to-place — NOTHING is
+ * inserted into the scene until the commit click. A translucent ghost of
+ * the run (cylinders / boxes matching its profile) rides the cursor inside
+ * a footprint bounding box — the same affordance other items get — and
+ * Figma-style alignment guides snap the box's edges to nearby geometry. The
+ * next grid click calls `createNode`; Esc discards.
+ *
+ * **Move** (existing run): the real node is hidden while the same ghost +
+ * box tracks the cursor; the commit click writes the translated `path` and
+ * reveals it, Esc reveals it unchanged.
+ *
+ * Wired via `def.affordanceTools.move`.
+ */
+export const MoveDuctSegmentTool = ({ node }) => {
+    const duct = node;
+    const originalPathRef = useRef(duct.path.map((p) => [...p]));
+    const isNew = typeof node.metadata === 'object' &&
+        node.metadata !== null &&
+        !Array.isArray(node.metadata) &&
+        node.metadata.isNew === true;
+    const [previewPath, setPreviewPath] = useState(originalPathRef.current);
+    const [translationGhost, setTranslationGhost] = useState(null);
+    const previewPathRef = useRef(originalPathRef.current);
+    const hasMovedRef = useRef(false);
+    const activatedAtRef = useRef(Date.now());
+    const prevSnapRef = useRef(null);
+    useEffect(() => {
+        const nodeId = node.id;
+        const originalPath = originalPathRef.current;
+        const [centerX, centerZ] = pathCenterXZ(originalPath);
+        const r = runRadiusM(duct);
+        const baseAabb = pathAabb(originalPath, r);
+        useScene.temporal.getState().pause();
+        let committed = false;
+        const candidates = collectGhostAlignmentCandidates(useScene.getState().nodes, nodeId, useViewer.getState().selection.levelId ?? node.parentId);
+        // Moving an existing run: hide its 3D MESH imperatively (NOT the store
+        // `visible` flag — the 2D floor plan skips `visible:false` nodes, so a
+        // store hide makes the run vanish in 2D / split view). The ghost stands
+        // in until commit; the real mesh is restored on cancel / unmount.
+        const existedAtStart = !isNew && !!useScene.getState().nodes[nodeId];
+        const setMeshHidden = (hidden) => {
+            const obj = sceneRegistry.nodes.get(nodeId);
+            if (obj)
+                obj.visible = !hidden;
+        };
+        if (existedAtStart)
+            setMeshHidden(true);
+        // Carry connected fittings (+ their other runs) as the whole run slides.
+        // Snapshot once at drag start; only existing runs are mated to anything.
+        const connectivity = existedAtStart
+            ? startRunMoveConnectivity(node)
+            : null;
+        const portConnectivity = existedAtStart
+            ? analyzePortConnectivity(node, useScene.getState().nodes)
+            : null;
+        const scenePorts = existedAtStart
+            ? collectScenePorts({ excludeNodeId: nodeId, systems: DUCT_PORT_SYSTEMS })
+            : [];
+        const nodesById = useScene.getState().nodes;
+        const profile = {
+            shape: duct.shape,
+            diameter: duct.diameter,
+            width: duct.width,
+            height: duct.height,
+        };
+        let lastTranslationPlan = null;
+        const setPreview = (path) => {
+            previewPathRef.current = path;
+            setPreviewPath(path);
+        };
+        const onMove = (event) => {
+            const snap = isGridSnapActive() ? snapToGridStep : (v) => v;
+            let dx = snap(event.localPosition[0] - centerX);
+            let dz = snap(event.localPosition[2] - centerZ);
+            // Figma-style magnetic alignment: snap the run's footprint box edges onto
+            // nearby geometry and publish the guides. Grid follows the snapping mode;
+            // lines follow magnetic alignment — the two are independent.
+            if (isAlignmentGuideActive()) {
+                const proposed = {
+                    minX: baseAabb.minX + dx,
+                    maxX: baseAabb.maxX + dx,
+                    minZ: baseAabb.minZ + dz,
+                    maxZ: baseAabb.maxZ + dz,
+                };
+                const { dx: sdx, dz: sdz, guides } = resolveGhostAlignment(nodeId, proposed, candidates);
+                if (isMagneticSnapActive()) {
+                    dx += sdx;
+                    dz += sdz;
+                }
+                useAlignmentGuides.getState().set(guides);
+            }
+            else {
+                useAlignmentGuides.getState().clear();
+            }
+            const cur = [centerX + dx, centerZ + dz];
+            if ((isGridSnapActive() || isMagneticSnapActive()) &&
+                (!prevSnapRef.current ||
+                    prevSnapRef.current[0] !== cur[0] ||
+                    prevSnapRef.current[1] !== cur[1])) {
+                triggerSFX('sfx:grid-snap');
+            }
+            prevSnapRef.current = cur;
+            hasMovedRef.current = true;
+            const nextPath = originalPath.map(([x, y, z]) => [x + dx, y, z + dz]);
+            setPreview(nextPath);
+            lastTranslationPlan =
+                existedAtStart && portConnectivity
+                    ? planRunTranslationOffsets({
+                        duct,
+                        translatedPath: nextPath,
+                        profile,
+                        connections: portConnectivity.connections,
+                        scenePorts,
+                        nodesById,
+                    })
+                    : null;
+            if (lastTranslationPlan)
+                connectivity?.clear();
+            else
+                connectivity?.preview({ path: nextPath });
+            setTranslationGhost(lastTranslationPlan);
+        };
+        const commit = (event, fromDragRelease = false) => {
+            if (committed)
+                return;
+            // The 150ms debounce only guards click-to-place against the arming click
+            // double-firing; a press-drag release is a distinct pointerup gesture, so
+            // it skips the guard (a quick drag-flick still commits).
+            if (!fromDragRelease && Date.now() - activatedAtRef.current < 150) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            if (!hasMovedRef.current) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            committed = true;
+            const finalPath = previewPathRef.current;
+            useScene.temporal.getState().resume();
+            let selectId = nodeId;
+            if (isNew && !useScene.getState().nodes[nodeId]) {
+                const created = DuctSegmentNode.parse({
+                    ...node,
+                    path: finalPath,
+                    metadata: stripPlacementMetadataFlags(node.metadata),
+                    visible: true,
+                });
+                useScene.getState().createNode(created, node.parentId);
+                selectId = created.id;
+            }
+            else {
+                const translationPlan = portConnectivity &&
+                    planRunTranslationOffsets({
+                        duct,
+                        translatedPath: finalPath,
+                        profile,
+                        connections: portConnectivity.connections,
+                        scenePorts,
+                        nodesById,
+                    });
+                if (translationPlan) {
+                    useScene.getState().applyNodeChanges({
+                        create: [...translationPlan.fittings, ...translationPlan.connectors].map((created) => ({
+                            node: created,
+                            parentId: node.parentId,
+                        })),
+                        update: [
+                            { id: nodeId, data: { path: translationPlan.ductPath } },
+                            ...translationPlan.updates,
+                        ],
+                    });
+                }
+                else {
+                    // 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 } },
+                        ...followUpdates,
+                    ]);
+                }
+                useScene.getState().markDirty(nodeId);
+            }
+            useScene.temporal.getState().pause();
+            // Followers are committed to the store — drop their live overrides so
+            // renderers read the canonical path/position.
+            connectivity?.clear();
+            setMeshHidden(false);
+            useAlignmentGuides.getState().clear();
+            triggerSFX('sfx:item-place');
+            useViewer.getState().setSelection({ selectedIds: [selectId] });
+            useEditor.getState().setMovingNodeOrigin('3d');
+            useEditor.getState().setMovingNode(null);
+            event.nativeEvent?.stopPropagation?.();
+        };
+        const onCancel = () => {
+            connectivity?.clear();
+            setTranslationGhost(null);
+            if (existedAtStart) {
+                setMeshHidden(false);
+                useViewer.getState().setSelection({ selectedIds: [nodeId] });
+            }
+            useAlignmentGuides.getState().clear();
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            useEditor.getState().setMovingNodeOrigin('3d');
+            useEditor.getState().setMovingNode(null);
+        };
+        // Press-drag-release: when the move was engaged by the drag gesture (the
+        // selection rig's move cross), `placementDragMode` is set, so commit on
+        // pointer-up at the last previewed path instead of waiting for a second
+        // click — same contract as the fitting move tool.
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            if (!hasMovedRef.current) {
+                onCancel();
+                return;
+            }
+            commit({
+                nativeEvent: event,
+                stopPropagation: () => event.stopPropagation(),
+            }, true);
+        };
+        emitter.on('grid:move', onMove);
+        emitter.on('grid:click', commit);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            emitter.off('grid:move', onMove);
+            emitter.off('grid:click', commit);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+            connectivity?.clear();
+            setTranslationGhost(null);
+            useAlignmentGuides.getState().clear();
+            if (existedAtStart)
+                setMeshHidden(false);
+            useScene.temporal.getState().resume();
+        };
+    }, [duct, isNew, node]);
+    const segments = [];
+    for (let i = 0; i < previewPath.length - 1; i++) {
+        segments.push({ a: previewPath[i], b: previewPath[i + 1] });
+    }
+    // Footprint box spanning the whole run (axis-aligned), drawn around the
+    // ghost the same way items get one. Recomputed from the live preview path.
+    const r = runRadiusM(duct);
+    const box = pathAabb(previewPath, r);
+    const boxY = previewPath[0]?.[1] ?? 0;
+    return (_jsxs("group", { children: [segments.map((seg, i) => (_jsx(GhostSegment, { a: seg.a, b: seg.b, duct: duct }, `ghost-${i}`))), translationGhost?.fittings.map((fitting) => (_jsx(FittingGhost, { fitting: fitting, tint: "valid" }, `translation-fitting-${fitting.id}`))), translationGhost?.connectors.map((connector) => (_jsx(DuctSegmentGhost, { duct: connector, tint: "valid" }, `translation-connector-${connector.id}`))), _jsx(DragBoundingBox, { centerY: 0, nodeId: node.id, position: [(box.minX + box.maxX) / 2, boxY, (box.minZ + box.maxZ) / 2], size: [box.maxX - box.minX, runHeightM(duct), box.maxZ - box.minZ] })] }));
+};
+/** Translucent stand-in for one duct section — mirrors the draw tool's
+ *  `PreviewSegment` so the ghost matches what actually lands. */
+function GhostSegment({ a, b, duct }) {
+    const start = new Vector3(...a);
+    const end = new Vector3(...b);
+    const dir = new Vector3().subVectors(end, start);
+    const length = dir.length();
+    if (length < 1e-4)
+        return null;
+    dir.normalize();
+    const mid = new Vector3().addVectors(start, end).multiplyScalar(0.5);
+    if (duct.shape !== 'round') {
+        const w = duct.width * IN_TO_M;
+        const h = duct.height * IN_TO_M;
+        return (_jsxs("mesh", { layers: EDITOR_LAYER, position: mid.toArray(), ref: (m) => {
+                if (!m)
+                    return;
+                const { width: x, height: z } = rectSectionAxes(dir, duct.roll);
+                m.quaternion.setFromRotationMatrix(new Matrix4().makeBasis(x, dir, z));
+            }, children: [_jsx("boxGeometry", { args: [w, length, h] }), _jsx("meshBasicMaterial", { color: GHOST_COLOR, depthTest: false, opacity: GHOST_OPACITY, transparent: true })] }));
+    }
+    const radius = (duct.diameter * IN_TO_M) / 2;
+    return (_jsxs("mesh", { layers: EDITOR_LAYER, position: mid.toArray(), ref: (m) => {
+            if (!m)
+                return;
+            m.quaternion.setFromUnitVectors(new Vector3(0, 1, 0), dir);
+        }, children: [_jsx("cylinderGeometry", { args: [radius, radius, length, 24, 1, false] }), _jsx("meshBasicMaterial", { color: GHOST_COLOR, depthTest: false, opacity: GHOST_OPACITY, transparent: true })] }));
+}
+export default MoveDuctSegmentTool;

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

@@ -0,0 +1,4 @@
+import { type ParametricDescriptor } from '@pascal-app/core';
+import type { DuctSegmentNode } from './schema';
+export declare const ductSegmentParametrics: ParametricDescriptor<DuctSegmentNode>;
+//# sourceMappingURL=parametrics.d.ts.map

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

@@ -0,0 +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"}

package/dist/duct-segment/parametrics.js

@@ -0,0 +1,165 @@
+import { useScene } from '@pascal-app/core';
+import { Vector3 } from 'three';
+import { getDuctFittingPorts } from '../duct-fitting/ports';
+import { rollToContinueAcrossElbow } from './geometry';
+/** A run endpoint sitting this close to a collar counts as mated. */
+const MATE_TOL_M = 0.03;
+function dist2(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return dx * dx + dy * dy + dz * dz;
+}
+/**
+ * Cross-section roll that keeps this run continuous through a fitting
+ * mated at either endpoint — the same continuity the draw tool computes
+ * for freshly drawn risers (`rollToContinueAcrossElbow`), recovered here
+ * for runs whose shape is flipped to rect AFTER they were drawn. Without
+ * it a riser falls back to the world-axis orientation and its profile
+ * lands 90° off the elbow it rises from. Returns null when no fitting is
+ * mated (roll 0 — the natural horizontal orientation — is correct).
+ */
+function rollFromMatedFitting(duct) {
+    if (duct.path.length < 2)
+        return null;
+    const first = duct.path[0];
+    const last = duct.path[duct.path.length - 1];
+    const ends = [
+        { point: first, away: duct.path[1] },
+        { point: last, away: duct.path[duct.path.length - 2] },
+    ];
+    const tol2 = MATE_TOL_M * MATE_TOL_M;
+    for (const node of Object.values(useScene.getState().nodes)) {
+        if (node.type !== 'duct-fitting')
+            continue;
+        const fitting = node;
+        if (fitting.fittingType === 'reducer')
+            continue;
+        const ports = getDuctFittingPorts(fitting);
+        for (const end of ends) {
+            const mated = ports.find((p) => dist2(end.point, p.position) <= tol2);
+            if (!mated)
+                continue;
+            // The leg on the far side of the junction is the source the
+            // profile must stay continuous with: an elbow's other run leg, or
+            // the tee's run when this duct is the branch.
+            const source = ports.find((p) => p.id !== mated.id && p.id !== 'branch');
+            if (!source)
+                continue;
+            const srcDuct = Object.values(useScene.getState().nodes).find((n) => n.type === 'duct-segment' &&
+                n.id !== duct.id &&
+                (n.path.length >= 2
+                    ? dist2(n.path[0], source.position) <= tol2 ||
+                        dist2(n.path[n.path.length - 1], source.position) <= tol2
+                    : false));
+            const newDir = new Vector3(end.away[0] - end.point[0], end.away[1] - end.point[1], end.away[2] - end.point[2]);
+            if (newDir.lengthSq() < 1e-10)
+                continue;
+            newDir.normalize();
+            // Only steep runs are ambiguous (world-axis fallback); a
+            // horizontal run's roll-0 orientation is already canonical, and
+            // re-deriving it from a possibly-stale riser roll would corrupt it.
+            if (Math.abs(newDir.y) < Math.SQRT1_2)
+                continue;
+            const srcRoll = srcDuct && srcDuct.shape !== 'round' ? srcDuct.roll : 0;
+            const srcDir = new Vector3(...source.direction);
+            return rollToContinueAcrossElbow(srcDir, srcRoll, srcDir, newDir);
+        }
+    }
+    return null;
+}
+export const ductSegmentParametrics = {
+    // Flipping a drawn run to rect / oval recovers the cross-section roll
+    // the draw tool would have computed — risers re-orient to stay
+    // continuous through the elbow they turn off instead of snapping to
+    // the world-axis fallback. Spiral is a round-only construction, so a
+    // 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 = {};
+        if (next.ductMaterial === 'spiral' && next.shape !== 'round') {
+            out.ductMaterial = 'sheet-metal';
+        }
+        if ('shape' in patch && next.shape !== 'round') {
+            const roll = rollFromMatedFitting(next);
+            if (roll !== null)
+                out.roll = roll;
+        }
+        return out;
+    },
+    groups: [
+        {
+            label: 'Air',
+            fields: [
+                {
+                    key: 'system',
+                    kind: 'enum',
+                    options: ['supply', 'return'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'shape',
+                    kind: 'enum',
+                    options: ['round', 'rect', 'oval'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'diameter',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 4,
+                    max: 24,
+                    step: 1,
+                    visibleIf: (n) => n.shape === 'round',
+                },
+                {
+                    key: 'width',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 4,
+                    max: 60,
+                    step: 1,
+                    visibleIf: (n) => n.shape !== 'round',
+                },
+                {
+                    key: 'height',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 3,
+                    max: 40,
+                    step: 1,
+                    visibleIf: (n) => n.shape !== 'round',
+                },
+            ],
+        },
+        {
+            label: 'Construction',
+            fields: [
+                {
+                    key: 'ductMaterial',
+                    kind: 'enum',
+                    options: ['sheet-metal', 'spiral', 'flex', 'duct-board'],
+                },
+                {
+                    key: 'seamDetail',
+                    kind: 'boolean',
+                    // Only meaningful where a body detail exists: round spiral
+                    // (lock seam) and round flex (wire corrugation).
+                    visibleIf: (n) => n.shape === 'round' && (n.ductMaterial === 'spiral' || n.ductMaterial === 'flex'),
+                },
+                {
+                    key: 'insulated',
+                    kind: 'boolean',
+                },
+                {
+                    key: 'insulationR',
+                    kind: 'number',
+                    min: 0,
+                    max: 8,
+                    step: 0.5,
+                    visibleIf: (n) => n.insulated,
+                },
+            ],
+        },
+    ],
+};

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

@@ -0,0 +1,2 @@
+export { DuctSegmentNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/duct-segment/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/duct-segment/schema.js

@@ -0,0 +1 @@
+export { DuctSegmentNode } from '@pascal-app/core';

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

@@ -0,0 +1,34 @@
+/**
+ * Selection-time editing for committed duct runs: each path point shows a
+ * cluster of directional arrows instead of a free-drag handle — four XZ
+ * chevrons (±X / ±Z) plus an up / down vertical pair.
+ *
+ * Handles are PORTALED into the duct's registered scene group so they
+ * share its exact frame — path coords are node-local, and the level /
+ * building transform above the group applies to the handles for free.
+ * Drag raycasts run in world space and convert hits back into the
+ * group's local frame before writing the path.
+ *
+ * Drag model: the along-run arrow lengthens / shortens the run (locked to the
+ * run axis). The across-run (side) and up / down arrows instead SWING the
+ * grabbed endpoint around its neighbour at a fixed radius — the run pivots like
+ * a compass arm, keeping its length, rather than stretching. Dragged run
+ * endpoints still snap onto nearby typed ports (along-run drag) so a loose run
+ * can be mated onto a fitting after the fact, and when the dragged endpoint
+ * belongs to a straight run whose OTHER end sits on an elbow collar, the elbow
+ * re-aims to follow the drag (junction + far collar fixed, bend angle adapts).
+ *
+ * Modifiers (mirroring the wall corner drag):
+ * - **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.
+ *
+ * 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
+ * change.
+ */
+declare const DuctSegmentSelectionAffordance: () => import("react").JSX.Element | null;
+export default DuctSegmentSelectionAffordance;
+//# sourceMappingURL=selection.d.ts.map

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

@@ -0,0 +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"}