@pascal-app/nodes 1.0.6 → 1.1.0

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

@@ -0,0 +1,100 @@
+import { useScene } from '@pascal-app/core';
+import { ductBodyPaint } from '../shared/duct-body-paint.js';
+import { createPathPointMoveAffordance } from '../shared/path-point-affordance.js';
+import { createSegmentMoveAffordance } from '../shared/path-segment-affordance.js';
+import { createRunHangerToolHint } from '../shared/run-hanger-mode.js';
+import { ductRunToolOptions } from '../shared/run-tool-options.js';
+import { ductBranchAffordance, ductContinuationAffordance } from './continuation.js';
+import { buildDuctSegmentFloorplan } from './floorplan.js';
+import { ductSegmentParametrics } from './parametrics.js';
+/**
+ * Phase 1 of the HVAC node system — round duct segment as a polyline.
+ *
+ * Composition: `def.geometry` only. No custom renderer, no per-frame
+ * system. The framework's `<ParametricNodeRenderer>` mounts an empty
+ * group; `<GeometrySystem>` calls `buildDuctSegmentGeometry` whenever
+ * the node is dirty and swaps in the cylinder+sphere meshes.
+ *
+ * Deferred to later slices:
+ *   - Placement tool (polyline draw UX).
+ *   - Fittings (elbow / tee / reducer) — needs typed ports first.
+ *   - Terminals (registers / diffusers) — needs surface-snapping.
+ *   - Equipment (furnace / air-handler / condenser).
+ *   - Floor-plan rendering.
+ *   - Move / endpoint handles.
+ *
+ * The node can be created programmatically today via
+ * `DuctSegmentNode.parse({ path: [...] })` + `useScene.createNode(...)`.
+ */
+/** R / T roll step (radians) — 45°, matching the fitting rotate. */
+const ROLL_STEP_RAD = Math.PI / 4;
+/**
+ * R / T roll a selected rect / oval run's cross-section ±45° around its
+ * drawn line, so a rectangular trunk can be turned on its side after
+ * placement. Round runs look identical at any roll, so the action gates
+ * itself off for them (`appliesTo`) and the editor's default rotation —
+ * a no-op for a node with no `rotation` field — takes over harmlessly.
+ */
+function rollDuctSegment(node, steps) {
+    const duct = node;
+    useScene.getState().updateNode(duct.id, { roll: duct.roll + steps * ROLL_STEP_RAD });
+}
+export const ductSegmentEditContribution = {
+    drafting: { surfaceQuery: true, cancelOnHistoryJump: true },
+    // Directional run: like a wall, drafting sets a direction, so it takes the
+    // structural snapping context (grid / lines / angles / off) with a 45° angle
+    // lock available as a cyclable mode.
+    snapProfile: 'structural',
+    capabilities: {
+        paint: ductBodyPaint,
+    },
+    parametrics: ductSegmentParametrics,
+    // R / T roll a selected rect / oval run ±45° around its drawn line.
+    // `appliesTo` lets round runs fall through to the editor's default
+    // (harmless — duct-segment has no `rotation` field).
+    keyboardActions: {
+        r: {
+            appliesTo: (node) => node.type === 'duct-segment' && node.shape !== 'round',
+            run: (node) => rollDuctSegment(node, 1),
+        },
+        t: {
+            appliesTo: (node) => node.type === 'duct-segment' && node.shape !== 'round',
+            run: (node) => rollDuctSegment(node, -1),
+        },
+    },
+    floorplanDependsOnSiblings: true,
+    floorplan: buildDuctSegmentFloorplan,
+    // 2D selection-time path-point handles — the floor-plan twin of the 3D
+    // `affordanceTools.selection` handles. The builder emits an
+    // `endpoint-handle` per path vertex; this drags the matching point.
+    floorplanAffordances: {
+        'move-path-point': createPathPointMoveAffordance('duct-segment'),
+        // 2D twin of the 3D side-move arrows: slide a segment perpendicular to
+        // itself. (Length editing stays on the per-vertex hex handles.)
+        'move-segment': createSegmentMoveAffordance('duct-segment'),
+        'continue-run': ductContinuationAffordance,
+        'branch-run': ductBranchAffordance,
+    },
+    // Selection-time path-point handles (drag to edit a committed run).
+    // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
+    // mounts via the editor's SelectionAffordanceManager — not `def.system`,
+    // which the viewer package mounts for the read-only route.
+    affordanceTools: {
+        selection: () => import('./selection.js'),
+        // Ghost-preview duplicate / move. Duplicate is pure drag-to-place: a
+        // translucent copy of the run follows the cursor and only lands on the
+        // commit click — nothing is inserted into the scene before that.
+        move: () => import('./move-tool.js'),
+    },
+    tool: () => import('./tool.js'),
+    toolOptions: ductRunToolOptions,
+    toolHints: [
+        { key: 'Click', label: 'Start segment' },
+        { key: 'Click again', label: 'Place and continue' },
+        { key: 'Alt + drag', label: 'Go vertical ↕, click to place' },
+        { key: '[ / ]', label: 'Duct diameter down / up' },
+        { key: 'Q', label: 'Round / rectangular / oval' },
+        createRunHangerToolHint('duct-segment'),
+        { key: 'Esc', label: 'Exit drawing' },
+    ],
+};

package/dist/duct-segment/definition.js

@@ -1,181 +1,4 @@
-import { ductBodySlots, useScene } from '@pascal-app/core';
-import { ductBodyPaint } from '../shared/duct-body-paint.js';
-import { createPathPointMoveAffordance } from '../shared/path-point-affordance.js';
-import { createSegmentMoveAffordance } from '../shared/path-segment-affordance.js';
-import { createRunHangerToolHint } from '../shared/run-hanger-mode.js';
-import { ductBranchAffordance, ductContinuationAffordance } from './continuation.js';
-import { buildDuctSegmentFloorplan } from './floorplan.js';
-import { buildDuctSegmentGeometry, ductPortDiameterIn } from './geometry.js';
-import { ductSegmentParametrics } from './parametrics.js';
-import { DuctSegmentNode } from './schema.js';
-/**
- * Phase 1 of the HVAC node system — round duct segment as a polyline.
- *
- * Composition: `def.geometry` only. No custom renderer, no per-frame
- * system. The framework's `<ParametricNodeRenderer>` mounts an empty
- * group; `<GeometrySystem>` calls `buildDuctSegmentGeometry` whenever
- * the node is dirty and swaps in the cylinder+sphere meshes.
- *
- * Deferred to later slices:
- *   - Placement tool (polyline draw UX).
- *   - Fittings (elbow / tee / reducer) — needs typed ports first.
- *   - Terminals (registers / diffusers) — needs surface-snapping.
- *   - Equipment (furnace / air-handler / condenser).
- *   - Floor-plan rendering.
- *   - Move / endpoint handles.
- *
- * The node can be created programmatically today via
- * `DuctSegmentNode.parse({ path: [...] })` + `useScene.createNode(...)`.
- */
-/** R / T roll step (radians) — 45°, matching the fitting rotate. */
-const ROLL_STEP_RAD = Math.PI / 4;
-/**
- * R / T roll a selected rect / oval run's cross-section ±45° around its
- * drawn line, so a rectangular trunk can be turned on its side after
- * placement. Round runs look identical at any roll, so the action gates
- * itself off for them (`appliesTo`) and the editor's default rotation —
- * a no-op for a node with no `rotation` field — takes over harmlessly.
- */
-function rollDuctSegment(node, steps) {
-    const duct = node;
-    useScene.getState().updateNode(duct.id, { roll: duct.roll + steps * ROLL_STEP_RAD });
-}
-export const ductSegmentDefinition = {
-    kind: 'duct-segment',
-    schemaVersion: 2,
-    schema: DuctSegmentNode,
-    category: 'utility',
-    distributionRole: 'run',
-    drafting: { surfaceQuery: true, cancelOnHistoryJump: true },
-    // Directional run: like a wall, drafting sets a direction, so it takes the
-    // structural snapping context (grid / lines / angles / off) with a 45° angle
-    // lock available as a cyclable mode.
-    snapProfile: 'structural',
-    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(),
-        paint: ductBodyPaint,
-    },
-    parametrics: ductSegmentParametrics,
-    // R / T roll a selected rect / oval run ±45° around its drawn line.
-    // `appliesTo` lets round runs fall through to the editor's default
-    // (harmless — duct-segment has no `rotation` field).
-    keyboardActions: {
-        r: {
-            appliesTo: (node) => node.type === 'duct-segment' && node.shape !== 'round',
-            run: (node) => rollDuctSegment(node, 1),
-        },
-        t: {
-            appliesTo: (node) => node.type === 'duct-segment' && node.shape !== 'round',
-            run: (node) => rollDuctSegment(node, -1),
-        },
-    },
-    system: {
-        module: async () => ({
-            default: (await import('../shared/run-hanger-system.js')).DuctHangerSystem,
-        }),
-    },
-    floorplanDependsOnSiblings: true,
-    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,
-    // 2D selection-time path-point handles — the floor-plan twin of the 3D
-    // `affordanceTools.selection` handles. The builder emits an
-    // `endpoint-handle` per path vertex; this drags the matching point.
-    floorplanAffordances: {
-        'move-path-point': createPathPointMoveAffordance('duct-segment'),
-        // 2D twin of the 3D side-move arrows: slide a segment perpendicular to
-        // itself. (Length editing stays on the per-vertex hex handles.)
-        'move-segment': createSegmentMoveAffordance('duct-segment'),
-        'continue-run': ductContinuationAffordance,
-        'branch-run': ductBranchAffordance,
-    },
-    // Selection-time path-point handles (drag to edit a committed run).
-    // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
-    // mounts via the editor's SelectionAffordanceManager — not `def.system`,
-    // which the viewer package mounts for the read-only route.
-    affordanceTools: {
-        selection: () => import('./selection.js'),
-        // Ghost-preview duplicate / move. Duplicate is pure drag-to-place: a
-        // translucent copy of the run follows the cursor and only lands on the
-        // commit click — nothing is inserted into the scene before that.
-        move: () => import('./move-tool.js'),
-    },
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Click', label: 'Start segment' },
-        { key: 'Click again', label: 'Place and continue' },
-        { key: 'Alt + drag', label: 'Go vertical ↕, click to place' },
-        { key: '[ / ]', label: 'Duct diameter down / up' },
-        { key: 'Q', label: 'Round / rectangular / oval' },
-        createRunHangerToolHint('duct-segment'),
-        { key: 'Esc', label: 'Exit drawing' },
-    ],
-    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.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { ductSegmentEditContribution } from './definition.edit.js';
+import { ductSegmentRenderDefinition } from './definition.render.js';
+export const ductSegmentDefinition = composeNodeDefinition(ductSegmentRenderDefinition, ductSegmentEditContribution);

package/dist/duct-segment/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { DuctSegmentNode } from './schema.js';
+export declare const ductSegmentRenderDefinition: NodeRenderDefinition<typeof DuctSegmentNode> & {
+    kind: 'duct-segment';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/duct-segment/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/duct-segment/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAAC,GAAG;IACvF,IAAI,EAAE,cAAc,CAAA;CAwFrB,CAAA"}

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

@@ -0,0 +1,89 @@
+import { ductBodySlots } from '@pascal-app/core';
+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,
+            },
+        ];
+    },
+    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"}