@pascal-app/nodes 1.0.6 → 1.1.0

package/README.md

@@ -8,12 +8,13 @@ Built-in node definitions for the Pascal viewer and editor.
 npm install @pascal-app/core @pascal-app/viewer @pascal-app/editor @pascal-app/nodes
 ```
 
-The package declares the remaining React, Next.js, Three.js, and UI libraries it needs as peer
-dependencies. Install any peers reported by your package manager.
+The full entry uses the editor and its Next.js and UI peers. Render-only hosts can omit
+`@pascal-app/editor` (an optional peer) and Next.js. Install the remaining React and Three.js peers
+reported by your package manager.
 
 ## Usage
 
-Load `builtinPlugin` once before mounting a Pascal viewer or editor:
+Editor hosts load `builtinPlugin` once before mounting:
 
 ```typescript
 import { loadPlugin } from '@pascal-app/core'
@@ -25,6 +26,19 @@ await loadPlugin(builtinPlugin)
 The plugin registers the built-in schemas, renderers, geometry builders, tools, and systems. Hosts
 can load additional plugins through the same `loadPlugin` API.
 
+For a render-only host, use the same plugin contract with all built-in kinds:
+
+```typescript
+import { loadPlugin } from '@pascal-app/core'
+import { renderPlugin } from '@pascal-app/nodes/render'
+
+await loadPlugin(renderPlugin)
+```
+
+Load exactly one built-in entry per runtime. Both use the `pascal:core` plugin id and API version 1;
+`renderPlugin` supplies schemas, geometry, renderers, systems and runtime interactions, while
+`builtinPlugin` also supplies tools, inspectors, paint and floor plans.
+
 See the
 [`@pascal-app/viewer` quick start](https://github.com/pascalorg/editor/tree/main/packages/viewer#usage)
 for bootstrap ordering in a React application.
@@ -33,20 +47,41 @@ for bootstrap ordering in a React application.
 
 MIT
 
-## Kitchen agent tools
+## Agent tools
 
 The built-in plugin exports `builtinAgentTools` from `@pascal-app/nodes/agent-tools`
 (zod-only contracts) and `builtinAgentOperations` from
-`@pascal-app/nodes/agent-operations` (headless planners). Both the inspector and
-agents execute the same finishing planner, including hosted-item support checks.
+`@pascal-app/nodes/agent-operations` (headless planners). The inspectors and
+agents execute the same planners, and each edit applies in one undo step. A
+refused edit changes nothing; each contract's description lists its refusal codes.
+
+Kitchen:
+
 - `kitchen_finish_run({ runId, action: 'align' | 'fill' })` aligns a run or closes
-  50–150 mm wall gaps. Results apply in one undo step. Missing runs and unsupported
-  hosted items return `cabinet_run_not_found` and `hosted_items_unsupported`.
+  50–150 mm wall gaps, including hosted-item support checks. Missing runs and
+  unsupported hosted items return `cabinet_run_not_found` and
+  `hosted_items_unsupported`.
 - `kitchen_check_clearance({ nodeId })` returns an advisory opening warning for a
   run or module. It shares the registry notice used during placement, movement,
   and inspection. It checks conservative envelopes against visible floor objects
   and straight walls; curved walls and wall openings are not resolved.
 
+Ductwork and plumbing keep connected collars joined:
+
+- `duct_edit({ nodeId, action: 'resize' | 'offset', ... })` resizes a duct segment
+  or same-profile branch (transitions where it stops; center alignment for
+  connected runs), or offsets a straight horizontal run around an obstacle with
+  four elbows while both endpoints stay fixed.
+- `pipe_grade({ nodeId, action: 'grade' | 'endpoint' | 'elevation', ... })` sets a
+  run's grade and flow direction, moves a path point while keeping each leg's
+  grade (`detach` leaves the connected runs in place), or changes its elevation.
+- `pipe_resize({ nodeId, diameter, scope? })` resizes a segment or same-size,
+  same-material branch and inserts reducers at its size boundaries.
+- `pipe_offset({ nodeId, from, to, offset })` adds four bends to a straight run,
+  keeping both boundary collars fixed and the parallel sections at grade.
+- `pipe_connect({ nodeId, portId, end, diameter? })` draws a pipe from an open
+  waste or vent collar to a free endpoint, with a reducer when the size differs.
+
 A host that installs the plugin registers its tools on its MCP server with
 `registerOperationTool`, the shared tools' runner, under its own reviewed
 annotations (see the MCP README's plugin tools). Load the plugin definitions into

package/dist/agent-operations/index.d.ts

@@ -1,6 +1,11 @@
 import { checkKitchenClearance, finishKitchenRun } from '../cabinet/finish-operation.js';
 export { checkKitchenClearance, finishKitchenRun };
 export declare const builtinAgentOperations: {
+    pipe_connect: import("@pascal-app/core/agent-operations").AgentOperation<import("../pipe-segment/connect-operation.js").PipeConnectInput>;
+    pipe_offset: import("@pascal-app/core/agent-operations").AgentOperation<import("../pipe-segment/offset-operation.js").PipeOffsetInput>;
+    pipe_resize: import("@pascal-app/core/agent-operations").AgentOperation<import("../pipe-segment/resize-operation.js").PipeResizeInput>;
+    pipe_grade: import("@pascal-app/core/agent-operations").AgentOperation<import("../pipe-segment/grade-operation.js").PipeGradeInput>;
+    duct_edit: import("@pascal-app/core/agent-operations").AgentOperation<import("../duct-segment/edit-operation.js").DuctEditInput>;
     kitchen_finish_run: import("@pascal-app/core/agent-operations").AgentOperation<{
         runId: string;
         action: 'align' | 'fill';

package/dist/agent-operations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-operations/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAErF,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,CAAA;AAClD,eAAO,MAAM,sBAAsB;;;;;;;;CAGR,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-operations/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAOrF,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,CAAA;AAClD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;CAQR,CAAA"}

package/dist/agent-operations/index.js

@@ -1,6 +1,16 @@
 import { checkKitchenClearance, finishKitchenRun } from '../cabinet/finish-operation.js';
+import { editDuct } from '../duct-segment/edit-operation.js';
+import { connectPipe } from '../pipe-segment/connect-operation.js';
+import { editPipeGrade } from '../pipe-segment/grade-operation.js';
+import { offsetPipe } from '../pipe-segment/offset-operation.js';
+import { resizePipe } from '../pipe-segment/resize-operation.js';
 export { checkKitchenClearance, finishKitchenRun };
 export const builtinAgentOperations = {
+    pipe_connect: connectPipe,
+    pipe_offset: offsetPipe,
+    pipe_resize: resizePipe,
+    pipe_grade: editPipeGrade,
+    duct_edit: editDuct,
     kitchen_finish_run: finishKitchenRun,
     kitchen_check_clearance: checkKitchenClearance,
 };

package/dist/agent-tools/index.d.ts

@@ -21,6 +21,106 @@ export declare const checkKitchenClearanceTool: {
     };
     runsIn: 'operation';
 };
+export declare const editDuctTool: {
+    name: 'duct_edit';
+    title: string;
+    description: string;
+    input: {
+        nodeId: z.ZodString;
+        action: z.ZodEnum<{
+            offset: "offset";
+            resize: "resize";
+        }>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            branch: "branch";
+            segment: "segment";
+        }>>;
+        alignment: z.ZodOptional<z.ZodEnum<{
+            bottom: "bottom";
+            center: "center";
+            left: "left";
+            right: "right";
+            top: "top";
+        }>>;
+        shape: z.ZodOptional<z.ZodEnum<{
+            oval: "oval";
+            rect: "rect";
+            round: "round";
+        }>>;
+        diameter: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        offset: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        from: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        to: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    };
+    runsIn: 'operation';
+};
+export declare const pipeGradeTool: {
+    name: 'pipe_grade';
+    title: string;
+    description: string;
+    input: {
+        nodeId: z.ZodString;
+        action: z.ZodEnum<{
+            elevation: "elevation";
+            endpoint: "endpoint";
+            grade: "grade";
+        }>;
+        detach: z.ZodOptional<z.ZodBoolean>;
+        gradePercent: z.ZodOptional<z.ZodNumber>;
+        flow: z.ZodOptional<z.ZodEnum<{
+            forward: "forward";
+            reverse: "reverse";
+        }>>;
+        anchor: z.ZodOptional<z.ZodEnum<{
+            end: "end";
+            start: "start";
+        }>>;
+        pointIndex: z.ZodOptional<z.ZodNumber>;
+        point: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        elevation: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    };
+    runsIn: 'operation';
+};
+export declare const pipeResizeTool: {
+    name: 'pipe_resize';
+    title: string;
+    description: string;
+    input: {
+        nodeId: z.ZodString;
+        diameter: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            branch: "branch";
+            segment: "segment";
+        }>>;
+    };
+    runsIn: 'operation';
+};
+export declare const pipeOffsetTool: {
+    name: 'pipe_offset';
+    title: string;
+    description: string;
+    input: {
+        nodeId: z.ZodString;
+        from: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+        to: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+        offset: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+    };
+    runsIn: 'operation';
+};
+export declare const pipeConnectTool: {
+    name: 'pipe_connect';
+    title: string;
+    description: string;
+    input: {
+        nodeId: z.ZodString;
+        portId: z.ZodString;
+        end: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        diameter: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    };
+    runsIn: 'operation';
+};
 export declare const builtinAgentTools: {
     pluginId: string;
     apiVersion: 1;
@@ -45,6 +145,101 @@ export declare const builtinAgentTools: {
             nodeId: z.ZodString;
         };
         runsIn: 'operation';
+    } | {
+        name: 'duct_edit';
+        title: string;
+        description: string;
+        input: {
+            nodeId: z.ZodString;
+            action: z.ZodEnum<{
+                offset: "offset";
+                resize: "resize";
+            }>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                branch: "branch";
+                segment: "segment";
+            }>>;
+            alignment: z.ZodOptional<z.ZodEnum<{
+                bottom: "bottom";
+                center: "center";
+                left: "left";
+                right: "right";
+                top: "top";
+            }>>;
+            shape: z.ZodOptional<z.ZodEnum<{
+                oval: "oval";
+                rect: "rect";
+                round: "round";
+            }>>;
+            diameter: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            height: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            offset: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            from: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            to: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        };
+        runsIn: 'operation';
+    } | {
+        name: 'pipe_grade';
+        title: string;
+        description: string;
+        input: {
+            nodeId: z.ZodString;
+            action: z.ZodEnum<{
+                elevation: "elevation";
+                endpoint: "endpoint";
+                grade: "grade";
+            }>;
+            detach: z.ZodOptional<z.ZodBoolean>;
+            gradePercent: z.ZodOptional<z.ZodNumber>;
+            flow: z.ZodOptional<z.ZodEnum<{
+                forward: "forward";
+                reverse: "reverse";
+            }>>;
+            anchor: z.ZodOptional<z.ZodEnum<{
+                end: "end";
+                start: "start";
+            }>>;
+            pointIndex: z.ZodOptional<z.ZodNumber>;
+            point: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            elevation: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        };
+        runsIn: 'operation';
+    } | {
+        name: 'pipe_resize';
+        title: string;
+        description: string;
+        input: {
+            nodeId: z.ZodString;
+            diameter: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                branch: "branch";
+                segment: "segment";
+            }>>;
+        };
+        runsIn: 'operation';
+    } | {
+        name: 'pipe_offset';
+        title: string;
+        description: string;
+        input: {
+            nodeId: z.ZodString;
+            from: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+            to: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+            offset: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+        };
+        runsIn: 'operation';
+    } | {
+        name: 'pipe_connect';
+        title: string;
+        description: string;
+        input: {
+            nodeId: z.ZodString;
+            portId: z.ZodString;
+            end: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            diameter: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        };
+        runsIn: 'operation';
     })[];
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/agent-tools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-tools/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,oBAAoB;IAC/B,IAAI,EAAE,oBAAoB;IAC1B,KAAK;IACL,WAAW;IAEX,KAAK;QAAI,KAAK;QAAc,MAAM;;;;;IAClC,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,yBAAyB;IACpC,IAAI,EAAE,yBAAyB;IAC/B,KAAK;IACL,WAAW;IAEX,KAAK;QAAI,MAAM;;IACf,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,iBAAiB;;;;;cAftB,oBAAoB;;;;YAIjB,KAAK;YAAc,MAAM;;;;;gBAC1B,WAAW;;cAGb,yBAAyB;;;;YAItB,MAAM;;gBACP,WAAW;;CAOO,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-tools/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,oBAAoB;IAC/B,IAAI,EAAE,oBAAoB;IAC1B,KAAK;IACL,WAAW;IAEX,KAAK;QAAI,KAAK;QAAc,MAAM;;;;;IAClC,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,yBAAyB;IACpC,IAAI,EAAE,yBAAyB;IAC/B,KAAK;IACL,WAAW;IAEX,KAAK;QAAI,MAAM;;IACf,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,YAAY;IACvB,IAAI,EAAE,WAAW;IACjB,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;QACN,MAAM;;;;QACN,KAAK;;;;QACL,SAAS;;;;;;;QACT,KAAK;;;;;QACL,QAAQ;QACR,KAAK;QACL,MAAM;QACN,MAAM;QACN,IAAI;QACJ,EAAE;;IAEJ,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,aAAa;IACxB,IAAI,EAAE,YAAY;IAClB,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;QACN,MAAM;;;;;QACN,MAAM;QACN,YAAY;QACZ,IAAI;;;;QACJ,MAAM;;;;QACN,UAAU;QACV,KAAK;QACL,SAAS;;IAEX,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,cAAc;IACzB,IAAI,EAAE,aAAa;IACnB,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;QACN,QAAQ;QACR,KAAK;;;;;IAEP,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,cAAc;IACzB,IAAI,EAAE,aAAa;IACnB,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;QACN,IAAI;QACJ,EAAE;QACF,MAAM;;IAER,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,eAAe;IAC1B,IAAI,EAAE,cAAc;IACpB,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;QACN,MAAM;QACN,GAAG;QACH,QAAQ;;IAEV,MAAM,EAAE,WAAW;CACpB,CAAA;AACD,eAAO,MAAM,iBAAiB;;;;;cA3FtB,oBAAoB;;;;YAIjB,KAAK;YAAc,MAAM;;;;;gBAC1B,WAAW;;cAGb,yBAAyB;;;;YAItB,MAAM;;gBACP,WAAW;;cAGb,WAAW;;;;YAKf,MAAM;YACN,MAAM;;;;YACN,KAAK;;;;YACL,SAAS;;;;;;;YACT,KAAK;;;;;YACL,QAAQ;YACR,KAAK;YACL,MAAM;YACN,MAAM;YACN,IAAI;YACJ,EAAE;;gBAEI,WAAW;;cAGb,YAAY;;;;YAKhB,MAAM;YACN,MAAM;;;;;YACN,MAAM;YACN,YAAY;YACZ,IAAI;;;;YACJ,MAAM;;;;YACN,UAAU;YACV,KAAK;YACL,SAAS;;gBAEH,WAAW;;cAGb,aAAa;;;;YAKjB,MAAM;YACN,QAAQ;YACR,KAAK;;;;;gBAEC,WAAW;;cAGb,aAAa;;;;YAKjB,MAAM;YACN,IAAI;YACJ,EAAE;YACF,MAAM;;gBAEA,WAAW;;cAGb,cAAc;;;;YAKlB,MAAM;YACN,MAAM;YACN,GAAG;YACH,QAAQ;;gBAEF,WAAW;;CAeO,CAAA"}

package/dist/agent-tools/index.js

@@ -1,3 +1,4 @@
+import { measurement } from '@pascal-app/core/agent-tools';
 import { z } from 'zod';
 export const finishKitchenRunTool = {
     name: 'kitchen_finish_run',
@@ -13,9 +14,88 @@ export const checkKitchenClearanceTool = {
     input: { nodeId: z.string() },
     runsIn: 'operation',
 };
+export const editDuctTool = {
+    name: 'duct_edit',
+    title: 'Resize or offset duct',
+    description: "Resize a duct segment or branch, or offset a straight horizontal run around an obstacle with four elbows, keeping connected collars joined. resize: scope defaults to segment; branch follows the same profile through elbows, couplings, dampers and caps, stopping at junctions, profile changes and equipment. Transitions are inserted at the fixed collars where the resize stops. shape, diameter, width and height default to the run's current values. alignment defaults to center, which supports connected runs; top, bottom, left and right need a free straight run. offset: from and to are the first and last bend positions in metres from the start, and offset is the signed vertical displacement in metres; all three are required, and both original endpoints stay fixed. Does not detect obstacles: check clearance. Refuses duct_not_found, node_capability_unavailable, duct_profile_invalid, duct_alignment_anchored, duct_connection_ambiguous, duct_clearance, duct_offset_route, duct_offset_roll, duct_offset_attachments, duct_offset_clearance or duct_offset_angle without partial edits. One undo step.",
+    input: {
+        nodeId: z.string(),
+        action: z.enum(['resize', 'offset']),
+        scope: z.enum(['segment', 'branch']).optional(),
+        alignment: z.enum(['center', 'top', 'bottom', 'left', 'right']).optional(),
+        shape: z.enum(['round', 'rect', 'oval']).optional(),
+        diameter: measurement('length', 'in').optional(),
+        width: measurement('length', 'in').optional(),
+        height: measurement('length', 'in').optional(),
+        offset: measurement('length', 'm').optional(),
+        from: measurement('length', 'm').optional(),
+        to: measurement('length', 'm').optional(),
+    },
+    runsIn: 'operation',
+};
+export const pipeGradeTool = {
+    name: 'pipe_grade',
+    title: 'Edit pipe grade and elevation',
+    description: "Set a pipe run's grade or flow direction, move one of its path points, or change its elevation, keeping connected pipes and fittings joined. grade: gradePercent is the percent fall over horizontal travel; flow defaults to forward (falling from start to end), and reverse falls toward the start; anchor defaults to start, the end that keeps its elevation. endpoint: moves path point pointIndex to point, a numeric [x, y, z] tuple in level-local metres (not a unit-bearing length string), preserving each existing leg grade; connected runs and end caps follow unless detach is true (default false), which leaves them in place. elevation: sets the anchor end (default start) to elevation above the level and translates the whole run without changing grades. Vertical legs keep their rise. Refuses pipe_not_found, node_capability_unavailable, pipe_grade_invalid, pipe_elevation_invalid, pipe_endpoint_invalid, pipe_grade_conflict, pipe_connection_angle, pipe_connection_split, pipe_connected_grade or pipe_fixed_connection without partial edits. One undo step.",
+    input: {
+        nodeId: z.string(),
+        action: z.enum(['grade', 'endpoint', 'elevation']),
+        detach: z.boolean().optional(),
+        gradePercent: z.number().finite().nonnegative().optional(),
+        flow: z.enum(['forward', 'reverse']).optional(),
+        anchor: z.enum(['start', 'end']).optional(),
+        pointIndex: z.number().int().nonnegative().optional(),
+        point: z.tuple([z.number().finite(), z.number().finite(), z.number().finite()]).optional(),
+        elevation: measurement('length', 'm').optional(),
+    },
+    runsIn: 'operation',
+};
+export const pipeResizeTool = {
+    name: 'pipe_resize',
+    title: 'Resize connected pipe',
+    description: "Resize a pipe segment or its same-size, same-material branch, inserting reducers at size boundaries while keeping each leg's grade. scope defaults to segment; branch continues through elbows, couplings and cleanouts, stopping at junctions, reducers and fixed fixture or equipment collars. Caps are resized with the run; the same size is a no-op. Refuses pipe_not_found, node_capability_unavailable, pipe_size_invalid, pipe_ambiguous_connection, pipe_connection_angle, pipe_resize_space or pipe_resize_grade without partial edits. One undo step.",
+    input: {
+        nodeId: z.string(),
+        diameter: measurement('length', 'in', { min: 1.25, max: 8 }),
+        scope: z.enum(['segment', 'branch']).optional(),
+    },
+    runsIn: 'operation',
+};
+export const pipeOffsetTool = {
+    name: 'pipe_offset',
+    title: 'Offset pipe around obstacle',
+    description: 'Offset a straight, non-vertical pipe run around an obstacle with four bends, keeping both boundary collars fixed and the parallel sections at their grade. from and to are horizontal distances in metres from the start to the first and last bend; offset is the signed vertical displacement in metres. Each connector consumes abs(offset) of horizontal travel. Reports uphill waste connectors as warnings; this is geometric routing, not drainage or obstacle-clearance validation. Refuses pipe_not_found, node_capability_unavailable, pipe_offset_route, pipe_offset_attachments, pipe_offset_space, pipe_offset_angle or pipe_offset_grade without partial edits. One undo step.',
+    input: {
+        nodeId: z.string(),
+        from: measurement('length', 'm'),
+        to: measurement('length', 'm'),
+        offset: measurement('length', 'm'),
+    },
+    runsIn: 'operation',
+};
+export const pipeConnectTool = {
+    name: 'pipe_connect',
+    title: 'Connect a pipe to a fixed collar',
+    description: "Draw a new pipe from an open waste or vent collar of a fixture, trap or fitting to a free endpoint, inheriting the collar's size, material and system. portId names the collar on nodeId; end is a numeric [x, y, z] tuple in level-local metres, not a unit-bearing length string. The first section must leave straight along the collar direction; add further bends from the new pipe. diameter defaults to the collar's; a different diameter inserts a reducer without moving the source. Ordinary catalog models without authored ports are unsupported. Refuses pipe_collar_missing, pipe_collar_changed, pipe_collar_system, pipe_collar_occupied, pipe_collar_direction, pipe_collar_space, pipe_endpoint_invalid, pipe_endpoint_occupied or pipe_size_invalid without partial edits. One undo step.",
+    input: {
+        nodeId: z.string(),
+        portId: z.string(),
+        end: z.tuple([z.number().finite(), z.number().finite(), z.number().finite()]),
+        diameter: measurement('length', 'in', { min: 1.25, max: 8 }).optional(),
+    },
+    runsIn: 'operation',
+};
 export const builtinAgentTools = {
     pluginId: 'pascal:core',
     apiVersion: 1,
-    version: '1.0.0',
-    tools: [finishKitchenRunTool, checkKitchenClearanceTool],
+    version: '1.1.2',
+    tools: [
+        finishKitchenRunTool,
+        checkKitchenClearanceTool,
+        editDuctTool,
+        pipeGradeTool,
+        pipeResizeTool,
+        pipeOffsetTool,
+        pipeConnectTool,
+    ],
 };

package/dist/beam/actions/move-endpoint.d.ts

@@ -0,0 +1,24 @@
+import { type AnyNodeId, type DragAction } from '@pascal-app/core';
+import { type WallPlanPoint } from '@pascal-app/editor';
+export type MoveBeamEndpointCtx = {
+    beamId: AnyNodeId;
+    endpoint: 'start' | 'end';
+    levelId: string | null;
+    /** The end that stays put. */
+    fixed: WallPlanPoint;
+};
+export type MoveBeamEndpointDraft = {
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+};
+/**
+ * A beam's end dragged in 3D, as a pure drag action:
+ *  - **preview**: the pointer snapped as the beam tool snaps (wall faces and ends, other beams,
+ *    post centres, the grid), angle-stepped off the end that stays; Alt places it freely.
+ *  - **apply**: writes the ends into the scene while history is paused.
+ *  - **commit**: refuses a beam too short to draw; otherwise reverts, resumes history and writes
+ *    the final ends once, so the drag is one undo step.
+ *  - **cancel**: `createDragSession` restores the beam it touched.
+ */
+export declare const moveBeamEndpointDragAction: DragAction<MoveBeamEndpointCtx, MoveBeamEndpointDraft>;
+//# sourceMappingURL=move-endpoint.d.ts.map

package/dist/beam/actions/move-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-endpoint.d.ts","sourceRoot":"","sources":["../../../src/beam/actions/move-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,UAAU,EAEhB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAG5E,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,SAAS,CAAA;IACjB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;IACzB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,8BAA8B;IAC9B,KAAK,EAAE,aAAa,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,GAAG,EAAE,aAAa,CAAA;CAAE,CAAA;AAEhF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,UAAU,CAAC,mBAAmB,EAAE,qBAAqB,CA2C7F,CAAA"}

package/dist/beam/actions/move-endpoint.js

@@ -0,0 +1,54 @@
+import { useScene, } from '@pascal-app/core';
+import { isSegmentLongEnough } from '@pascal-app/editor';
+import { snapBeamPoint } from '../drafting.js';
+/**
+ * A beam's end dragged in 3D, as a pure drag action:
+ *  - **preview**: the pointer snapped as the beam tool snaps (wall faces and ends, other beams,
+ *    post centres, the grid), angle-stepped off the end that stays; Alt places it freely.
+ *  - **apply**: writes the ends into the scene while history is paused.
+ *  - **commit**: refuses a beam too short to draw; otherwise reverts, resumes history and writes
+ *    the final ends once, so the drag is one undo step.
+ *  - **cancel**: `createDragSession` restores the beam it touched.
+ */
+export const moveBeamEndpointDragAction = {
+    begin: (input) => {
+        const beam = input.node;
+        if (beam?.type !== 'beam')
+            throw new Error('[moveBeamEndpointDragAction] begin requires a beam');
+        const endpoint = input.handleId === 'start' ? 'start' : 'end';
+        return {
+            beamId: beam.id,
+            endpoint,
+            levelId: beam.parentId ?? null,
+            fixed: endpoint === 'start' ? [beam.end[0], beam.end[1]] : [beam.start[0], beam.start[1]],
+        };
+    },
+    preview: (ctx, point, modifiers) => {
+        const moved = ctx.levelId
+            ? snapBeamPoint({
+                point: [point[0], point[1]],
+                nodes: useScene.getState().nodes,
+                levelId: ctx.levelId,
+                start: ctx.fixed,
+                ignoreIds: [ctx.beamId],
+                free: modifiers.alt,
+            }).point
+            : [point[0], point[1]];
+        return ctx.endpoint === 'start'
+            ? { start: moved, end: ctx.fixed }
+            : { start: ctx.fixed, end: moved };
+    },
+    apply: (draft, ctx, scene) => {
+        scene.update(ctx.beamId, { start: draft.start, end: draft.end });
+        return [ctx.beamId];
+    },
+    commit: (draft, ctx, scene) => {
+        if (!(draft && isSegmentLongEnough(draft.start, draft.end)))
+            return false;
+        scene.restoreAll();
+        scene.resumeHistory();
+        scene.update(ctx.beamId, { start: draft.start, end: draft.end });
+        return true;
+    },
+    cancel: () => { },
+};

package/dist/beam/definition.d.ts

@@ -0,0 +1,65 @@
+export declare const beamDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`beam_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"beam">>;
+    start: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+    end: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    size: import("zod").ZodOptional<import("zod").ZodString>;
+    plies: import("zod").ZodDefault<import("zod").ZodNumber>;
+    material: import("zod").ZodDefault<import("zod").ZodEnum<{
+        glulam: "glulam";
+        lvl: "lvl";
+        "pressure-treated": "pressure-treated";
+        sawn: "sawn";
+        steel: "steel";
+    }>>;
+    placement: import("zod").ZodDefault<import("zod").ZodEnum<{
+        dropped: "dropped";
+        flush: "flush";
+    }>>;
+    topElevation: import("zod").ZodOptional<import("zod").ZodNumber>;
+    supportSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/beam/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/beam/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAoE,CAAA"}

package/dist/beam/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { BeamNode } from './schema.js';
+export declare const beamEditContribution: NodeEditContribution<typeof BeamNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/beam/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/beam/definition.edit.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAOvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAyGxC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CA6BtE,CAAA"}