@pascal-app/core 1.0.6 → 1.0.7

package/dist/agent-tools/wall-openings.d.ts

@@ -1,4 +1,18 @@
 import { z } from 'zod';
+export declare const doorDetailFields: {
+    sidelightLeft: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    sidelightRight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    transomHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    leafCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>]>>;
+    slidingStyle: z.ZodOptional<z.ZodEnum<{
+        bypass: "bypass";
+        patio: "patio";
+    }>>;
+    slideDirection: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+};
 export declare const addDoorTool: {
     name: string;
     title: string;
@@ -24,10 +38,23 @@ export declare const addDoorTool: {
         }>>;
         archHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         cornerRadius: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        sidelightLeft: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        sidelightRight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        transomHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        leafCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>]>>;
+        slidingStyle: z.ZodOptional<z.ZodEnum<{
+            bypass: "bypass";
+            patio: "patio";
+        }>>;
+        slideDirection: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
         wallId: z.ZodOptional<z.ZodString>;
         nodeId: z.ZodOptional<z.ZodString>;
         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>>>;
+        sillHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         openingKind: z.ZodOptional<z.ZodEnum<{
             door: "door";
             opening: "opening";
@@ -36,6 +63,13 @@ export declare const addDoorTool: {
             left: "left";
             right: "right";
         }>>;
+        handleStyle: z.ZodOptional<z.ZodEnum<{
+            bar: "bar";
+            knob: "knob";
+            lever: "lever";
+            "lever-curved": "lever-curved";
+            plate: "plate";
+        }>>;
         handleSide: z.ZodOptional<z.ZodEnum<{
             left: "left";
             right: "right";
@@ -70,6 +104,50 @@ export declare const addDoorTool: {
         }>>;
     };
 };
+/** Native window details shared by every window authoring contract. */
+export declare const windowDetailFields: {
+    hingesSide: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    openingDirection: z.ZodOptional<z.ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+    tiltTurnMode: z.ZodOptional<z.ZodEnum<{
+        tilt: "tilt";
+        turn: "turn";
+    }>>;
+    rollerShutter: z.ZodOptional<z.ZodEnum<{
+        box: "box";
+        concealed: "concealed";
+        none: "none";
+    }>>;
+    rollerShutterBoxHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    rollerShutterOpen: z.ZodOptional<z.ZodNumber>;
+    shutterOpen: z.ZodOptional<z.ZodNumber>;
+    shutterSides: z.ZodOptional<z.ZodEnum<{
+        both: "both";
+        left: "left";
+        right: "right";
+    }>>;
+    sillOverhang: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    sillInteriorDepth: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    sillInteriorThickness: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    sillInteriorOverhang: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    columns: z.ZodOptional<z.ZodNumber>;
+    rows: z.ZodOptional<z.ZodNumber>;
+    windowHandle: z.ZodOptional<z.ZodBoolean>;
+    sashGrid: z.ZodOptional<z.ZodBoolean>;
+    sillInterior: z.ZodOptional<z.ZodBoolean>;
+    shutters: z.ZodOptional<z.ZodEnum<{
+        "board-batten": "board-batten";
+        louvered: "louvered";
+        none: "none";
+        panel: "panel";
+    }>>;
+    shutterWidth: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+};
 export declare const addWindowTool: {
     name: string;
     title: string;
@@ -95,6 +173,47 @@ export declare const addWindowTool: {
         }>>;
         archHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         cornerRadius: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        hingesSide: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
+        openingDirection: z.ZodOptional<z.ZodEnum<{
+            inward: "inward";
+            outward: "outward";
+        }>>;
+        tiltTurnMode: z.ZodOptional<z.ZodEnum<{
+            tilt: "tilt";
+            turn: "turn";
+        }>>;
+        rollerShutter: z.ZodOptional<z.ZodEnum<{
+            box: "box";
+            concealed: "concealed";
+            none: "none";
+        }>>;
+        rollerShutterBoxHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        rollerShutterOpen: z.ZodOptional<z.ZodNumber>;
+        shutterOpen: z.ZodOptional<z.ZodNumber>;
+        shutterSides: z.ZodOptional<z.ZodEnum<{
+            both: "both";
+            left: "left";
+            right: "right";
+        }>>;
+        sillOverhang: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        sillInteriorDepth: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        sillInteriorThickness: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        sillInteriorOverhang: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        columns: z.ZodOptional<z.ZodNumber>;
+        rows: z.ZodOptional<z.ZodNumber>;
+        windowHandle: z.ZodOptional<z.ZodBoolean>;
+        sashGrid: z.ZodOptional<z.ZodBoolean>;
+        sillInterior: z.ZodOptional<z.ZodBoolean>;
+        shutters: z.ZodOptional<z.ZodEnum<{
+            "board-batten": "board-batten";
+            louvered: "louvered";
+            none: "none";
+            panel: "panel";
+        }>>;
+        shutterWidth: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         wallId: z.ZodOptional<z.ZodString>;
         nodeId: z.ZodOptional<z.ZodString>;
         width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
@@ -111,9 +230,8 @@ export declare const addWindowTool: {
             louvered: "louvered";
             "single-hung": "single-hung";
             sliding: "sliding";
+            "tilt-turn": "tilt-turn";
         }>>;
-        columns: z.ZodOptional<z.ZodNumber>;
-        rows: z.ZodOptional<z.ZodNumber>;
         style: z.ZodOptional<z.ZodEnum<{
             casement: "casement";
             "double-hung": "double-hung";
@@ -145,6 +263,7 @@ export declare const addDoorOutput: {
         unchanged: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>;
     doorId: z.ZodString;
+    sillHeight: z.ZodOptional<z.ZodNumber>;
 };
 export declare const addWindowOutput: {
     ok: z.ZodLiteral<true>;

package/dist/agent-tools/wall-openings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-openings.d.ts","sourceRoot":"","sources":["../../src/agent-tools/wall-openings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwDvB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDzB,CAAA;AAkBD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAA2C,CAAA;AAErE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAI3B,CAAA"}
+{"version":3,"file":"wall-openings.d.ts","sourceRoot":"","sources":["../../src/agent-tools/wall-openings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwDvB,eAAO,MAAM,gBAAgB;IAC3B,aAAa;IAIb,cAAc;IAId,aAAa;IAKb,SAAS;IAIT,YAAY;;;;IAIZ,cAAc;;;;CACf,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDvB,CAAA;AAED,uEAAuE;AACvE,eAAO,MAAM,kBAAkB;IAC7B,UAAU;;;;IAIV,gBAAgB;;;;IAMhB,YAAY;;;;IAMZ,aAAa;;;;;IAMb,sBAAsB;IAItB,iBAAiB;IAQjB,WAAW;IAQX,YAAY;;;;;IAIZ,YAAY;IAIZ,iBAAiB;IAIjB,qBAAqB;IAIrB,oBAAoB;IAIpB,OAAO;IASP,IAAI;IASJ,YAAY;IACZ,QAAQ;IAIR,YAAY;IAIZ,QAAQ;;;;;;IAMR,YAAY;CAKb,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCzB,CAAA;AAkBD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;CAIzB,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAI3B,CAAA"}

package/dist/agent-tools/wall-openings.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { DOOR_STYLES, WINDOW_STYLES } from '../building/opening-style-presets.js';
 import { geometryMetaFields } from '../schema/geometry-metadata.js';
-import { DoorType, WindowType } from '../schema/nodes/opening-types.js';
+import { DoorHandleStyle, DoorType, WindowType } from '../schema/nodes/opening-types.js';
 import { achievedOutput } from './achieved.js';
 import { scriptLanguage, scriptParams } from './add-object.js';
 import { measurement } from './measurement.js';
@@ -44,14 +44,38 @@ const outline = (archDefault) => ({
         description: 'Radius of the rounded top corners (rounded only; default 0.15 m).',
     }).optional(),
 });
+export const doorDetailFields = {
+    sidelightLeft: measurement('length', 'm', {
+        min: 0,
+        description: 'Fixed glazed light left of a swing leaf, metres; absent or 0 means none.',
+    }).optional(),
+    sidelightRight: measurement('length', 'm', {
+        min: 0,
+        description: 'Fixed glazed light right of a swing leaf, metres; absent or 0 means none.',
+    }).optional(),
+    transomHeight: measurement('length', 'm', {
+        min: 0,
+        description: 'Fixed light above a swing door and its sidelights, metres; absent or 0 means none. The full cutout must fit under the wall top (wall_too_low).',
+    }).optional(),
+    leafCount: z
+        .union([z.literal(1), z.literal(2), z.literal(3), z.literal(4), z.literal(6), z.literal(8)])
+        .optional()
+        .describe('Panel count: sliding 2–4; folding 2, 4, 6 or 8.'),
+    slidingStyle: z
+        .enum(['patio', 'bypass'])
+        .optional()
+        .describe('Sliding family: patio (default) or two-track bypass closet.'),
+    slideDirection: z.enum(['left', 'right']).optional(),
+};
 export const addDoorTool = {
     name: 'add_door',
     title: 'Add door',
-    description: 'Add a door to an existing straight wall at t (0..1 along it), or a passage with no leaf (openingKind opening: a cased opening, an arch). The door slides to stay on the wall and reports clamped. Refused with a code, as in the editor: curved walls, walls shorter than the door, and overlapping another door, window or wall item unless force is set. Match the reference with the outline (rectangle, rounded, arch), doorType and style; what they cannot express (glass strips, a pattern of lites, carved panels) is written as a script in code, never left as not possible.',
+    description: 'Add a door to an existing straight wall at t (0..1 along it), or a passage with no leaf (openingKind opening: a cased opening, an arch). The door slides to stay on the wall and reports clamped. On a railing (wallType railing) it is a gap in the guard as tall as the railing, with no leaf, casing or threshold. Refused with a code, as in the editor: curved walls, walls shorter than the door, and overlapping another door, window or wall item unless force is set. Match the reference with the outline (rectangle, rounded, arch), doorType and style; what they cannot express (glass strips, a pattern of lites, carved panels) is written as a script in code, never left as not possible. Not available in run_batch: the host opening executor prepares scripted creation and rebuilds, which a batch does not prepare.',
     input: {
         wallId: NodeId.optional().describe('The wall to add the door to.'),
         nodeId: NodeId.optional().describe('Rebuild this door instead of adding one: new code and/or params (get_source provides current code when needed). Its native fields change with update_node.'),
         ...placement,
+        ...doorDetailFields,
         width: measurement('length', 'm', {
             positive: true,
             description: 'Door width (default 0.9 m).',
@@ -60,11 +84,15 @@ export const addDoorTool = {
             positive: true,
             description: 'Door height (default 2.1 m).',
         }).optional(),
+        sillHeight: measurement('length', 'm', {
+            description: "Rarely needed: the door's bottom above the floor the wall stands on (default 0, on the floor). Negative reaches below that floor, down to the wall's bottom, where the wall goes down beside a floor sunk under it (a garage below the house, a step in the terrain): a garage door filling its doorway down to the garage floor. It stays between the wall's bottom and its ceiling, and reports clamped.",
+        }).optional(),
         openingKind: z
             .enum(['door', 'opening'])
             .optional()
             .describe("door (default), or opening: a passage with no leaf, framed or arched by the outline, as the editor's door panel offers."),
         hingesSide: z.enum(['left', 'right']).optional().describe('Hinge side (default left).'),
+        handleStyle: DoorHandleStyle.optional().describe('Door handle: lever (default), lever-curved, knob, bar, or plate.'),
         handleSide: z
             .enum(['left', 'right'])
             .optional()
@@ -82,10 +110,96 @@ export const addDoorTool = {
             .describe('Visual preset (panels only, never the size); same presets as create_room doors[].'),
     },
 };
+/** Native window details shared by every window authoring contract. */
+export const windowDetailFields = {
+    hingesSide: z
+        .enum(['left', 'right'])
+        .optional()
+        .describe('Casement or tilt-turn side hinges (default left).'),
+    openingDirection: z
+        .enum(['outward', 'inward'])
+        .optional()
+        .describe('Casement or awning swing toward exterior or interior, independent of placement (new windows default outward). Ignored by hopper and tilt-turn, which open inward.'),
+    tiltTurnMode: z
+        .enum(['tilt', 'turn'])
+        .optional()
+        .describe('Tilt-turn only: tilt inward about the bottom up to 15 degrees (default), or turn inward about the side hinges up to 90 degrees.'),
+    rollerShutter: z
+        .enum(['none', 'box', 'concealed'])
+        .optional()
+        .describe('Roller mount (default none): box on the exterior face above the opening, or concealed with a 0.03 m lintel strip and 0.025 x 0.03 m guides inside the reveal. Concealed curtain sits 0.02 m outside the frame plane, width minus 0.05 m.'),
+    rollerShutterBoxHeight: measurement('length', 'm', {
+        positive: true,
+        description: 'Exterior roller box height (default 0.18 m); used only by the box mount.',
+    }).optional(),
+    rollerShutterOpen: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe('Static roller curtain position: 0 down, 1 fully up (default 1), independent of operationState.'),
+    shutterOpen: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe('Exterior shutter position: 0 closed over the window, 1 open (default 1). Leaves over 0.75 m fold into two stacked halves; narrower leaves open flat against the wall.'),
+    shutterSides: z
+        .enum(['both', 'left', 'right'])
+        .optional()
+        .describe('Which exterior shutter leaves to build (default both).'),
+    sillOverhang: measurement('length', 'm', {
+        min: 0,
+        description: 'Exterior sill extension on each side; default 0.4 times sillDepth.',
+    }).optional(),
+    sillInteriorDepth: measurement('length', 'm', {
+        positive: true,
+        description: 'Interior stool depth (default 0.06 m).',
+    }).optional(),
+    sillInteriorThickness: measurement('length', 'm', {
+        positive: true,
+        description: 'Interior stool thickness (default 0.03 m).',
+    }).optional(),
+    sillInteriorOverhang: measurement('length', 'm', {
+        min: 0,
+        description: 'Interior stool extension beyond casing on each side (default 0.015 m).',
+    }).optional(),
+    columns: z
+        .number()
+        .int()
+        .min(1)
+        .max(12)
+        .optional()
+        .describe("Panes across each operable sash (the whole fixed window), equal widths; overrides the style's panes."),
+    rows: z
+        .number()
+        .int()
+        .min(1)
+        .max(12)
+        .optional()
+        .describe("Panes up each operable sash (the whole fixed window), equal heights; overrides the style's panes."),
+    windowHandle: z.boolean().optional().describe('Show the interior sash handle (default true).'),
+    sashGrid: z
+        .boolean()
+        .optional()
+        .describe('Pane grid per operable sash (default false; columns or rows enable it).'),
+    sillInterior: z
+        .boolean()
+        .optional()
+        .describe('Add a stool board on the room side (default false).'),
+    shutters: z
+        .enum(['none', 'louvered', 'panel', 'board-batten'])
+        .optional()
+        .describe('Exterior shutters (default none), with a 10 mm overlap lip on one leaf when both sides are present.'),
+    shutterWidth: measurement('length', 'm', {
+        positive: true,
+        description: 'Width per side, uncapped: defaults to half the opening for both sides, full opening for left or right only. Widths over 0.75 m form a bifold pair of equal halves.',
+    }).optional(),
+};
 export const addWindowTool = {
     name: 'add_window',
     title: 'Add window',
-    description: "Add a window to an existing straight wall at t (0..1 along it), centred vertically on the wall, or on sillHeight above the floor when given. It slides to stay on the wall and under the wall's ceiling, and reports clamped. Refused with a code, as in the editor: curved walls, walls shorter than the window, overlapping another door, window or wall item unless force is set, and a style on a window that is not Fixed (style_needs_fixed_window). Match the reference with the outline (rectangle, rounded, arch), windowType and panes (columns × rows, or a style); what they cannot express (glass strips, leaded lites, a feature frame) is written as a script in code, never left as not possible.",
+    description: "Add a window to an existing straight wall at t (0..1 along it), centred vertically on the wall, or on sillHeight above the floor when given. It slides to stay on the wall and under the wall's ceiling, and reports clamped. Refused with a code, as in the editor: curved walls, railings (railing_window: a railing takes a door, a gap in its guard), walls shorter than the window, overlapping another door, window or wall item unless force is set, and a style on a window that is not Fixed (style_needs_fixed_window). Match the reference with the outline (rectangle, rounded, arch), windowType and panes (columns × rows, or a style); what they cannot express (glass strips, leaded lites, a feature frame) is written as a script in code, never left as not possible. Not available in run_batch: the host opening executor prepares scripted creation and rebuilds, which a batch does not prepare.",
     input: {
         wallId: NodeId.optional().describe('The wall to add the window to.'),
         nodeId: NodeId.optional().describe('Rebuild this window instead of adding one: new code and/or params (get_source provides current code when needed). Its native fields change with update_node.'),
@@ -105,20 +219,7 @@ export const addWindowTool = {
         ...outline('0.35 m'),
         ...script('window'),
         windowType: WindowType.optional().describe('How it opens (default fixed).'),
-        columns: z
-            .number()
-            .int()
-            .min(1)
-            .max(12)
-            .optional()
-            .describe("Panes across, equal widths; overrides the style's panes."),
-        rows: z
-            .number()
-            .int()
-            .min(1)
-            .max(12)
-            .optional()
-            .describe("Panes up, equal heights; overrides the style's panes."),
+        ...windowDetailFields,
         style: z
             .enum(WINDOW_STYLES)
             .optional()
@@ -140,7 +241,11 @@ const openingOutput = {
     message: z.string(),
     achieved: achievedOutput,
 };
-export const addDoorOutput = { doorId: z.string(), ...openingOutput };
+export const addDoorOutput = {
+    doorId: z.string(),
+    ...openingOutput,
+    sillHeight: z.number().optional(),
+};
 export const addWindowOutput = {
     windowId: z.string(),
     ...openingOutput,

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

@@ -13,9 +13,39 @@ export declare const addWallTool: {
         level: z.ZodOptional<z.ZodString>;
         start: z.ZodArray<z.ZodNumber>;
         end: z.ZodArray<z.ZodNumber>;
+        type: z.ZodOptional<z.ZodString>;
+        wallType: z.ZodOptional<z.ZodEnum<{
+            railing: "railing";
+            standard: "standard";
+        }>>;
+        railing: z.ZodOptional<z.ZodObject<{
+            style: z.ZodOptional<z.ZodEnum<{
+                balusters: "balusters";
+                boards: "boards";
+                cable: "cable";
+                glass: "glass";
+                metal: "metal";
+                "post-and-rail": "post-and-rail";
+            }>>;
+            postSpacing: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            postSize: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            infillSize: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            infillGap: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            bottomClearance: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            cap: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
         thickness: 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>>>;
         curveOffset: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     };
 };
+export declare const setWallTypeTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        wallIds: z.ZodArray<z.ZodString>;
+        type: z.ZodNullable<z.ZodString>;
+    };
+};
 //# sourceMappingURL=walls.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"walls.d.ts","sourceRoot":"","sources":["../../src/agent-tools/walls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;GAGG;AACH,eAAO,MAAM,uBAAuB,4FAGlC,CAAA;AAKF,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAwBvB,CAAA"}
+{"version":3,"file":"walls.d.ts","sourceRoot":"","sources":["../../src/agent-tools/walls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAavB;;;GAGG;AACH,eAAO,MAAM,uBAAuB,4FAGlC,CAAA;AAKF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwEvB,CAAA;AAED,eAAO,MAAM,eAAe;IAC1B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;QACP,IAAI;;CAEP,CAAA"}

package/dist/agent-tools/walls.js

@@ -2,6 +2,11 @@ import { z } from 'zod';
 import { FOUNDATION_BY_REGION_NOTE } from '../lib/foundation-construction.js';
 import { levelTarget } from './levels.js';
 import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+const wallTypeInput = z
+    .string()
+    .min(1)
+    .describe('Assembly type id from get_walls.wallTypes: a built-in preset or custom- project wall type. Copies its layers and total thickness in metres, overriding thickness. Unknown ids: unknown_wall_type.');
 /**
  * A wall's bend: a rounded corner could only be made with apply_patch, its sign documented
  * nowhere.
@@ -13,12 +18,50 @@ const planPoint = (end) => z.array(z.number()).length(2).describe(`[x, z] ${end}
 export const addWallTool = {
     name: 'add_wall',
     title: 'Add wall',
-    description: 'Add a single wall between two points on a level, straight or, with curveOffset, an arc. Refused with a code: a level that is not a storey (a declared roof level), and a wall shorter than 1 cm. On a level below grade, a wall against the ground (on the outline of the walls of the level) is a foundation wall, ' +
+    description: 'Add a single wall between two points on a level, straight or, with curveOffset, an arc. type applies a preset or project wall assembly including its thickness (unknown_wall_type for an unknown id). wallType railing builds the Build panel guard: default post-and-rail, 0.9144 m high, thickness from railing.postSize, no assembly or foundation. Its doors are gaps; windows refuse railing_window, skirting refuses railing_wall. railing settings on a standard wall refuse not_a_railing; type on a railing refuses railing_wall. Refused with a code: a level that is not a storey (a declared roof level), and a wall shorter than 1 cm. On a level below grade, a standard wall against the ground (on the outline of the walls of the level) is a foundation wall, ' +
         FOUNDATION_BY_REGION_NOTE +
         '; a partition inside the outline is an ordinary wall; the result says which.',
     input: {
         start: planPoint('start'),
         end: planPoint('end'),
+        type: wallTypeInput.optional(),
+        wallType: z
+            .enum(['standard', 'railing'])
+            .optional()
+            .describe('Wall kind (default standard). railing is an open guard with its own height and post-derived thickness.'),
+        railing: z
+            .object({
+            style: z
+                .enum(['balusters', 'post-and-rail', 'cable', 'boards', 'glass', 'metal'])
+                .optional()
+                .describe('Guard style (default post-and-rail); omitted member sizes use the style defaults from the Build panel.'),
+            postSpacing: measurement('length', 'm', {
+                positive: true,
+                description: 'Maximum post spacing on centre (default 1.8288 m).',
+            }).optional(),
+            postSize: measurement('length', 'm', {
+                positive: true,
+                description: 'Square post side; sets wall thickness, overriding thickness. Default 0.0889 m for wood styles, 0.0508 m cable, 0.0381 m glass/metal.',
+            }).optional(),
+            infillSize: measurement('length', 'm', {
+                positive: true,
+                description: 'Baluster/bar square side, cable diameter, board face height or glass thickness. Default by style: post-and-rail 0.0381, balusters 0.03175, cable 0.009525, boards 0.1397, glass 0.0127, metal 0.015875 m.',
+            }).optional(),
+            infillGap: measurement('length', 'm', {
+                min: 0,
+                description: 'Clear infill gap. Default 0.0889 m wood styles, 0.066675 m cable, 0 m glass, 0.09525 m metal.',
+            }).optional(),
+            bottomClearance: measurement('length', 'm', {
+                min: 0,
+                description: 'Clearance over the floor. Default 0.0889 m post-and-rail/boards, 0.05715 m balusters, 0.06985 m cable, 0.0762 m glass/metal.',
+            }).optional(),
+            cap: z
+                .boolean()
+                .optional()
+                .describe('2x6 top cap on post-and-rail/boards styles (default true).'),
+        })
+            .optional()
+            .describe('Railing settings, only with wallType railing. All lengths in metres; omitted fields follow the selected style.'),
         thickness: measurement('length', 'm', {
             positive: true,
             description: 'Wall thickness (default 0.1 m; a wall against the ground on a level below grade, given none, is a foundation wall ' +
@@ -27,9 +70,18 @@ export const addWallTool = {
         }).optional(),
         height: measurement('length', 'm', {
             positive: true,
-            description: "Wall height (default: the storey's height).",
+            description: "Wall height (default: the storey's height; a railing 0.9144 m / 36 in).",
         }).optional(),
         curveOffset: WALL_CURVE_OFFSET_INPUT.optional(),
         ...levelTarget,
     },
 };
+export const setWallTypeTool = {
+    name: 'set_wall_type',
+    title: 'Set wall type',
+    description: 'Apply an assembly type to existing standard walls, copying its layers and total thickness as the wall panel does. type null clears the assembly and keeps thickness. All walls change together. Refused with unknown_wall_type for an unknown type id, target_not_found for a missing wall, curtain_wall or railing_wall for walls that take no assembly.',
+    input: {
+        wallIds: z.array(NodeId).min(1),
+        type: wallTypeInput.nullable(),
+    },
+};