@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/duct-segment/edit-operation.js

@@ -0,0 +1,283 @@
+import { DuctFittingNode, DuctSegmentNode, nodeRegistry, } from '@pascal-app/core';
+import { refuse } from '@pascal-app/core/agent-tools';
+import { queryNodes } from '@pascal-app/core/runtime';
+import { Vector3 } from 'three';
+import { fittingLegLength, getDuctFittingPorts } from '../duct-fitting/ports.js';
+import { planElbowAtPort, profileDiameterIn } from '../shared/auto-fitting.js';
+import { autoOffsetInvalidationUpdates } from '../shared/auto-offset-tag.js';
+import { transferRunEndCapOwnership } from '../shared/automatic-run-end-cap.js';
+import { ductProfilesMatch, planDuctAdapter } from '../shared/duct-adapter.js';
+import { rectSectionAxes, rollToContinueAcrossElbow } from './profile.js';
+function portsOf(node) {
+    const definition = nodeRegistry.get(node.type);
+    if (!definition?.ports)
+        return [];
+    return definition.ports(node).map((port) => ({ ...port, nodeId: node.id }));
+}
+const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+function mates(port, ports) {
+    return ports.filter((other) => other.nodeId !== port.nodeId &&
+        other.system === port.system &&
+        distance(port.position, other.position) < 0.005 &&
+        new Vector3(...port.direction).dot(new Vector3(...other.direction)) < -0.99);
+}
+function profileOf(node, port) {
+    if (node.type === 'duct-segment')
+        return node;
+    return {
+        shape: port.shape ?? 'round',
+        diameter: port.diameter,
+        width: port.width ?? port.diameter,
+        height: port.height ?? port.diameter,
+    };
+}
+function validPaths(before, changes) {
+    for (const entry of changes.update ?? []) {
+        const old = before[entry.id];
+        if (old?.type !== 'duct-segment' || !('path' in entry.data) || !entry.data.path)
+            continue;
+        const path = entry.data.path;
+        for (let i = 1; i < path.length; i++) {
+            const original = new Vector3(...old.path[i]).sub(new Vector3(...old.path[i - 1]));
+            const next = new Vector3(...path[i]).sub(new Vector3(...path[i - 1]));
+            if (next.length() < 0.08 || next.dot(original) <= 0)
+                refuse('duct_clearance', 'Not enough straight duct for the fittings. Use a longer run or a smaller size change.');
+        }
+    }
+}
+/** One plan is used by the inspector and agent hosts; neither writes a partial network. */
+export const editDuct = (before, input) => {
+    const duct = before[input.nodeId];
+    if (duct?.type !== 'duct-segment')
+        return refuse('duct_not_found', 'Select a duct run.');
+    if (!nodeRegistry.get('duct-segment')?.ports)
+        return refuse('node_capability_unavailable', 'Register duct node definitions before editing.');
+    const changes = { create: [], update: [] };
+    if (input.action === 'offset') {
+        if (queryNodes(before, { parentId: duct.id }).length > 0 ||
+            Object.keys(duct.hangerOverrides ?? {}).length)
+            return refuse('duct_offset_attachments', 'Remove custom hanger adjustments or hosted children before splitting this run.');
+        const { offset = 0, from = 0, to = 0 } = input;
+        if (![offset, from, to].every(Number.isFinite) ||
+            duct.path.length !== 2 ||
+            Math.abs(duct.path[0][1] - duct.path[1][1]) > 0.001)
+            return refuse('duct_offset_route', 'Choose a straight horizontal run for an obstacle offset.');
+        const start = new Vector3(...duct.path[0]);
+        const end = new Vector3(...duct.path[1]);
+        const axis = end.clone().sub(start).normalize();
+        const length = start.distanceTo(end);
+        const leg = fittingLegLength(profileDiameterIn(duct));
+        if (from < leg + 0.08 ||
+            to > length - leg - 0.08 ||
+            to - from < 2 * leg + 0.08 ||
+            Math.abs(offset) < 2 * leg + 0.08)
+            return refuse('duct_offset_clearance', `Allow ${(2 * leg + 0.08).toFixed(2)} m for the rise and offset span, and ${(leg + 0.08).toFixed(2)} m at each end.`);
+        const up = new Vector3(0, Math.sign(offset), 0);
+        const a = start.clone().addScaledVector(axis, from);
+        const b = a.clone().add(new Vector3(0, offset, 0));
+        const d = start.clone().addScaledVector(axis, to);
+        const c = d.clone().add(new Vector3(0, offset, 0));
+        const corners = [a, b, c, d];
+        const incoming = [axis, up, axis, up.clone().negate()];
+        const outgoing = [up, axis, up.clone().negate(), axis];
+        const elbows = corners.map((corner, i) => {
+            const plan = planElbowAtPort({
+                id: 'end',
+                nodeId: duct.id,
+                position: corner.toArray(),
+                direction: incoming[i].toArray(),
+                diameter: profileDiameterIn(duct),
+                system: duct.system,
+            }, outgoing[i].toArray(), duct);
+            if (!plan)
+                return refuse('duct_offset_angle', 'The requested bends cannot be formed on this route.');
+            return plan;
+        });
+        const paths = [
+            [start.toArray(), elbows[0].trimmedPortPoint],
+            [elbows[0].collarPoint, elbows[1].trimmedPortPoint],
+            [elbows[1].collarPoint, elbows[2].trimmedPortPoint],
+            [elbows[2].collarPoint, elbows[3].trimmedPortPoint],
+            [elbows[3].collarPoint, end.toArray()],
+        ];
+        // Rolled rectangular sections require a twist, which the elbow schema cannot express.
+        if (duct.shape !== 'round' && Math.abs(duct.roll) > 0.001)
+            return refuse('duct_offset_roll', 'Reset the section roll before adding an obstacle offset.');
+        changes.update.push({
+            id: duct.id,
+            data: { path: paths[0], wallAttachment: undefined, hangerOverrides: undefined },
+        });
+        const { id: _id, ...defaults } = duct;
+        for (const path of paths.slice(1))
+            changes.create.push({
+                node: DuctSegmentNode.parse({
+                    ...defaults,
+                    metadata: {},
+                    wallAttachment: undefined,
+                    hangerOverrides: undefined,
+                    path,
+                    roll: duct.shape === 'round'
+                        ? 0
+                        : rollToContinueAcrossElbow(axis, duct.roll, axis, new Vector3(...path[1]).sub(new Vector3(...path[0])).normalize()),
+                }),
+                parentId: duct.parentId ?? undefined,
+            });
+        const tail = changes.create.at(-1).node;
+        changes.update.push(...transferRunEndCapOwnership(before, duct.id, tail.id, 'end'));
+        for (const elbow of elbows)
+            changes.create.push({ node: elbow.fitting, parentId: duct.parentId ?? undefined });
+    }
+    else {
+        const targetResult = DuctSegmentNode.safeParse({
+            ...duct,
+            shape: input.shape ?? duct.shape,
+            diameter: input.diameter ?? duct.diameter,
+            width: input.width ?? duct.width,
+            height: input.height ?? duct.height,
+        });
+        if (!targetResult.success)
+            return refuse('duct_profile_invalid', 'Enter duct dimensions within the supported profile range.');
+        const target = targetResult.data;
+        if (ductProfilesMatch(duct, target))
+            return { result: { message: 'The duct already has this profile.', affected: [] }, changes };
+        const ports = queryNodes(before, { parentId: duct.parentId }).flatMap(portsOf);
+        const selected = new Set([duct.id]);
+        for (const port of ports.filter((p) => p.nodeId === duct.id)) {
+            for (const mate of mates(port, ports)) {
+                const owner = before[mate.nodeId];
+                if (owner?.type === 'duct-fitting' && owner.fittingType === 'end-cap')
+                    selected.add(owner.id);
+            }
+        }
+        const queue = [duct];
+        if (input.scope === 'branch') {
+            while (queue.length) {
+                const current = queue.shift();
+                for (const port of ports.filter((p) => p.nodeId === current.id)) {
+                    for (const mate of mates(port, ports)) {
+                        const owner = before[mate.nodeId];
+                        const traversable = owner.type === 'duct-segment' ||
+                            (owner.type === 'duct-fitting' &&
+                                ['elbow', 'coupling', 'damper', 'end-cap'].includes(owner.fittingType) &&
+                                ports
+                                    .filter((p) => p.nodeId === owner.id)
+                                    .every((p) => mates(p, ports).every((m) => before[m.nodeId]?.type === 'duct-segment')));
+                        if (!selected.has(owner.id) &&
+                            traversable &&
+                            owner.system === duct.system &&
+                            ductProfilesMatch(profileOf(owner, mate), duct)) {
+                            selected.add(owner.id);
+                            queue.push(owner);
+                        }
+                    }
+                }
+            }
+        }
+        const alignment = input.alignment ?? 'center';
+        const connected = ports.some((port) => port.nodeId === duct.id &&
+            mates(port, ports).some((mate) => !selected.has(mate.nodeId) ||
+                before[mate.nodeId]?.type !== 'duct-fitting' ||
+                before[mate.nodeId].fittingType !== 'end-cap'));
+        if (alignment !== 'center' && (connected || duct.path.length !== 2))
+            return refuse('duct_alignment_anchored', 'Face alignment requires a free straight run. Use center alignment to keep connected collars fixed.');
+        const updated = new Map();
+        for (const id of selected) {
+            const node = before[id];
+            if (node.type === 'duct-segment') {
+                let path = node.path.map((p) => [...p]);
+                if (alignment !== 'center') {
+                    const axes = rectSectionAxes(new Vector3(...path[1]).sub(new Vector3(...path[0])).normalize(), node.roll);
+                    if (axes.height.y < 0)
+                        axes.height.negate();
+                    const side = alignment === 'left' || alignment === 'right';
+                    const dimension = (p) => p.shape === 'round' ? p.diameter : side ? p.width : p.height;
+                    const sign = alignment === 'top' || alignment === 'right' ? 1 : -1;
+                    const delta = (side ? axes.width : axes.height)
+                        .clone()
+                        .multiplyScalar((sign * (dimension(node) - dimension(target)) * 0.0254) / 2);
+                    path = path.map((p) => new Vector3(...p).add(delta).toArray());
+                }
+                updated.set(id, {
+                    ...node,
+                    shape: target.shape,
+                    diameter: target.diameter,
+                    width: target.width,
+                    height: target.height,
+                    path,
+                    ductMaterial: node.ductMaterial === 'spiral' && target.shape !== 'round'
+                        ? 'sheet-metal'
+                        : node.ductMaterial,
+                });
+            }
+            else if (node.type === 'duct-fitting') {
+                updated.set(id, DuctFittingNode.parse({
+                    ...node,
+                    shape: target.shape,
+                    diameter: profileDiameterIn(target),
+                    diameter2: profileDiameterIn(target),
+                    width: target.width,
+                    height: target.height,
+                }));
+            }
+        }
+        if (alignment !== 'center') {
+            const resized = updated.get(duct.id);
+            const delta = new Vector3(...resized.path[0]).sub(new Vector3(...duct.path[0]));
+            for (const id of selected) {
+                const cap = updated.get(id);
+                if (cap?.type === 'duct-fitting' && cap.fittingType === 'end-cap')
+                    cap.position = new Vector3(...cap.position).add(delta).toArray();
+            }
+        }
+        for (const id of selected) {
+            const node = updated.get(id);
+            if (node.type !== 'duct-segment')
+                continue;
+            for (const port of ports.filter((p) => p.nodeId === id)) {
+                const matches = mates(port, ports);
+                if (matches.length > 1)
+                    return refuse('duct_connection_ambiguous', 'More than one collar shares an endpoint. Resolve the connection before resizing.');
+                const mate = matches[0];
+                if (!mate)
+                    continue;
+                const owner = before[mate.nodeId];
+                let point = [...port.position];
+                if (selected.has(owner.id)) {
+                    const changed = updated.get(owner.id);
+                    if (changed.type === 'duct-fitting')
+                        point = [...getDuctFittingPorts(changed).find((p) => p.id === mate.id).position];
+                }
+                else {
+                    const adapter = planDuctAdapter(mate, profileOf(owner, mate), target);
+                    if (adapter) {
+                        changes.create.push({ node: adapter.fitting, parentId: duct.parentId ?? undefined });
+                        point = adapter.collarPoint;
+                    }
+                }
+                node.path[port.id === 'start' ? 0 : node.path.length - 1] = point;
+            }
+        }
+        for (const [id, node] of updated)
+            changes.update.push({ id, data: node });
+        validPaths(before, changes);
+    }
+    const touched = changes.update.map((entry) => entry.id);
+    const invalidations = touched.flatMap((id) => autoOffsetInvalidationUpdates(before, id));
+    for (const entry of invalidations) {
+        const existing = changes.update.find((update) => update.id === entry.id);
+        if (existing)
+            existing.data = { ...existing.data, ...entry.data };
+        else
+            changes.update.push(entry);
+    }
+    return {
+        result: {
+            message: input.action === 'offset'
+                ? 'Offset with four elbows; original end connections stay fixed. Check obstacle clearance before applying.'
+                : 'Ducts resized; boundary collars stay fixed with transitions where needed.',
+            affected: changes.update.map((entry) => entry.id),
+            created: changes.create.length,
+        },
+        changes,
+    };
+};

package/dist/duct-segment/floorplan.js

@@ -1,6 +1,6 @@
 import { runHangerFloorplan } from '../shared/run-hangers.js';
 import { ductContinuationHandlePlan, ductEndpointPort } from './continuation.js';
-import { INCHES_TO_METERS } from './geometry.js';
+import { INCHES_TO_METERS } from './profile.js';
 const SUPPLY_CENTERLINE = '#d4825a';
 const RETURN_CENTERLINE = '#5a8ad4';
 const BODY_COLOR = '#9ca3af';

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

@@ -2,46 +2,6 @@ import type { GeometryContext } from '@pascal-app/core';
 import { type ColorPreset, type RenderShading } from '@pascal-app/viewer';
 import { ExtrudeGeometry, Group, type Material, Mesh, Vector3 } from 'three';
 import type { DuctSegmentNode } from './schema.js';
-export declare const INCHES_TO_METERS = 0.0254;
-/**
- * Area-equivalent round diameter (inches) for a rect cross-section —
- * what a rect trunk advertises on its ports so round fittings / branches
- * mate at a sensible size.
- */
-export declare function equivalentDiameterIn(widthIn: number, heightIn: number): number;
-/**
- * Area-equivalent round diameter (inches) for a flat-oval cross-section:
- * a rectangle of (width − height) × height plus the two semicircular caps.
- */
-export declare function ovalEquivalentDiameterIn(widthIn: number, heightIn: number): number;
-/** The diameter (inches) a duct segment presents at its ports. */
-export declare function ductPortDiameterIn(node: {
-    shape?: 'round' | 'rect' | 'oval';
-    diameter: number;
-    width?: number;
-    height?: number;
-}): number;
-/**
- * Cross-section axes for a rect run along `dir`, rolled `roll` radians
- * about the run direction. At roll 0: width is the horizontal axis
- * (UP × dir) and height the vertical one — vertical runs, where that
- * cross product degenerates, fall back to world X/Z. `roll` rotates the
- * pair in the plane perpendicular to `dir`, letting a riser carry the
- * orientation of the run it turned off instead of the bare fallback.
- */
-export declare function rectSectionAxes(dir: Vector3, roll?: number): {
-    width: Vector3;
-    height: Vector3;
-};
-/**
- * Roll (radians) that keeps a rect cross-section continuous across an
- * elbow: the dimension lying along the joint's hinge — the bend-plane
- * normal `portDir × newDir`, perpendicular to both legs — must stay on
- * the same physical face on the new run as on the source run. Returns 0
- * for an in-plane (degenerate-normal) joint, so horizontal turns keep
- * the natural width-horizontal orientation.
- */
-export declare function rollToContinueAcrossElbow(sourceDir: Vector3, sourceRoll: number, portDir: Vector3, newDir: Vector3): number;
 /**
  * Rect box spanning `start`→`end`. Orientation comes from `rectSectionAxes`
  * (width horizontal, height vertical by default; `roll` reorients a riser

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;AAEvD,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;AAuB/C;;;;;;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

@@ -2,7 +2,7 @@ import { DUCT_BODY_SLOT_DEFAULT, DUCT_BODY_SLOT_ID } from '@pascal-app/core';
 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 { buildRunHangers } from '../shared/run-hangers.js';
-export const INCHES_TO_METERS = 0.0254;
+import { INCHES_TO_METERS, rectSectionAxes } from './profile.js';
 // 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
 // at screen scale — R-1 would add only ~8 mm over a 15 cm duct. So the shell
@@ -20,83 +20,8 @@ function pickInsulationThickness(r) {
 // body itself is plain white (see createDuctMaterial).
 const SUPPLY_COLOR = '#d4825a';
 const RETURN_COLOR = '#5a8ad4';
-const RADIAL_SEGMENTS = 24;
 const UP = new Vector3(0, 1, 0);
-/**
- * Area-equivalent round diameter (inches) for a rect cross-section —
- * what a rect trunk advertises on its ports so round fittings / branches
- * mate at a sensible size.
- */
-export function equivalentDiameterIn(widthIn, heightIn) {
-    return 2 * Math.sqrt((widthIn * heightIn) / Math.PI);
-}
-/**
- * Area-equivalent round diameter (inches) for a flat-oval cross-section:
- * a rectangle of (width − height) × height plus the two semicircular caps.
- */
-export function ovalEquivalentDiameterIn(widthIn, heightIn) {
-    const minor = Math.min(widthIn, heightIn);
-    const major = Math.max(widthIn, heightIn);
-    const area = (major - minor) * minor + Math.PI * (minor / 2) ** 2;
-    return 2 * Math.sqrt(area / Math.PI);
-}
-/** The diameter (inches) a duct segment presents at its ports. */
-export function ductPortDiameterIn(node) {
-    if (node.shape === 'rect' && node.width && node.height) {
-        return equivalentDiameterIn(node.width, node.height);
-    }
-    if (node.shape === 'oval' && node.width && node.height) {
-        return ovalEquivalentDiameterIn(node.width, node.height);
-    }
-    return node.diameter;
-}
-/**
- * Cross-section axes for a rect run along `dir`, rolled `roll` radians
- * about the run direction. At roll 0: width is the horizontal axis
- * (UP × dir) and height the vertical one — vertical runs, where that
- * cross product degenerates, fall back to world X/Z. `roll` rotates the
- * pair in the plane perpendicular to `dir`, letting a riser carry the
- * orientation of the run it turned off instead of the bare fallback.
- */
-export function rectSectionAxes(dir, roll = 0) {
-    const d = dir.clone().normalize();
-    const xBase = new Vector3().crossVectors(UP, d);
-    if (xBase.lengthSq() < 1e-8)
-        xBase.set(1, 0, 0);
-    xBase.normalize();
-    const zBase = new Vector3().crossVectors(xBase, d);
-    const c = Math.cos(roll);
-    const s = Math.sin(roll);
-    const width = xBase.clone().multiplyScalar(c).addScaledVector(zBase, s);
-    const height = xBase.clone().multiplyScalar(-s).addScaledVector(zBase, c);
-    return { width, height };
-}
-/**
- * Roll (radians) that keeps a rect cross-section continuous across an
- * elbow: the dimension lying along the joint's hinge — the bend-plane
- * normal `portDir × newDir`, perpendicular to both legs — must stay on
- * the same physical face on the new run as on the source run. Returns 0
- * for an in-plane (degenerate-normal) joint, so horizontal turns keep
- * the natural width-horizontal orientation.
- */
-export function rollToContinueAcrossElbow(sourceDir, sourceRoll, portDir, newDir) {
-    const n = new Vector3().crossVectors(portDir, newDir);
-    if (n.lengthSq() < 1e-8)
-        return 0;
-    n.normalize();
-    const src = rectSectionAxes(sourceDir, sourceRoll);
-    const carriesWidth = Math.abs(src.width.dot(n)) >= Math.abs(src.height.dot(n));
-    const d = newDir.clone().normalize();
-    const xBase = new Vector3().crossVectors(UP, d);
-    if (xBase.lengthSq() < 1e-8)
-        xBase.set(1, 0, 0);
-    xBase.normalize();
-    const zBase = new Vector3().crossVectors(xBase, d);
-    // Place the hinge-aligned face on the same axis the source carries it.
-    return carriesWidth
-        ? Math.atan2(n.dot(zBase), n.dot(xBase))
-        : Math.atan2(-n.dot(xBase), n.dot(zBase));
-}
+const RADIAL_SEGMENTS = 24;
 /**
  * Rect box spanning `start`→`end`. Orientation comes from `rectSectionAxes`
  * (width horizontal, height vertical by default; `roll` reorients a riser

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;AAoFzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA4T3D,CAAA;eA0Dc,mBAAmB"}
+{"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;AAoFzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA2T3D,CAAA;eA0Dc,mBAAmB"}

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

@@ -12,7 +12,7 @@ import { DUCT_PORT_SYSTEMS } from '../shared/port-systems.js';
 import { startRunMoveConnectivity } from '../shared/run-move-connectivity.js';
 import { planRunTranslationOffsets, } from '../shared/run-translation-offset.js';
 import { translateWallRun } from '../shared/wall-run-move.js';
-import { rectSectionAxes } from './geometry.js';
+import { rectSectionAxes } from './profile.js';
 const GHOST_COLOR = '#818cf8';
 const GHOST_OPACITY = 0.5;
 const IN_TO_M = 0.0254;
@@ -130,8 +130,18 @@ export const MoveDuctSegmentTool = ({ node }) => {
             width: duct.width,
             height: duct.height,
         };
-        let lastTranslationPlan = null;
+        const translationPlanFor = (path) => portConnectivity
+            ? planRunTranslationOffsets({
+                duct,
+                translatedPath: path,
+                profile,
+                connections: portConnectivity.connections,
+                scenePorts,
+                nodesById,
+            })
+            : null;
         const setPreview = (path) => {
+            hasMovedRef.current = true;
             previewPathRef.current = path;
             setPreviewPath(path);
         };
@@ -142,10 +152,11 @@ export const MoveDuctSegmentTool = ({ node }) => {
             if (duct.wallAttachment && attachedWall?.type === 'wall') {
                 const wallMove = translateWallRun(originalPath, duct.wallAttachment, attachedWall, event);
                 if (wallMove) {
-                    hasMovedRef.current = true;
+                    // Connected joints that cannot follow hold the last shown frame.
+                    if (connectivity && !connectivity.preview({ path: wallMove.path }))
+                        return;
                     previewAttachmentRef.current = wallMove.attachment;
                     setPreview(wallMove.path);
-                    connectivity?.preview({ path: wallMove.path });
                     setTranslationGhost(null);
                     return;
                 }
@@ -181,25 +192,14 @@ export const MoveDuctSegmentTool = ({ node }) => {
                 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)
+            const translationPlan = translationPlanFor(nextPath);
+            if (translationPlan)
                 connectivity?.clear();
-            else
-                connectivity?.preview({ path: nextPath });
-            setTranslationGhost(lastTranslationPlan);
+            else if (connectivity && !connectivity.preview({ path: nextPath }))
+                return;
+            setPreview(nextPath);
+            setTranslationGhost(translationPlan);
         };
         const commit = (event, fromDragRelease = false) => {
             if (committed)
@@ -215,11 +215,22 @@ export const MoveDuctSegmentTool = ({ node }) => {
                 event.nativeEvent?.stopPropagation?.();
                 return;
             }
-            committed = true;
             const finalPath = previewPathRef.current;
+            const creating = isNew && !useScene.getState().nodes[nodeId];
+            const translationPlan = creating ? null : translationPlanFor(finalPath);
+            // 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 = creating || translationPlan || !connectivity
+                ? []
+                : connectivity.commitUpdates({ path: finalPath });
+            if (!followUpdates) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            committed = true;
             useScene.temporal.getState().resume();
             let selectId = nodeId;
-            if (isNew && !useScene.getState().nodes[nodeId]) {
+            if (creating) {
                 const created = DuctSegmentNode.parse({
                     ...node,
                     path: finalPath,
@@ -237,15 +248,6 @@ export const MoveDuctSegmentTool = ({ node }) => {
                 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) => ({
@@ -265,9 +267,6 @@ export const MoveDuctSegmentTool = ({ node }) => {
                     });
                 }
                 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,

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

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

package/dist/duct-segment/parametrics.js

@@ -3,7 +3,7 @@ import { Vector3 } from 'three';
 import { getDuctFittingPorts } from '../duct-fitting/ports.js';
 import { findAutomaticRunEndCapIds } from '../shared/automatic-run-end-cap.js';
 import { fittingDeletionPlansForRun } from '../shared/fitting-deletion-cleanup.js';
-import { rollToContinueAcrossElbow } from './geometry.js';
+import { rollToContinueAcrossElbow } from './profile.js';
 /** A run endpoint sitting this close to a collar counts as mated. */
 const MATE_TOL_M = 0.03;
 function dist2(a, b) {
@@ -100,7 +100,7 @@ export const ductSegmentParametrics = {
         ...findAutomaticRunEndCapIds(duct.id, nodes, 'duct-fitting'),
         ...fittingDeletionPlansForRun(duct, nodes, requestedDeleteIds, false).flatMap((plan) => plan.deleteFitting ? [plan.fittingId, ...plan.cascadeDeleteIds] : []),
     ],
-    trailingSection: () => import('../shared/run-hanger-inspector.js'),
+    trailingSection: () => import('./edit-inspector.js'),
     groups: [
         {
             label: 'Hangers',
@@ -145,39 +145,6 @@ export const ductSegmentParametrics = {
                     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',
-                },
             ],
         },
         {