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

package/dist/duct-segment/tool.js

@@ -1,19 +1,25 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { DuctSegmentNode, emitter, getCeilingAt, getCeilingHeightAt, resolveCeilingHeight, useScene, } from '@pascal-app/core';
-import { CursorSphere, DimensionPill, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useEditor, usePathDraftPreview, } from '@pascal-app/editor';
-import { useViewer } from '@pascal-app/viewer';
-import { Html } from '@react-three/drei';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DuctSegmentNode } from '@pascal-app/core';
+import { EDITOR_LAYER, triggerSFX, useEditor, usePathDraftPreview, useRegistryToolContext, } from '@pascal-app/editor';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { DoubleSide, Matrix4, Path, Shape, ShapeGeometry, Vector3, } from 'three';
+import { Euler, Vector3 } from 'three';
 import { getDuctFittingPorts } from '../duct-fitting/ports';
 import { planCrossAtRunBody, planElbowAtPort, planElbowRealign, planTeeAtRunBody, } from '../shared/auto-fitting';
-import { alignDrawPoint, clearDrawAlignment } from '../shared/draw-alignment';
+import { createDuctRunEndCap, findMatedRunEndCapIds, isRunEndCapPort, } from '../shared/automatic-run-end-cap';
+import { ConnectionFeedback } from '../shared/connection-feedback';
+import { createRunWallAttachment } from '../shared/distribution-run-contract';
+import { DistributionRunCursor, runDistanceSquared as dist2, runSectionHalfSizeM, stepNominalRunSize, useDistributionRunTool, } from '../shared/distribution-run-tool';
+import { ductProfilesMatch, planDuctAdapter } from '../shared/duct-adapter';
+import { FITTING_CLEARANCE_MESSAGE, hasFittingClearance } from '../shared/fitting-clearance';
 import { LevelOffsetGroup } from '../shared/level-offset-group';
-import { FittingGhost } from '../shared/mep-ghost';
-import { collectScenePorts, DUCT_PORT_SYSTEMS, findNearestPortXZ, findNearestRunBodyXZ, findRunBodyCrossingXZ, } from '../shared/ports';
+import { DuctSegmentGhost, FittingGhost } from '../shared/mep-ghost';
+import { collectScenePorts, DUCT_PORT_SYSTEMS, findNearestRunBody3D, findRunBodyCrossingSurface, } from '../shared/ports';
+import { RunHangerPreview } from '../shared/run-hanger-controls';
+import { useRunHangerMode } from '../shared/run-hanger-mode';
+import { currentDuctContinuationSeed, ductEndpointPort } from './continuation';
 import { ductSegmentDefinition } from './definition';
-import { ductPortDiameterIn, rectSectionAxes, rollToContinueAcrossElbow } from './geometry';
+import { rectSectionAxes, rollToContinueAcrossElbow } from './geometry';
 /**
  * Continuous placement tool for duct segments.
  *
@@ -42,46 +48,15 @@ import { ductPortDiameterIn, rectSectionAxes, rollToContinueAcrossElbow } from '
  *     vertical mouse motion drives Y. Click commits the riser segment.
  *   - **[ / ]** step the duct diameter through nominal US sizes; the
  *     ghost preview and the committed node both use it.
- *   - **C** toggles ceiling-level placement: each point lands just below
- *     the ceiling actually covering it (duct top hugging that ceiling)
- *     instead of the floor, so a run tracks per-room ceiling heights.
- *     Points not under any ceiling fall back to the floor.
- *   - Esc clears an anchored start point.
+ *   - Esc exits drawing.
  */
-const PREVIEW_OPACITY = 0.55;
 /**
  * Nominal US round-duct sizes (inches): 4"–10" in 1" steps, 12"+ in 2"
  * steps — matches what flex and rigid round actually ship in.
  */
 const DUCT_DIAMETERS_IN = [4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20];
-/** Snap radius (meters) for joining onto an existing duct's start/end. */
-const ENDPOINT_SNAP_RADIUS_M = 0.5;
-/** Snap radius (meters) for tapping the SIDE of an existing run — a tee
- *  is minted there. Tighter than the port radius so run ends keep
- *  priority near their last stretch. */
 const BODY_SNAP_RADIUS_M = 0.35;
 /** Angle step (radians) for the XZ angle lock — 45°. */
-const ANGLE_STEP_RAD = Math.PI / 4;
-/** Mouse pixels → meters mapping for Alt-vertical drag. 100 px ≈ 1 m. */
-const ALT_PIXELS_PER_METER = 100;
-/** Bounds on Alt-driven Y so a wild fling doesn't fly off. */
-const ALT_Y_MIN_M = -3;
-const ALT_Y_MAX_M = 10;
-/** green-500 — the project's bounding-box / placeable accent. The cursor
- *  ring + vertical line recolour to this while the point is snapped onto an
- *  existing run, so the coincidence reads with the familiar snap green. */
-const SNAP_CURSOR_COLOR = '#22c55e';
-function snap(value, step) {
-    if (step <= 0)
-        return value;
-    return Math.round(value / step) * step;
-}
-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 for a new rect run leaving `port` along `newDir`,
  * so its profile stays continuous with whatever it joined: a turn
@@ -92,11 +67,15 @@ function dist2(a, b) {
  * there). Null when the port doesn't carry a rect orientation. Shared
  * by the ghost preview and the commit so what you see is what lands.
  */
-function continuityRollFrom(port, newDir) {
+function continuityRollFrom(port, newDir, nodes) {
     if (!port)
         return null;
-    const nodes = useScene.getState().nodes;
     const owner = nodes[port.nodeId];
+    if (owner?.type === 'duct-fitting' && ['reducer', 'transition'].includes(owner.fittingType)) {
+        const width = new Vector3(0, 0, 1).applyEuler(new Euler(...owner.rotation));
+        const basis = rectSectionAxes(newDir);
+        return Math.atan2(width.dot(basis.height), width.dot(basis.width));
+    }
     let srcDir = null;
     let srcRoll = 0;
     if ((owner?.type === 'hvac-equipment' || owner?.type === 'duct-terminal') &&
@@ -134,26 +113,26 @@ function continuityRollFrom(port, newDir) {
     if (!srcDir)
         return null;
     const cross = new Vector3().crossVectors(srcDir, newDir);
-    if (cross.lengthSq() < 1e-8)
+    if (cross.lengthSq() < 1e-8) {
+        if (owner?.type === 'duct-segment') {
+            const i = port.id === 'start' ? 0 : owner.path.length - 2;
+            const direction = new Vector3(...owner.path[i + 1]).sub(new Vector3(...owner.path[i]));
+            const width = rectSectionAxes(direction, owner.roll).width;
+            const basis = rectSectionAxes(newDir);
+            return Math.atan2(width.dot(basis.height), width.dot(basis.width));
+        }
         return srcRoll;
+    }
     return rollToContinueAcrossElbow(srcDir, srcRoll, srcDir, newDir);
 }
-function continuityRollForRun(startPort, endPort, dir) {
-    return continuityRollFrom(startPort, dir) ?? continuityRollFrom(endPort, dir) ?? 0;
-}
-/**
- * Nearest typed port — duct run ends, fitting collars, anything whose
- * kind registers `def.ports` — within snap range of `point` on the XZ
- * plane. Y is ignored for the distance check (grid events ride the floor
- * while ports hang at duct height); the snap adopts the port's full 3D
- * position. The full port is returned so the commit knows what it joined
- * (auto-elbow insertion needs the port's direction and owner).
- */
-function findNearbyPort(point) {
-    return findNearestPortXZ(point, collectScenePorts({ systems: DUCT_PORT_SYSTEMS }), ENDPOINT_SNAP_RADIUS_M);
+function continuityRollForRun(startPort, endPort, dir, nodes) {
+    return continuityRollFrom(startPort, dir, nodes) ?? continuityRollFrom(endPort, dir, nodes) ?? 0;
 }
-function portPoint(port) {
-    return [port.position[0], port.position[1], port.position[2]];
+function getConnectionPorts(levelId, nodes) {
+    return collectScenePorts({
+        systems: DUCT_PORT_SYSTEMS,
+        levelId: levelId ?? undefined,
+    }).filter((port) => !isRunEndCapPort(port, nodes));
 }
 /**
  * Profile to inherit when the segment start snaps onto `port` — joining
@@ -161,16 +140,16 @@ function portPoint(port) {
  * run / fitting collar keeps its diameter. Equipment and terminal
  * collars are round at the port's advertised size.
  */
-function inheritProfile(port) {
-    const owner = useScene.getState().nodes[port.nodeId];
+function inheritProfile(port, nodes) {
+    const owner = nodes[port.nodeId];
     if (!owner)
         return null;
     if (owner.type === 'duct-segment' || owner.type === 'duct-fitting') {
         return {
-            shape: owner.shape,
+            shape: port.shape ?? owner.shape,
             diameter: Math.min(48, Math.max(2, owner.type === 'duct-segment' ? owner.diameter : port.diameter)),
-            width: owner.width,
-            height: owner.height,
+            width: port.width ?? owner.width,
+            height: port.height ?? owner.height,
         };
     }
     if (owner.type === 'hvac-equipment' || owner.type === 'duct-terminal') {
@@ -195,52 +174,38 @@ function inheritProfile(port) {
     }
     return null;
 }
-/**
- * Project `raw` onto the nearest of the eight 45° rays emanating from
- * `from` in the XZ plane. Y is preserved from `from`. The projection
- * keeps the cursor's *distance* along the chosen ray so the user feels
- * the segment grow with their mouse motion rather than snap to a fixed
- * length.
- */
-function projectToAngleLock(from, raw) {
-    const dx = raw[0] - from[0];
-    const dz = raw[2] - from[2];
-    const len = Math.hypot(dx, dz);
-    if (len < 1e-4)
-        return [from[0], from[1], from[2]];
-    const theta = Math.atan2(dz, dx);
-    const snapped = Math.round(theta / ANGLE_STEP_RAD) * ANGLE_STEP_RAD;
-    // Distance along the chosen ray = projection of raw onto that direction.
-    const proj = dx * Math.cos(snapped) + dz * Math.sin(snapped);
-    const d = Math.max(0, proj);
-    return [from[0] + Math.cos(snapped) * d, from[1], from[2] + Math.sin(snapped) * d];
-}
-const elbowPlanFor = (port, awayDir, profile) => {
+const elbowPlanFor = (port, awayDir, profile, nodes) => {
     if (!port)
         return null;
-    const owner = useScene.getState().nodes[port.nodeId];
+    const owner = nodes[port.nodeId];
     if (owner?.type !== 'duct-segment')
         return null;
-    const plan = planElbowAtPort(port, awayDir, profile);
+    const source = inheritProfile(port, nodes) ?? profile;
+    const plan = planElbowAtPort(port, awayDir, source);
     if (!plan)
         return null;
     // Trim the run's snapped endpoint back to the elbow's inlet collar.
     const path = owner.path.map((p) => [...p]);
     const index = port.id === 'start' ? 0 : path.length - 1;
     const neighbor = path[index === 0 ? 1 : index - 1];
-    const remaining = Math.hypot(plan.trimmedPortPoint[0] - neighbor[0], plan.trimmedPortPoint[1] - neighbor[1], plan.trimmedPortPoint[2] - neighbor[2]);
-    // The trim must leave a real piece of the existing run AND not flip it.
     const original = path[index];
-    const originalLen = Math.hypot(original[0] - neighbor[0], original[1] - neighbor[1], original[2] - neighbor[2]);
-    if (remaining < 0.08 || remaining >= originalLen)
-        return null;
+    const direction = [
+        original[0] - neighbor[0],
+        original[1] - neighbor[1],
+        original[2] - neighbor[2],
+    ];
+    const hasClearance = hasFittingClearance(neighbor, plan.trimmedPortPoint, direction, 0.08);
     path[index] = plan.trimmedPortPoint;
-    return { ...plan, trim: { id: port.nodeId, data: { path } } };
+    return {
+        ...plan,
+        hasClearance,
+        trim: { id: port.nodeId, data: { path } },
+    };
 };
-const realignPlanFor = (port, awayDir) => {
+const realignPlanFor = (port, awayDir, nodes) => {
     if (!port)
         return null;
-    const owner = useScene.getState().nodes[port.nodeId];
+    const owner = nodes[port.nodeId];
     if (owner?.type !== 'duct-fitting')
         return null;
     return planElbowRealign(owner, port.id, awayDir);
@@ -251,10 +216,10 @@ const realignPlanFor = (port, awayDir) => {
  * tap), decide every node the commit creates / updates — auto-inserted
  * elbows / tees / crosses, the drawn run (split in two when it crosses a
  * trunk), trunk tails, and trim / realign updates. Reads the live scene
- * graph but mutates nothing, so the live preview can call it each frame
- * to ghost the fittings before the commit applies the identical plan.
+ * graph snapshot but mutates nothing, so the live preview can call it each
+ * frame to ghost the fittings before the commit applies the identical plan.
  */
-function planDuctDraw(start, end, startPort, startBody, endPort, endBody, profile) {
+export function planDuctDraw(start, end, startPort, startBody, endPort, endBody, profile, nodes, surface, autoHangers = false, toolDefaults = {}, hangerStyle = 'single') {
     const length = Math.hypot(end[0] - start[0], end[1] - start[1], end[2] - start[2]);
     if (length < 1e-4)
         return null;
@@ -263,56 +228,107 @@ function planDuctDraw(start, end, startPort, startBody, endPort, endBody, profil
         (end[1] - start[1]) / length,
         (end[2] - start[2]) / length,
     ];
-    const startPlan = elbowPlanFor(startPort, dir, profile);
-    const endPlan = elbowPlanFor(endPort, [-dir[0], -dir[1], -dir[2]], profile);
-    const startRealign = startPlan ? null : realignPlanFor(startPort, dir);
-    const endRealign = endPlan ? null : realignPlanFor(endPort, [-dir[0], -dir[1], -dir[2]]);
+    const startPlan = elbowPlanFor(startPort, dir, profile, nodes);
+    const endPlan = elbowPlanFor(endPort, [-dir[0], -dir[1], -dir[2]], profile, nodes);
+    const invalidPlan = () => ({
+        validationMessage: FITTING_CLEARANCE_MESSAGE,
+        fittings: [],
+        ducts: [],
+        tails: [],
+        updates: [],
+        delete: [],
+    });
+    if (startPlan?.hasClearance === false || endPlan?.hasClearance === false)
+        return invalidPlan();
+    const startRealign = startPlan ? null : realignPlanFor(startPort, dir, nodes);
+    const endRealign = endPlan ? null : realignPlanFor(endPort, [-dir[0], -dir[1], -dir[2]], nodes);
     const trunkBody = startPlan ? null : startBody;
-    const trunkOwner = trunkBody ? useScene.getState().nodes[trunkBody.nodeId] : null;
+    const trunkOwner = trunkBody ? nodes[trunkBody.nodeId] : null;
     const teePlan = trunkBody && trunkOwner?.type === 'duct-segment'
         ? planTeeAtRunBody(trunkOwner, trunkBody, dir, profile)
         : null;
     const endTrunkBody = endPlan || endRealign ? null : endBody;
-    const endTrunkOwner = endTrunkBody ? useScene.getState().nodes[endTrunkBody.nodeId] : null;
+    const endTrunkOwner = endTrunkBody ? nodes[endTrunkBody.nodeId] : null;
     const endTeePlan = endTrunkBody && endTrunkOwner?.type === 'duct-segment'
         ? planTeeAtRunBody(endTrunkOwner, endTrunkBody, [-dir[0], -dir[1], -dir[2]], profile)
         : null;
-    let ductStart = startPlan?.collarPoint ?? teePlan?.branchCollar ?? startRealign?.collarPoint ?? start;
-    let ductEnd = endPlan?.collarPoint ?? endTeePlan?.branchCollar ?? endRealign?.collarPoint ?? end;
-    const remaining = Math.hypot(ductEnd[0] - ductStart[0], ductEnd[1] - ductStart[1], ductEnd[2] - ductStart[2]);
-    let plans = [startPlan, endPlan].filter((p) => p !== null);
-    let tee = teePlan;
+    const adapterFor = (port, corner, away) => {
+        if (!port)
+            return null;
+        const source = inheritProfile(port, nodes);
+        if (!source)
+            return null;
+        const axis = new Vector3(...away);
+        if (!corner && axis.dot(new Vector3(...port.direction).normalize()) < 0.9999)
+            return null;
+        const owner = nodes[port.nodeId];
+        const roll = continuityRollFrom(port, axis, nodes) ?? 0;
+        const width = rectSectionAxes(axis, roll).width;
+        if (owner?.type === 'duct-fitting' && !corner) {
+            width.set(0, 0, 1).applyEuler(new Euler(...owner.rotation));
+        }
+        return planDuctAdapter({ ...port, position: corner?.collarPoint ?? port.position, direction: away }, source, profile, width);
+    };
+    const startAdapter = adapterFor(startPort, startPlan, dir);
+    const endAdapter = adapterFor(endPort, endPlan, [-dir[0], -dir[1], -dir[2]]);
+    for (const [port, adapter] of [
+        [startPort, startAdapter],
+        [endPort, endAdapter],
+    ]) {
+        const source = port ? inheritProfile(port, nodes) : null;
+        if (source && !ductProfilesMatch(source, profile) && !adapter) {
+            return {
+                ...invalidPlan(),
+                validationMessage: 'Align the connection or draw a 15–90° bend to fit the profile change.',
+            };
+        }
+    }
+    const ductStart = startAdapter?.collarPoint ??
+        startPlan?.collarPoint ??
+        teePlan?.branchCollar ??
+        startRealign?.collarPoint ??
+        start;
+    let ductEnd = endAdapter?.collarPoint ??
+        endPlan?.collarPoint ??
+        endTeePlan?.branchCollar ??
+        endRealign?.collarPoint ??
+        end;
+    const plans = [startPlan, endPlan].filter((p) => p !== null);
+    const tee = teePlan;
     let endTee = endTeePlan && endTrunkBody?.nodeId === trunkBody?.nodeId ? null : endTeePlan;
     if (!endTee && endTeePlan)
         ductEnd = endRealign?.collarPoint ?? end;
-    let realigns = [startRealign, endRealign].filter((p) => p !== null);
-    const crossHit = findRunBodyCrossingXZ(start, end, BODY_SNAP_RADIUS_M);
-    const crossOwner = crossHit ? useScene.getState().nodes[crossHit.nodeId] : null;
+    const realigns = [startRealign, endRealign].filter((p) => p !== null);
+    const crossHit = surface
+        ? findRunBodyCrossingSurface(start, end, BODY_SNAP_RADIUS_M, surface)
+        : null;
+    const crossOwner = crossHit ? nodes[crossHit.nodeId] : null;
     const crossTappedElsewhere = crossHit?.nodeId === trunkBody?.nodeId || crossHit?.nodeId === endTrunkBody?.nodeId;
-    let cross = crossHit && !crossTappedElsewhere && crossOwner?.type === 'duct-segment'
+    const cross = crossHit && !crossTappedElsewhere && crossOwner?.type === 'duct-segment'
         ? planCrossAtRunBody(crossOwner, crossHit, dir, profile)
         : null;
-    if (remaining <= 0.08) {
-        plans = [];
-        tee = null;
-        endTee = null;
-        realigns = [];
-        cross = null;
-        ductStart = start;
-        ductEnd = end;
-    }
+    if (!hasFittingClearance(ductStart, ductEnd, dir, 0.08) ||
+        (trunkBody && !teePlan) ||
+        (endTrunkBody && !endTeePlan) ||
+        (crossHit && !crossTappedElsewhere && !cross))
+        return invalidPlan();
+    if (cross &&
+        (!hasFittingClearance(ductStart, cross.branchCollarNear, dir, 0.08) ||
+            !hasFittingClearance(cross.branchCollarFar, ductEnd, dir, 0.08)))
+        return invalidPlan();
     // Rect / oval continuity: roll the new run's cross-section so its
     // profile stays continuous with whatever either end joined.
     let roll = 0;
     if (profile.shape !== 'round') {
         const newDir = new Vector3(...dir);
-        roll = continuityRollForRun(startPort, endPort, newDir);
+        roll = continuityRollForRun(startPort, endPort, newDir, nodes);
     }
     const defaults = ductSegmentDefinition.defaults();
-    const toolDefaults = useEditor.getState().toolDefaults['duct-segment'] ?? {};
     const makeDuct = (from, to) => DuctSegmentNode.parse({
         ...defaults,
         ...toolDefaults,
+        autoHangers,
+        hangerStyle,
         name: profile.shape === 'rect' ? 'Trunk' : 'Duct run',
         path: [from, to],
         shape: profile.shape,
@@ -333,6 +349,7 @@ function planDuctDraw(start, end, startPort, startBody, endPort, endBody, profil
         : [makeDuct(ductStart, ductEnd)];
     const fittings = [
         ...plans.map((p) => p.fitting),
+        ...[startAdapter, endAdapter].flatMap((p) => (p ? [p.fitting] : [])),
         ...(tee ? [tee.fitting] : []),
         ...(endTee ? [endTee.fitting] : []),
         ...(cross ? [cross.fitting] : []),
@@ -349,587 +366,197 @@ function planDuctDraw(start, end, startPort, startBody, endPort, endBody, profil
         ...(cross ? [cross.trunkUpdate] : []),
         ...realigns.map((p) => p.update),
     ];
-    return { fittings, ducts, tails, updates };
-}
-function ductEndPort(duct, id) {
-    if (duct.path.length < 2)
-        return null;
-    const index = id === 'start' ? 0 : duct.path.length - 1;
-    const neighborIndex = id === '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 len = Math.hypot(dx, dy, dz);
-    const direction = len < 1e-9 ? [1, 0, 0] : [dx / len, dy / len, dz / len];
-    return {
-        id,
-        nodeId: duct.id,
-        position,
-        direction,
-        diameter: ductPortDiameterIn(duct),
-        system: duct.system,
-    };
+    const deleteIds = Array.from(new Set([
+        ...findMatedRunEndCapIds(startPort, nodes, 'duct-fitting'),
+        ...findMatedRunEndCapIds(endPort, nodes, 'duct-fitting'),
+    ]));
+    const firstDuct = ducts[0];
+    const nextDuct = ducts.at(-1);
+    const startEndCap = !startPort && !startBody && firstDuct ? createDuctRunEndCap(firstDuct, 'start') : null;
+    const nextEndCap = !endPort && !endBody && nextDuct ? createDuctRunEndCap(nextDuct) : null;
+    if (startEndCap)
+        fittings.push(startEndCap);
+    if (nextEndCap)
+        fittings.push(nextEndCap);
+    return { validationMessage: null, fittings, ducts, tails, updates, delete: deleteIds };
 }
 const DuctSegmentTool = () => {
-    const activeLevelId = useViewer((s) => s.selection.levelId);
-    const unit = useViewer((s) => s.unit);
+    const { activeLevelId, sceneApi, unit } = useRegistryToolContext();
     const cursorRef = useRef(null);
-    // Cross-section profile for the next committed segment. Q toggles
-    // round/rect, [ / ] steps the round diameter, and snapping the start
-    // onto an existing run / fitting INHERITS that node's profile — so
-    // continuing a 14×8 trunk keeps drawing 14×8, and branching off a
-    // round collar keeps its diameter. Seeded from `toolDefaults`.
+    const continuationSeedRef = useRef(currentDuctContinuationSeed());
+    const continuationSeed = continuationSeedRef.current;
+    const hangerDefaults = useEditor((state) => state.toolDefaults['duct-segment']);
+    const initialAutoHangersRef = useRef(Boolean(hangerDefaults?.autoHangers ?? continuationSeed?.duct.autoHangers ?? false));
+    const autoHangers = useRunHangerMode((state) => state.enabled['duct-segment']);
+    const hangerStyle = (hangerDefaults?.hangerStyle ?? continuationSeed?.duct.hangerStyle) === 'double'
+        ? 'double'
+        : 'single';
+    const hangerStyleRef = useRef(hangerStyle);
+    hangerStyleRef.current = hangerStyle;
+    const autoHangersRef = useRef(autoHangers);
+    autoHangersRef.current = autoHangers;
+    const pendingPromotionRef = useRef(continuationSeed?.promotedFitting ?? null);
     const [profile, setProfile] = useState(() => {
         const defaults = ductSegmentDefinition.defaults();
         const seeded = useEditor.getState().toolDefaults['duct-segment'];
         return {
-            shape: seeded?.shape ?? defaults.shape,
-            diameter: seeded?.diameter ?? defaults.diameter,
-            width: seeded?.width ?? defaults.width,
-            height: seeded?.height ?? defaults.height,
+            shape: continuationSeed?.duct.shape ?? seeded?.shape ?? defaults.shape,
+            diameter: continuationSeed?.duct.diameter ?? seeded?.diameter ?? defaults.diameter,
+            width: continuationSeed?.duct.width ?? seeded?.width ?? defaults.width,
+            height: continuationSeed?.duct.height ?? seeded?.height ?? defaults.height,
         };
     });
-    const [draftPoints, setDraftPoints] = useState([]);
-    const [cursorPos, setCursorPos] = useState(null);
-    // Ceiling mode (toggle with C): the first point lands at the level's
-    // ceiling height (duct top hugging the ceiling) instead of the floor.
-    const [ceilingMode, setCeilingMode] = useState(false);
-    // The shared coordinate when the cursor is within snap range of an existing
-    // duct (null = free placement). Drives the green cursor highlight so the
-    // user sees the next click will join an existing run, not freeform-place.
-    const [snapTarget, setSnapTarget] = useState(null);
-    // In ceiling mode, the ceiling the cursor is currently under — rendered as
-    // a translucent overlay so the duct reads as hung against a real surface
-    // rather than a dot floating in space. Null when off-ceiling.
-    const [hoverCeiling, setHoverCeiling] = useState(null);
-    // True while Alt is held with a last point on the draft — drives the
-    // vertical-cylinder ghost and the cursor HUD label.
-    const [altActive, setAltActive] = useState(false);
-    // What the in-flight cursor end currently snaps onto (port end, or a
-    // run body for a tee / cross tap). Drives the auto-fitting GHOST so the
-    // user sees the elbow / tee / cross the next click will mint.
-    const [endSnap, setEndSnap] = useState({
-        port: null,
-        body: null,
-    });
-    // Mirror into refs so emitter callbacks (closing over the first render's
-    // setState) read the latest values without re-subscribing.
-    const draftRef = useRef(draftPoints);
-    draftRef.current = draftPoints;
-    const cursorPosRef = useRef(cursorPos);
-    cursorPosRef.current = cursorPos;
     const profileRef = useRef(profile);
     profileRef.current = profile;
-    const ceilingModeRef = useRef(ceilingMode);
-    ceilingModeRef.current = ceilingMode;
-    // Port the anchored START point snapped onto (null = free placement).
-    // Read at commit so a turn off an existing run mints an elbow there.
-    const startPortRef = useRef(null);
-    // Centerline hit the anchored START point snapped onto (null = none).
-    // Read at commit so a branch off a trunk's side mints a tee there.
-    const startBodyRef = useRef(null);
-    // Anchor captured when Alt is pressed: screen Y at that moment and the
-    // base elevation (= last point's Y). Cleared on Alt release.
-    const altAnchorRef = useRef(null);
-    // Latest mouse clientY from grid:move; used so the Alt anchor knows where
-    // the cursor was at key-press time.
-    const lastClientYRef = useRef(null);
-    const ghostFittings = useMemo(() => {
-        const last = draftPoints.at(-1);
-        if (!(activeLevelId && last && cursorPos) || altActive)
-            return [];
-        const fittings = planDuctDraw(last, cursorPos, startPortRef.current, startBodyRef.current, endSnap.port, endSnap.body, profile)?.fittings ?? [];
-        return fittings.map((fitting, index) => ({
-            ...fitting,
-            id: `duct-fitting_live-draft-${index}`,
-            parentId: activeLevelId,
-        }));
-    }, [activeLevelId, altActive, cursorPos, draftPoints, endSnap, profile]);
     useEffect(() => {
-        usePathDraftPreview
-            .getState()
-            .setDraft('duct-segment', draftPoints, cursorPos, profile, ghostFittings);
-    }, [cursorPos, draftPoints, ghostFittings, profile]);
-    useEffect(() => () => usePathDraftPreview.getState().clear('duct-segment'), []);
-    useEffect(() => {
-        if (!activeLevelId)
-            return;
-        // Continuous chain: first click anchors the start, each following
-        // click commits one two-point duct and uses that duct's far end as
-        // the next anchor. No selection switch or finish gesture.
-        //
-        // All the auto-fitting decisions (elbow / tee / cross) live in the
-        // shared `planDuctDraw` so the live ghost previews exactly what this
-        // commit applies.
-        const commitSegment = (start, end, endPort = null, endBody = null) => {
-            const plan = planDuctDraw(start, end, startPortRef.current, startBodyRef.current, endPort, endBody, profileRef.current);
-            if (!plan)
+        const mode = useRunHangerMode.getState();
+        mode.setEnabled('duct-segment', initialAutoHangersRef.current);
+        return () => mode.setEnabled('duct-segment', false);
+    }, []);
+    const run = useDistributionRunTool({
+        active: !!activeLevelId,
+        levelId: activeLevelId,
+        toolName: 'duct-segment',
+        initialStart: continuationSeed
+            ? [...(continuationSeed.port?.position ?? continuationSeed.body?.point ?? [0, 0, 0])]
+            : null,
+        initialConnection: continuationSeed
+            ? { port: continuationSeed.port, body: continuationSeed.body }
+            : null,
+        getPorts: () => getConnectionPorts(activeLevelId, sceneApi.nodes()),
+        findBody: (point) => findNearestRunBody3D(point, BODY_SNAP_RADIUS_M, { levelId: activeLevelId ?? undefined }),
+        surfaceClearance: (surface) => surface
+            ? runSectionHalfSizeM(profileRef.current.shape === 'round'
+                ? profileRef.current.diameter
+                : profileRef.current.height)
+            : 0,
+        minimumSegmentLength: 0.08,
+        inheritFromConnection: ({ port }) => {
+            if (!port)
                 return;
-            // One atomic change: trim / split the joined runs, create the
-            // fittings + the new duct. Single undo step.
-            useScene.getState().applyNodeChanges({
+            const inherited = inheritProfile(port, sceneApi.nodes());
+            if (inherited)
+                setProfile(inherited);
+        },
+        commit: ({ start, end, startConnection, endConnection, surfaceTarget }) => {
+            if (!activeLevelId)
+                return null;
+            const promotedFitting = pendingPromotionRef.current;
+            const plan = planDuctDraw(start, end, promotedFitting ? null : startConnection.port, startConnection.body, endConnection.port, endConnection.body, profileRef.current, sceneApi.nodes(), surfaceTarget, autoHangersRef.current, hangerDefaults, hangerStyleRef.current);
+            if (!plan || plan.validationMessage)
+                return null;
+            const attachDuct = (node) => {
+                const wallAttachment = surfaceTarget?.kind === 'wall'
+                    ? createRunWallAttachment(surfaceTarget.hostId, surfaceTarget.side, node.path[0], node.path.at(-1), surfaceTarget, profileRef.current.shape === 'round'
+                        ? runSectionHalfSizeM(profileRef.current.diameter)
+                        : runSectionHalfSizeM(profileRef.current.height))
+                    : undefined;
+                return { ...node, wallAttachment };
+            };
+            const ducts = plan.ducts.map(attachDuct);
+            const tails = plan.tails;
+            if (!sceneApi.applyChanges)
+                throw new Error('Registry SceneApi must support atomic changes');
+            sceneApi.applyChanges({
                 create: [
                     ...plan.fittings.map((node) => ({ node, parentId: activeLevelId })),
-                    ...plan.tails.map((node) => ({ node, parentId: activeLevelId })),
-                    ...plan.ducts.map((node) => ({ node, parentId: activeLevelId })),
+                    ...tails.map((node) => ({ node, parentId: activeLevelId })),
+                    ...ducts.map((node) => ({ node, parentId: activeLevelId })),
                 ],
-                update: plan.updates,
+                update: [
+                    ...(promotedFitting
+                        ? [
+                            {
+                                id: promotedFitting.id,
+                                data: {
+                                    name: promotedFitting.name,
+                                    fittingType: promotedFitting.fittingType,
+                                    rotation: promotedFitting.rotation,
+                                    branchAngle: promotedFitting.branchAngle,
+                                    shape2: promotedFitting.shape2,
+                                    width2: promotedFitting.width2,
+                                    height2: promotedFitting.height2,
+                                    diameter2: promotedFitting.diameter2,
+                                },
+                            },
+                        ]
+                        : []),
+                    ...plan.updates,
+                ],
+                delete: plan.delete,
             });
+            pendingPromotionRef.current = null;
             const nextDuct = plan.ducts.at(-1);
             const nextStart = nextDuct ? nextDuct.path[nextDuct.path.length - 1] : end;
-            const nextPort = nextDuct ? ductEndPort(nextDuct, 'end') : endPort;
-            triggerSFX('sfx:item-place');
-            setDraftPoints([nextStart]);
-            setSnapTarget(null);
-            setEndSnap({ port: null, body: null });
-            startPortRef.current = nextPort;
-            startBodyRef.current = nextPort ? null : endBody;
-            altAnchorRef.current = null;
-            setAltActive(false);
-        };
-        // Y for a point at level-local `[x, z]`. Floor (0) when ceiling mode is
-        // off. In ceiling mode, query the ceiling actually covering that point
-        // and hang the duct just below it (centerline = ceiling underside −
-        // half the duct's vertical dimension) so its top hugs the ceiling. Each
-        // point follows its own ceiling, so a run stepping into a room with a
-        // different ceiling height tracks that change. Points not under any
-        // ceiling fall back to the floor.
-        const resolveCeilingY = (x, z) => {
-            if (!ceilingModeRef.current)
-                return 0;
-            const ceiling = getCeilingHeightAt(activeLevelId, useScene.getState().nodes, x, z);
-            if (ceiling === null)
-                return 0;
-            const p = profileRef.current;
-            const verticalIn = p.shape === 'round' ? p.diameter : p.height;
-            return Math.max(0, ceiling - (verticalIn * 0.0254) / 2);
-        };
-        const resolveSnappedPoint = (event) => {
-            // Port / body mating is the run's primary affordance; it stays on in
-            // every snapping mode except `off` (the raw-cursor bypass).
-            const snapEnabled = isGridSnapActive() || isMagneticSnapActive() || isAngleSnapActive();
-            const last = draftRef.current.at(-1);
-            // First point of the run: grid-snapped placement. Y follows the
-            // ceiling under the cursor in ceiling mode (floor otherwise).
-            // Endpoint snap can still join an existing run.
-            if (!last) {
-                const baseY = resolveCeilingY(event.localPosition[0], event.localPosition[2]);
-                const raw = [
-                    event.localPosition[0],
-                    baseY,
-                    event.localPosition[2],
-                ];
-                const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
-                if (event.nativeEvent?.altKey !== true && snapEnabled) {
-                    const target = findNearbyPort(raw);
-                    if (target)
-                        return {
-                            point: portPoint(target),
-                            snapped: portPoint(target),
-                            port: target,
-                            body: null,
-                        };
-                    // No open end nearby — try the side of a run (tee tap). Probe
-                    // with a grid-snapped cursor so the tap steps along the duct
-                    // like every other placement; `off` mode (step 0) rides smoothly.
-                    const probe = [snap(raw[0], step), baseY, snap(raw[2], step)];
-                    const body = findNearestRunBodyXZ(probe, BODY_SNAP_RADIUS_M);
-                    if (body)
-                        return { point: body.point, snapped: body.point, port: null, body };
-                }
-                const sx = snap(raw[0], step);
-                const sz = snap(raw[2], step);
-                return {
-                    point: [sx, resolveCeilingY(sx, sz), sz],
-                    snapped: null,
-                    port: null,
-                    body: null,
-                };
-            }
-            // Subsequent points: angle-locked to 45° from `last` in `angles` mode.
-            // Y inherits `last[1]` for the angle/probe math; the free placement below
-            // re-resolves it from the ceiling under the point in ceiling mode, so a run
-            // stepping into a room with a different ceiling height tracks that change.
-            // Depth changes otherwise come from Alt-vertical risers.
-            const rawXZ = [
-                event.localPosition[0],
-                last[1],
-                event.localPosition[2],
-            ];
-            // The 45° lock is now the `angles` snapping mode (Shift cycles to it),
-            // not a held key.
-            const angled = isAngleSnapActive() ? projectToAngleLock(last, rawXZ) : rawXZ;
-            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
-            // Port snap (Alt bypass) — checked against the RAW cursor, not the
-            // angle-locked projection, so a port slightly off the 45° ray can
-            // still capture the cursor. Joining beats the lock.
-            if (event.nativeEvent?.altKey !== true && snapEnabled) {
-                const target = findNearbyPort(rawXZ);
-                if (target)
-                    return { point: portPoint(target), snapped: portPoint(target), port: target, body: null };
-                // No open end nearby — landing on the side of a run taps a tee
-                // there (mirror of the first-point tee tap). Probe with a
-                // grid-snapped cursor so the tap steps along the duct instead of
-                // sliding smoothly (Shift above frees it). Checked against the
-                // cursor, not the 45° projection, so a slightly-off trunk captures.
-                const probe = [
-                    snap(rawXZ[0], step),
-                    rawXZ[1],
-                    snap(rawXZ[2], step),
-                ];
-                const body = findNearestRunBodyXZ(probe, BODY_SNAP_RADIUS_M);
-                if (body)
-                    return { point: body.point, snapped: body.point, port: null, body };
-            }
-            const fx = snap(angled[0], step);
-            const fz = snap(angled[2], step);
-            const fy = ceilingModeRef.current ? resolveCeilingY(fx, fz) : angled[1];
+            const nextPort = nextDuct ? ductEndpointPort(nextDuct, 'end') : endConnection.port;
             return {
-                point: [fx, fy, fz],
-                snapped: null,
-                port: null,
-                body: null,
+                nextStart,
+                nextConnection: {
+                    port: nextPort,
+                    body: nextPort ? null : endConnection.body,
+                },
             };
-        };
-        /**
-         * Compute the Alt-mode cursor position: XZ locked to the last point,
-         * Y driven by how far the mouse has moved vertically on screen since
-         * Alt was pressed. Returns null if there's no anchor (Alt not active).
-         */
-        const resolveAltVerticalPoint = (clientY) => {
-            const anchor = altAnchorRef.current;
-            const last = draftRef.current.at(-1);
-            if (!anchor || !last)
-                return null;
-            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
-            // Screen +Y points down, so subtract to map "drag up = raise Y".
-            const dy = (anchor.clientY - clientY) / ALT_PIXELS_PER_METER;
-            const snappedDy = snap(dy, step);
-            const y = Math.min(ALT_Y_MAX_M, Math.max(ALT_Y_MIN_M, anchor.baseY + snappedDy));
-            return [last[0], y, last[2]];
-        };
-        // Resolve the cursor point (port / body / grid / angle snap) and then
-        // layer Figma-style alignment on top so a run lines up with other runs,
-        // fittings, and items as it's drawn. A free point (first vertex, or no
-        // angle lock) snaps; an angle-locked continuation shows the guide passively
-        // without leaving its 45° ray. Alignment follows the `lines` mode; a
-        // port / body snap or Alt-vertical bypasses it.
-        const resolveAlignedPoint = (event) => {
-            const r = resolveSnappedPoint(event);
-            const hasStart = draftRef.current.length > 0;
-            const alt = event.nativeEvent?.altKey === true;
-            const point = alignDrawPoint(r.point, {
-                applySnap: isMagneticSnapActive() && (!hasStart || !isAngleSnapActive()),
-                bypass: alt || r.snapped !== null,
-            });
-            return { ...r, point };
-        };
-        // The ceiling the cursor is under (ceiling mode only) — drives the
-        // translucent surface overlay so the in-flight point reads as hung
-        // against a real ceiling. Cleared when off-ceiling or out of mode.
-        const updateHoverCeiling = (x, z) => {
-            if (!ceilingModeRef.current) {
-                setHoverCeiling(null);
-                return;
-            }
-            setHoverCeiling(getCeilingAt(activeLevelId, useScene.getState().nodes, x, z));
-        };
-        const onMove = (event) => {
-            const clientY = event.nativeEvent?.clientY;
-            if (typeof clientY === 'number')
-                lastClientYRef.current = clientY;
-            // Alt vertical mode wins over the XZ logic.
-            if (altAnchorRef.current && typeof clientY === 'number') {
-                const point = resolveAltVerticalPoint(clientY);
-                if (point) {
-                    clearDrawAlignment();
-                    setCursorPos(point);
-                    setSnapTarget(null);
-                    setEndSnap({ port: null, body: null });
-                    updateHoverCeiling(point[0], point[2]);
-                    return;
+        },
+        onShortcut: (event) => {
+            if (event.key === '[' || event.key === ']') {
+                event.preventDefault();
+                const next = stepNominalRunSize(DUCT_DIAMETERS_IN, profileRef.current.diameter, event.key === ']' ? 1 : -1);
+                if (next !== profileRef.current.diameter) {
+                    setProfile((current) => ({ ...current, diameter: next }));
+                    triggerSFX('sfx:grid-snap');
                 }
             }
-            const { point, snapped, port, body } = resolveAlignedPoint(event);
-            setCursorPos(point);
-            setSnapTarget(snapped);
-            setEndSnap({ port, body: port ? null : body });
-            updateHoverCeiling(point[0], point[2]);
-        };
-        const onClick = (event) => {
-            const start = draftRef.current.at(-1);
-            // Vertical mode with a start anchored: the click commits the riser
-            // segment right there. Never falls through to the XZ logic — a
-            // no-op Alt click (height unchanged) must not place anything.
-            if (altAnchorRef.current && start) {
-                const clientY = event.nativeEvent?.clientY ?? lastClientYRef.current;
-                if (typeof clientY === 'number') {
-                    const point = resolveAltVerticalPoint(clientY);
-                    if (point && Math.abs(point[1] - start[1]) >= 1e-4) {
-                        commitSegment(start, point);
-                    }
-                }
-                return;
-            }
-            const { point, port, body } = resolveAlignedPoint(event);
-            if (!start) {
-                // First click: anchor the segment start, remembering the port or
-                // run body it snapped to so the commit can mint an elbow / tee.
-                // Joining a port INHERITS the source's cross-section — continuing
-                // a rect trunk keeps drawing rect at its W×H, a round collar its
-                // diameter. Body taps (tee branches) keep the tool's own profile.
-                triggerSFX('sfx:grid-snap');
-                startPortRef.current = port;
-                startBodyRef.current = port ? null : body;
-                if (port) {
-                    const inherited = inheritProfile(port);
-                    if (inherited)
-                        setProfile(inherited);
-                }
-                setDraftPoints([point]);
-                return;
-            }
-            // Second click: commit the segment and re-arm. A body hit on the end
-            // (no end port) taps a tee into that run's side.
-            commitSegment(start, point, port, port ? null : body);
-        };
-        const enterAltMode = () => {
-            const last = draftRef.current.at(-1);
-            if (!last || lastClientYRef.current === null)
-                return;
-            if (altAnchorRef.current)
-                return;
-            altAnchorRef.current = { clientY: lastClientYRef.current, baseY: last[1] };
-            setAltActive(true);
-        };
-        const exitAltMode = () => {
-            if (!altAnchorRef.current)
-                return;
-            altAnchorRef.current = null;
-            setAltActive(false);
-        };
-        const stepDiameter = (step) => {
-            const sizes = DUCT_DIAMETERS_IN;
-            const current = profileRef.current.diameter;
-            // Nearest catalogue index, then step — handles seeded off-catalogue
-            // values (e.g. a preset's 7.5") gracefully.
-            let nearest = 0;
-            for (let i = 1; i < sizes.length; i++) {
-                if (Math.abs(sizes[i] - current) < Math.abs(sizes[nearest] - current))
-                    nearest = i;
-            }
-            const next = sizes[Math.min(sizes.length - 1, Math.max(0, nearest + step))];
-            if (next === current)
-                return;
-            setProfile((p) => ({ ...p, diameter: next }));
-            triggerSFX('sfx:grid-snap');
-        };
-        const onKeyDown = (e) => {
-            const tag = e.target?.tagName;
-            if (tag === 'INPUT' || tag === 'TEXTAREA')
-                return;
-            if (e.key === 'Alt') {
-                e.preventDefault();
-                enterAltMode();
-            }
-            else if (e.key === '[') {
-                e.preventDefault();
-                stepDiameter(-1);
-            }
-            else if (e.key === ']') {
-                e.preventDefault();
-                stepDiameter(1);
-            }
-            else if (e.key === 'q' || e.key === 'Q') {
-                e.preventDefault();
-                setProfile((p) => ({ ...p, shape: p.shape === 'round' ? 'rect' : 'round' }));
+            else if (event.key === 'q' || event.key === 'Q') {
+                event.preventDefault();
+                setProfile((current) => ({
+                    ...current,
+                    shape: current.shape === 'round' ? 'rect' : current.shape === 'rect' ? 'oval' : 'round',
+                }));
                 triggerSFX('sfx:grid-snap');
             }
-            else if (e.key === 'c' || e.key === 'C') {
-                // Toggle ceiling mode: points hang from the ceiling above them
-                // (duct top hugging the ceiling) instead of sitting on the floor.
-                // Only flip while unanchored — already-placed points keep their Y,
-                // so a mid-run toggle would split a run across two height regimes.
-                if (draftRef.current.length > 0)
-                    return;
-                e.preventDefault();
-                setCeilingMode((m) => !m);
-                setHoverCeiling(null);
+            else if (event.key === 'h' || event.key === 'H') {
+                event.preventDefault();
+                useRunHangerMode.getState().toggle('duct-segment');
                 triggerSFX('sfx:grid-snap');
             }
-        };
-        const onKeyUp = (e) => {
-            if (e.key === 'Alt') {
-                e.preventDefault();
-                exitAltMode();
-            }
-        };
-        const onCancel = () => {
-            clearDrawAlignment();
-            if (draftRef.current.length === 0)
-                return;
-            markToolCancelConsumed();
-            setDraftPoints([]);
-            setCursorPos(null);
-            setSnapTarget(null);
-            setEndSnap({ port: null, body: null });
-            setHoverCeiling(null);
-            startPortRef.current = null;
-            startBodyRef.current = null;
-        };
-        emitter.on('grid:move', onMove);
-        emitter.on('grid:click', onClick);
-        emitter.on('tool:cancel', onCancel);
-        window.addEventListener('keydown', onKeyDown);
-        window.addEventListener('keyup', onKeyUp);
-        return () => {
-            emitter.off('grid:move', onMove);
-            emitter.off('grid:click', onClick);
-            emitter.off('tool:cancel', onCancel);
-            window.removeEventListener('keydown', onKeyDown);
-            window.removeEventListener('keyup', onKeyUp);
-            altAnchorRef.current = null;
-            clearDrawAlignment();
-        };
-    }, [activeLevelId]);
+        },
+    });
+    const previewPlan = useMemo(() => {
+        if (!(activeLevelId && run.start && run.cursor))
+            return null;
+        return planDuctDraw(run.start, run.cursor, pendingPromotionRef.current ? null : run.startConnection.port, run.startConnection.body, run.endConnection.port, run.endConnection.body, profile, sceneApi.nodes(), run.surfaceTarget, autoHangers, hangerDefaults, hangerStyle);
+    }, [
+        activeLevelId,
+        autoHangers,
+        hangerDefaults,
+        hangerStyle,
+        profile,
+        run.start,
+        run.cursor,
+        run.startConnection,
+        run.endConnection,
+        run.surfaceTarget,
+        sceneApi,
+    ]);
+    const ghostFittings = useMemo(() => previewPlan?.fittings ?? [], [previewPlan]);
+    useEffect(() => {
+        usePathDraftPreview
+            .getState()
+            .setDraft('duct-segment', run.start ? [run.start] : [], run.cursor, { ...profile, autoHangers, hangerStyle }, ghostFittings);
+    }, [autoHangers, hangerStyle, ghostFittings, profile, run.cursor, run.start]);
+    useEffect(() => () => usePathDraftPreview.getState().clear('duct-segment'), []);
+    useEffect(() => () => useEditor.getState().setToolDefaults('duct-segment', null), []);
     if (!activeLevelId)
         return null;
-    const previewSegments = [];
-    for (let i = 0; i < draftPoints.length - 1; i++) {
-        previewSegments.push({ a: draftPoints[i], b: draftPoints[i + 1] });
-    }
-    const last = draftPoints.at(-1);
-    if (last && cursorPos) {
-        previewSegments.push({ a: last, b: cursorPos });
-    }
-    // Wall-style dimension pill above the cursor: absolute world coords before
-    // the first point, signed per-axis deltas from the last placed point while
-    // a segment is in flight. The actively-driven axis is emphasised — Y in
-    // Alt-vertical mode, otherwise whichever horizontal axis dominates. A
-    // trailing Ø readout shows the diameter the next click commits ([ / ]).
-    const pillParts = cursorPos
-        ? [
-            ...['x', 'y', 'z'].map((axis, i) => ({
-                key: axis,
-                prefix: axis.toUpperCase(),
-                value: last ? cursorPos[i] - last[i] : cursorPos[i],
-                signed: !!last,
-            })),
-            ...(profile.shape === 'round'
-                ? [{ key: 'diameter', prefix: 'Ø', value: profile.diameter * 0.0254, signed: false }]
-                : [
-                    { key: 'trunk-w', prefix: 'W', value: profile.width * 0.0254, signed: false },
-                    { key: 'trunk-h', prefix: 'H', value: profile.height * 0.0254, signed: false },
-                ]),
-        ]
-        : null;
-    const pillPrimary = last && cursorPos
-        ? altActive
-            ? 'y'
-            : Math.abs(cursorPos[0] - last[0]) >= Math.abs(cursorPos[2] - last[2])
-                ? 'x'
-                : 'z'
-        : undefined;
-    // When the in-flight point hangs above the floor (ceiling mode, or an
-    // Alt riser), the cursor marker itself rides AT the point (where the
-    // mouse is aiming and the next click commits), and a plumb line drops
-    // straight down to a faint ground ring on the floor below — so the plan
-    // position stays legible from any angle. A floor-level point keeps the
-    // standard fixed-height cursor look.
-    const cursorElevation = cursorPos ? cursorPos[1] : 0;
-    const isElevated = cursorElevation > 0.001;
-    const cursorGround = cursorPos
-        ? [cursorPos[0], 0, cursorPos[2]]
-        : null;
-    return (_jsxs(LevelOffsetGroup, { children: [ceilingMode && hoverCeiling && _jsx(CeilingHighlight, { ceiling: hoverCeiling }), cursorPos && cursorGround && (_jsxs(_Fragment, { children: [isElevated ? (_jsx(CursorSphere, { color: snapTarget ? SNAP_CURSOR_COLOR : undefined, dotAtTip: true, height: cursorElevation, position: cursorGround, ref: cursorRef })) : (_jsx(CursorSphere, { color: snapTarget ? SNAP_CURSOR_COLOR : undefined, position: cursorPos, ref: cursorRef })), pillParts && (_jsx("group", { position: cursorPos, children: _jsx(Html, { center: true, position: [0, 1.45, 0], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex flex-col items-center gap-2", children: [ceilingMode && !last && (_jsx("div", { className: "whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-3 py-0.5 text-[10px] text-muted-foreground shadow-sm backdrop-blur", children: "Ceiling \u00B7 C to toggle" })), _jsx(DimensionPill, { parts: pillParts, primary: pillPrimary, unit: unit })] }) }) }))] })), draftPoints.map((p, i) => (_jsxs("mesh", { layers: EDITOR_LAYER, position: p, children: [_jsx("sphereGeometry", { args: [0.07, 16, 12] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false })] }, `pt-${i}`))), previewSegments.map((seg, i) => (_jsx(PreviewSegment, { a: seg.a, b: seg.b, endPort: endSnap.port, profile: profile, startPort: startPortRef.current }, `seg-${i}`))), ghostFittings.map((fitting) => (_jsx(FittingGhost, { fitting: fitting }, fitting.id)))] }));
+    const extraParts = profile.shape === 'round'
+        ? [{ key: 'diameter', prefix: 'Ø', value: profile.diameter * 0.0254 }]
+        : [
+            { key: 'trunk-w', prefix: 'W', value: profile.width * 0.0254 },
+            { key: 'trunk-h', prefix: 'H', value: profile.height * 0.0254 },
+        ];
+    return (_jsxs(LevelOffsetGroup, { children: [_jsx(ConnectionFeedback, { point: run.cursor, target: run.endConnection.port, levelId: activeLevelId, profile: {
+                    ...profile,
+                    system: String(hangerDefaults?.system ?? ductSegmentDefinition.defaults().system),
+                } }), _jsx(DistributionRunCursor, { altActive: run.altActive, cursor: run.cursor, cursorRef: cursorRef, directionMode: run.directionMode, extraParts: extraParts, lengthInput: run.lengthInput, onLengthInputChange: run.onLengthInputChange, onDirectionSelect: run.onDirectionSelect, validationMessage: previewPlan?.validationMessage ?? run.validationMessage, snapTarget: run.snapTarget, snapScreen: run.snapScreen, start: run.start, startDirection: run.startConnection.port?.direction ?? null, unit: unit }), run.start && (_jsxs("mesh", { layers: EDITOR_LAYER, position: run.start, children: [_jsx("sphereGeometry", { args: [0.07, 16, 12] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false })] })), previewPlan?.ducts.map((duct, index) => (_jsx(DuctSegmentGhost, { duct: duct }, index))), previewPlan?.ducts.map((duct, index) => (_jsx(RunHangerPreview, { run: duct, levelId: activeLevelId }, `hanger-${index}`))), ghostFittings.map((fitting) => (_jsx(FittingGhost, { fitting: fitting }, fitting.id)))] }));
 };
-/**
- * Build a horizontal `ShapeGeometry` for a ceiling polygon (with holes) in
- * level-local XZ, laid flat in the XZ plane. Mirrors the ceiling renderer /
- * move-tool convention (Z negated, then rotated onto the floor plane).
- */
-function buildCeilingShape(polygon, holes) {
-    if (polygon.length < 3)
-        return null;
-    const shape = new Shape();
-    const first = polygon[0];
-    shape.moveTo(first[0], -first[1]);
-    for (let i = 1; i < polygon.length; i++) {
-        const pt = polygon[i];
-        shape.lineTo(pt[0], -pt[1]);
-    }
-    shape.closePath();
-    for (const holePolygon of holes) {
-        if (holePolygon.length < 3)
-            continue;
-        const hole = new Path();
-        const hf = holePolygon[0];
-        hole.moveTo(hf[0], -hf[1]);
-        for (let i = 1; i < holePolygon.length; i++) {
-            const pt = holePolygon[i];
-            hole.lineTo(pt[0], -pt[1]);
-        }
-        hole.closePath();
-        shape.holes.push(hole);
-    }
-    const geometry = new ShapeGeometry(shape);
-    geometry.rotateX(-Math.PI / 2);
-    return geometry;
-}
-/**
- * Translucent overlay of the ceiling the cursor is under, drawn at the
- * ceiling's own height. Gives the in-flight duct point a real surface to
- * read against, so "hung against the ceiling" is visible from any angle
- * instead of being a dot floating in space.
- */
-function CeilingHighlight({ ceiling }) {
-    const geometry = useMemo(() => buildCeilingShape(ceiling.polygon, ceiling.holes), [ceiling.polygon, ceiling.holes]);
-    const outline = useMemo(() => {
-        if (ceiling.polygon.length < 2)
-            return null;
-        const pts = ceiling.polygon.map(([x, z]) => new Vector3(x, 0, z));
-        const f = ceiling.polygon[0];
-        pts.push(new Vector3(f[0], 0, f[1]));
-        return pts;
-    }, [ceiling.polygon]);
-    if (!geometry)
-        return null;
-    const y = resolveCeilingHeight(ceiling, useScene.getState().nodes);
-    return (_jsxs("group", { position: [0, y, 0], children: [_jsx("mesh", { geometry: geometry, layers: EDITOR_LAYER, renderOrder: 1, children: _jsx("meshBasicMaterial", { color: "#818cf8", depthWrite: false, opacity: 0.15, side: DoubleSide, transparent: true }) }), outline && (_jsxs("line", { children: [_jsx("bufferGeometry", { ref: (g) => {
-                            if (g)
-                                g.setFromPoints(outline);
-                        } }), _jsx("lineBasicMaterial", { color: "#818cf8", opacity: 0.6, transparent: true })] }))] }));
-}
-function PreviewSegment({ a, b, profile, startPort, endPort, }) {
-    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);
-    // Rect AND oval ghost as a box — close enough for a translucent guide.
-    if (profile.shape !== 'round') {
-        const w = profile.width * 0.0254;
-        const h = profile.height * 0.0254;
-        return (_jsxs("mesh", { layers: EDITOR_LAYER, position: mid.toArray(), ref: (m) => {
-                if (!m)
-                    return;
-                // Same basis AND roll as the commit will use, so the ghost
-                // shows the orientation that actually lands.
-                const roll = continuityRollForRun(startPort, endPort, dir);
-                const { width: x, height: z } = rectSectionAxes(dir, roll);
-                m.quaternion.setFromRotationMatrix(new Matrix4().makeBasis(x, dir, z));
-            }, children: [_jsx("boxGeometry", { args: [w, length, h] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: PREVIEW_OPACITY, transparent: true })] }));
-    }
-    const radius = (profile.diameter * 0.0254) / 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: "#818cf8", depthTest: false, opacity: PREVIEW_OPACITY, transparent: true })] }));
-}
 export default DuctSegmentTool;