@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/duct-segment/definition.render.js

@@ -0,0 +1,91 @@
+import { ductBodySlots } from '@pascal-app/core';
+import { buildDuctSegmentFloorplan } from './floorplan.js';
+import { buildDuctSegmentGeometry } from './geometry.js';
+import { ductPortDiameterIn } from './profile.js';
+import { DuctSegmentNode } from './schema.js';
+export const ductSegmentRenderDefinition = {
+    kind: 'duct-segment',
+    schemaVersion: 2,
+    schema: DuctSegmentNode,
+    category: 'utility',
+    distributionRole: 'run',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        autoHangers: false,
+        hangerStyle: 'single',
+        hangerSpacing: 1.5,
+        hangerMaxReach: 2,
+        path: [
+            [0, 0, 0],
+            [3, 0, 0],
+        ],
+        shape: 'rect',
+        diameter: 6,
+        width: 14,
+        height: 8,
+        ductMaterial: 'flex',
+        seamDetail: false,
+        insulated: false,
+        insulationR: 0.5,
+        system: 'supply',
+        roll: 0,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        slots: () => ductBodySlots(),
+    },
+    system: {
+        module: async () => ({
+            default: (await import('../shared/run-hanger-system.js')).DuctHangerSystem,
+        }),
+    },
+    geometry: buildDuctSegmentGeometry,
+    // Open run ends as typed ports — directions point outward along the
+    // path tangent so fittings mate flush. Path coords are already
+    // level-local, so no transform is needed.
+    ports: (n) => {
+        if (n.path.length < 2)
+            return [];
+        const unit = (a, b) => {
+            const d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+            const len = Math.hypot(d[0], d[1], d[2]);
+            return len < 1e-9 ? [1, 0, 0] : [d[0] / len, d[1] / len, d[2] / len];
+        };
+        const first = n.path[0];
+        const second = n.path[1];
+        const last = n.path[n.path.length - 1];
+        const prev = n.path[n.path.length - 2];
+        return [
+            {
+                id: 'start',
+                position: first,
+                direction: unit(first, second),
+                diameter: ductPortDiameterIn(n),
+                system: n.system,
+            },
+            {
+                id: 'end',
+                position: last,
+                direction: unit(last, prev),
+                diameter: ductPortDiameterIn(n),
+                system: n.system,
+            },
+        ];
+    },
+    floorplan: buildDuctSegmentFloorplan,
+    presentation: {
+        label: 'Duct',
+        description: 'HVAC duct run — polyline of round, rect, or flat-oval sections.',
+        icon: { kind: 'url', src: '/icons/duct.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 90,
+    },
+    mcp: {
+        description: 'An HVAC duct run defined as a polyline — round (branches), rect (trunks/plenums), or flat-oval (tight joist bays). Supply or return, with configurable size, material (incl. spiral seam), and external insulation.',
+    },
+};

package/dist/duct-segment/edit-inspector.d.ts

@@ -0,0 +1,5 @@
+import { type DuctSegmentNode } from '@pascal-app/core';
+export default function DuctEditInspector({ node }: {
+    node: DuctSegmentNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=edit-inspector.d.ts.map

package/dist/duct-segment/edit-inspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-inspector.d.ts","sourceRoot":"","sources":["../../src/duct-segment/edit-inspector.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,eAAe,EAA2B,MAAM,kBAAkB,CAAA;AAKhG,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,+BAU5E"}

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

@@ -0,0 +1,163 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { usePascalI18n, useScene } from '@pascal-app/core';
+import { useMemo, useState } from 'react';
+import RunHangerInspector from '../shared/run-hanger-inspector.js';
+import { editDuct } from './edit-operation.js';
+export default function DuctEditInspector({ node }) {
+    return (_jsxs(_Fragment, { children: [_jsx(DuctEditForm, { node: node }, `${node.id}:${node.shape}:${node.diameter}:${node.width}:${node.height}:${JSON.stringify(node.path)}`), _jsx(RunHangerInspector, { node: node })] }));
+}
+function DuctEditForm({ node }) {
+    const i18n = usePascalI18n();
+    const nodes = useScene((state) => state.nodes);
+    const [input, setInput] = useState({
+        nodeId: node.id,
+        action: 'resize',
+        scope: 'segment',
+        alignment: 'center',
+        shape: node.shape,
+        diameter: node.diameter,
+        width: node.width,
+        height: node.height,
+        from: 1,
+        to: 2,
+        offset: 1,
+    });
+    const [notice, setNotice] = useState('');
+    const preview = useMemo(() => {
+        try {
+            return { outcome: editDuct(nodes, input, { activeLevelId: node.parentId }), error: '' };
+        }
+        catch (error) {
+            return {
+                outcome: null,
+                error: error instanceof Error
+                    ? error.message
+                    : i18n._({
+                        id: 'node.ductSegment.editInspector.unableToPlanEdit',
+                        message: 'Unable to plan this edit.',
+                    }),
+            };
+        }
+    }, [nodes, input, node.parentId, i18n]);
+    const update = (patch) => {
+        setInput((previous) => ({ ...previous, ...patch }));
+        setNotice('');
+    };
+    const numberField = (key, label) => (_jsxs("label", { className: "flex items-center justify-between gap-2", children: [label, _jsx("input", { "aria-label": label, type: "number", step: input.action === 'offset' ? 0.05 : 1, className: "w-20 rounded border bg-background p-1", value: Number.isFinite(input[key]) ? input[key] : '', onChange: (event) => update({ [key]: event.target.valueAsNumber }) })] }));
+    const changes = preview.outcome?.changes;
+    const count = (changes?.update?.length ?? 0) + (changes?.create?.length ?? 0);
+    const paths = input.action === 'offset' && changes
+        ? [
+            ...changes
+                .update.filter((entry) => entry.id === node.id)
+                .map((entry) => entry.data.path),
+            ...changes.create.flatMap((entry) => entry.node.type === 'duct-segment' ? [entry.node.path] : []),
+        ]
+        : [];
+    const length = Math.hypot(...node.path[1].map((v, i) => v - node.path[0][i]));
+    const elevation = Math.max(Math.abs(input.offset ?? 1), 0.1);
+    const project = (point) => {
+        const along = point.reduce((sum, value, i) => sum + (value - node.path[0][i]) * (node.path[1][i] - node.path[0][i]), 0) / (length || 1);
+        const baseline = (input.offset ?? 0) > 0 ? 90 : 26;
+        return `${16 + (along / (length || 1)) * 228},${baseline - ((point[1] - node.path[0][1]) / elevation) * 64}`;
+    };
+    return (_jsxs("section", { className: "space-y-2 border-t pt-3 text-xs", children: [_jsx("h3", { className: "text-sm font-medium", children: i18n._({ id: 'node.ductSegment.editInspector.editDuctRoute', message: 'Edit duct route' }) }), _jsxs("select", { "aria-label": i18n._({ id: 'node.ductSegment.editInspector.ductEdit', message: 'Duct edit' }), className: "w-full rounded border bg-background p-1", value: input.action, onChange: (event) => update({ action: event.target.value }), children: [_jsx("option", { value: "resize", children: i18n._({
+                            id: 'node.ductSegment.editInspector.resizeWithConnections',
+                            message: 'Resize with connections',
+                        }) }), _jsx("option", { value: "offset", children: i18n._({
+                            id: 'node.ductSegment.editInspector.offsetAroundObstacle',
+                            message: 'Offset around obstacle',
+                        }) })] }), input.action === 'resize' ? (_jsxs(_Fragment, { children: [_jsxs("select", { "aria-label": i18n._({
+                            id: 'node.ductSegment.editInspector.resizeScope',
+                            message: 'Resize scope',
+                        }), className: "w-full rounded border bg-background p-1", value: input.scope, onChange: (event) => update({ scope: event.target.value }), children: [_jsx("option", { value: "segment", children: i18n._({
+                                    id: 'node.ductSegment.editInspector.thisSegment',
+                                    message: 'This segment',
+                                }) }), _jsx("option", { value: "branch", children: i18n._({
+                                    id: 'node.ductSegment.editInspector.connectedSameSizeBranch',
+                                    message: 'Connected same-size branch',
+                                }) })] }), _jsx("p", { className: "text-muted-foreground", children: i18n._({
+                            id: 'node.ductSegment.editInspector.branchStopsAtJunctionsSizeChanges',
+                            message: 'Branch stops at junctions, size changes and equipment. Boundary collars stay fixed.',
+                        }) }), _jsxs("select", { "aria-label": i18n._({
+                            id: 'node.ductSegment.editInspector.ductShape',
+                            message: 'Duct shape',
+                        }), className: "w-full rounded border bg-background p-1", value: input.shape, onChange: (event) => update({ shape: event.target.value }), children: [_jsx("option", { value: "round", children: i18n._({ id: 'node.ductSegment.editInspector.round', message: 'Round' }) }), _jsx("option", { value: "rect", children: i18n._({ id: 'node.ductSegment.editInspector.rectangular', message: 'Rectangular' }) }), _jsx("option", { value: "oval", children: i18n._({ id: 'node.ductSegment.editInspector.oval', message: 'Oval' }) })] }), input.shape === 'round' ? (numberField('diameter', i18n._({ id: 'node.ductSegment.editInspector.diameter', message: 'Diameter (in)' }))) : (_jsxs(_Fragment, { children: [numberField('width', i18n._({ id: 'node.ductSegment.editInspector.width', message: 'Width (in)' })), numberField('height', i18n._({ id: 'node.ductSegment.editInspector.height', message: 'Height (in)' }))] })), _jsxs("select", { "aria-label": i18n._({
+                            id: 'node.ductSegment.editInspector.preserveDuctAlignment',
+                            message: 'Preserve duct alignment',
+                        }), className: "w-full rounded border bg-background p-1", value: input.alignment, onChange: (event) => update({ alignment: event.target.value }), children: [_jsx("option", { value: "center", children: i18n._({
+                                    id: 'node.ductSegment.editInspector.keepCenterline',
+                                    message: 'Keep centerline',
+                                }) }), _jsx("option", { value: "top", children: i18n._({
+                                    id: 'node.ductSegment.editInspector.keepTopFace',
+                                    message: 'Keep top face',
+                                }) }), _jsx("option", { value: "bottom", children: i18n._({
+                                    id: 'node.ductSegment.editInspector.keepBottomFace',
+                                    message: 'Keep bottom face',
+                                }) }), _jsx("option", { value: "left", children: i18n._({
+                                    id: 'node.ductSegment.editInspector.keepLeftFace',
+                                    message: 'Keep left face',
+                                }) }), _jsx("option", { value: "right", children: i18n._({
+                                    id: 'node.ductSegment.editInspector.keepRightFace',
+                                    message: 'Keep right face',
+                                }) })] }), _jsx("p", { className: "text-muted-foreground", children: i18n._({
+                            id: 'node.ductSegment.editInspector.faceAlignmentAppliesToFreeStraight',
+                            message: 'Face alignment applies to free straight runs. Left and right follow the run’s section axes.',
+                        }) })] })) : (_jsxs(_Fragment, { children: [numberField('from', i18n._({
+                        id: 'node.ductSegment.editInspector.firstBend',
+                        message: 'First bend from start (m)',
+                    })), numberField('to', i18n._({
+                        id: 'node.ductSegment.editInspector.lastBend',
+                        message: 'Last bend from start (m)',
+                    })), numberField('offset', i18n._({
+                        id: 'node.ductSegment.editInspector.verticalOffset',
+                        message: 'Vertical offset (m)',
+                    })), _jsx("p", { className: "text-muted-foreground", children: i18n._({
+                            id: 'node.ductSegment.editInspector.positiveMovesUpNegativeMovesDown',
+                            message: 'Positive moves up; negative moves down. Four elbows preserve both endpoints. Check the obstacle’s clearance; this does not detect collisions.',
+                        }) })] })), paths.length > 0 && (_jsxs("figure", { className: "rounded border p-2", children: [_jsxs("svg", { viewBox: "0 0 260 116", role: "img", "aria-label": i18n._({
+                            id: 'node.ductSegment.editInspector.offsetSideElevationPreview',
+                            message: 'Offset side elevation preview',
+                        }), className: "w-full", children: [_jsx("title", { children: i18n._({
+                                    id: 'node.ductSegment.editInspector.offsetSideElevationPreview',
+                                    message: 'Offset side elevation preview',
+                                }) }), _jsx("polyline", { points: node.path.map(project).join(' '), fill: "none", stroke: "currentColor", opacity: "0.3", strokeDasharray: "4 4" }), _jsx("polyline", { points: paths.flat().map(project).join(' '), fill: "none", stroke: "#818cf8", strokeWidth: "3" })] }), _jsx("figcaption", { className: "text-muted-foreground", children: i18n._({
+                            id: 'node.ductSegment.editInspector.sideElevationDashedLineIsThe',
+                            message: 'Side elevation · dashed line is the original route',
+                        }) })] })), _jsx("p", { role: "status", className: preview.error ? 'text-amber-600' : 'text-muted-foreground', children: preview.error ||
+                    i18n._({
+                        id: 'node.ductSegment.editInspector.partsSummary',
+                        message: '{affected, plural, one {# existing part affected} other {# existing parts affected}} · {created, plural, one {# new part} other {# new parts}}',
+                        values: {
+                            affected: changes?.update?.length ?? 0,
+                            created: changes?.create?.length ?? 0,
+                        },
+                    }) }), _jsx("button", { type: "button", disabled: !count || !!preview.error, className: "w-full rounded border px-2 py-1 disabled:opacity-40", onClick: () => {
+                    try {
+                        const outcome = editDuct(useScene.getState().nodes, input, {
+                            activeLevelId: node.parentId,
+                        });
+                        const plan = outcome.changes;
+                        if (plan)
+                            useScene.getState().applyNodeChanges({
+                                create: plan.create?.map((entry) => ({
+                                    ...entry,
+                                    parentId: entry.parentId,
+                                })),
+                                update: plan.update?.map((entry) => ({ ...entry, id: entry.id })),
+                            });
+                        setNotice(String(outcome.result.message));
+                    }
+                    catch (error) {
+                        setNotice(error instanceof Error
+                            ? error.message
+                            : i18n._({
+                                id: 'node.ductSegment.editInspector.unableToApplyEdit',
+                                message: 'Unable to apply edit.',
+                            }));
+                    }
+                }, children: input.action === 'resize'
+                    ? i18n._({ id: 'node.ductSegment.editInspector.applyResize', message: 'Apply resize' })
+                    : i18n._({ id: 'node.ductSegment.editInspector.applyOffset', message: 'Apply offset' }) }), notice && _jsx("p", { role: "status", children: notice })] }));
+}

package/dist/duct-segment/edit-operation.d.ts

@@ -0,0 +1,17 @@
+import type { AgentOperation } from '@pascal-app/core/agent-operations';
+export type DuctEditInput = {
+    nodeId: string;
+    action: 'resize' | 'offset';
+    scope?: 'segment' | 'branch';
+    alignment?: 'center' | 'top' | 'bottom' | 'left' | 'right';
+    shape?: 'round' | 'rect' | 'oval';
+    diameter?: number;
+    width?: number;
+    height?: number;
+    offset?: number;
+    from?: number;
+    to?: number;
+};
+/** One plan is used by the inspector and agent hosts; neither writes a partial network. */
+export declare const editDuct: AgentOperation<DuctEditInput>;
+//# sourceMappingURL=edit-operation.d.ts.map

package/dist/duct-segment/edit-operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-operation.d.ts","sourceRoot":"","sources":["../../src/duct-segment/edit-operation.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAA4B,MAAM,mCAAmC,CAAA;AAajG,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC3B,KAAK,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAA;IAC5B,SAAS,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAA;IAC1D,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,EAAE,CAAC,EAAE,MAAM,CAAA;CACZ,CAAA;AA4CD,2FAA2F;AAC3F,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,aAAa,CAmRlD,CAAA"}

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