@pascal-app/core 1.0.4 → 1.0.6

package/dist/agent-tools/verify-scene.js

@@ -8,7 +8,7 @@ const extensions = [];
 export function extendVerifyScene(extension) {
     extensions.push(extension);
 }
-const DESCRIPTION = 'Check the whole scene after complex edits, and before retrying a failed tool: per-level content and roles (storey, roof-only, support), then every problem found, each with a type: empty levels, walls with no room or door, rooms with no floor or ceiling, storeys with no stair, roof levels misused, openings off their wall, stairs off their slab or blocked, furniture blocking a door or overlapping, nodes their schema rejects.';
+const DESCRIPTION = 'Optional whole-scene evidence: per-level content, roles (storey, roof-only, support) and the spaces its walls enclose, then every problem found, each with a type: empty levels, walls with no room or door, a space the walls enclose with no room over it (space_no_room) or with several and no wall between them (space_many_rooms), a room the walls do not close (room_not_enclosed) or with no name (room_unnamed), rooms with no floor or ceiling, storeys with no stair, roof levels misused, walls intersecting a covering slab or ending coplanar with its walking surface (wall_covering_slab_contact, with wallId and slabId), openings off their wall, stairs off their slab or blocked, furniture blocking a door or overlapping, a house past its lot line or in its required yards, every node field its schema rejects (schema_invalid, with its nodeId and path; valid is then false, and the level holding the node lists it as unread and is measured once it is fixed), a node kind no schema here knows, once per kind (schema_unknown_kind, info: a plugin kind), a hidden site (site_hidden). Static authored ceiling objects report transformed bounds extending above their ceiling attachment and bounds overlapping solid covering slab bands, with node IDs and measured metres; stored and derived slab holes are subtracted. Wall-mounted objects report a front oriented toward their host; static authored wall bounds report wall-body overlap and extension through the opposite face. With settled editor meshes, catalog wall bounds and large competing coplanar faces against the host or another item on the same wall are also measured within 1 mm. Hidden back-to-wall contact is not competing face evidence. These are observations, not instructions to change the scene or proof of exact mesh intersection. Bounds are measured in the owning building frame, including stacked level elevations. Unknown catalog raw bounds without meshes, animated models, unsupported attachment frames, unresolved scripted wall cuts, roof collisions, recessed slab shells and foundation volumes are not assessed.';
 export const verifySceneTool = {
     name: 'verify_scene',
     title: 'Verify scene',

package/dist/agent-tools/view-scene.d.ts

@@ -1,5 +1,17 @@
 import { z } from 'zod';
-export declare const VIEW_SIDES: readonly ["north", "north-east", "east", "south-east", "south", "south-west", "west", "north-west", "above"];
+/** Sides on the plan's compass: north is its top edge (z grows south, x east). */
+export declare const COMPASS_SIDES: readonly ['north', 'north-east', 'east', 'south-east', 'south', 'south-west', 'west', 'north-west'];
+/**
+ * Sides as a front photo names them, standing in the street facing the house: left and right are
+ * that viewer's hands. They turn with the house's street: the one its site records, else its own
+ * front.
+ */
+export declare const STREET_SIDES: readonly ['street', 'street-left', 'street-right', 'left', 'right', 'back', 'back-left', 'back-right'];
+export declare const VIEW_SIDES: readonly ["north", "north-east", "east", "south-east", "south", "south-west", "west", "north-west", "street", "street-left", "street-right", "left", "right", "back", "back-left", "back-right", "above"];
+/** The light a view is rendered in: the scene's own, or one a reference photo was taken in. */
+export declare const VIEW_LIGHTING: readonly ['current', 'day', 'overcast', 'sunset', 'dusk', 'night'];
+/** The longest side of a view, in pixels: past it a vision model scales the picture down. */
+export declare const VIEW_MAX_PX = 1920;
 export declare const viewSceneTool: {
     name: string;
     title: string;
@@ -7,33 +19,59 @@ export declare const viewSceneTool: {
     input: {
         target: z.ZodOptional<z.ZodString>;
         interior: z.ZodOptional<z.ZodObject<{
-            levelId: z.ZodString;
+            levelId: z.ZodOptional<z.ZodString>;
+            zoneId: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        presentation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"stacked">;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"exploded">;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"solo">;
+            levelId: z.ZodString;
+        }, z.core.$strip>], "mode">>;
         from: z.ZodOptional<z.ZodEnum<{
             above: "above";
+            back: "back";
+            "back-left": "back-left";
+            "back-right": "back-right";
+            east: "east";
+            left: "left";
             north: "north";
             "north-east": "north-east";
-            east: "east";
-            "south-east": "south-east";
+            "north-west": "north-west";
+            right: "right";
             south: "south";
+            "south-east": "south-east";
             "south-west": "south-west";
+            street: "street";
+            "street-left": "street-left";
+            "street-right": "street-right";
             west: "west";
-            "north-west": "north-west";
         }>>;
-        elevation: z.ZodOptional<z.ZodNumber>;
-        eyeHeight: z.ZodOptional<z.ZodNumber>;
+        elevation: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        eyeHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         position: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-        fov: z.ZodOptional<z.ZodNumber>;
+        fov: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         projection: z.ZodOptional<z.ZodEnum<{
-            perspective: "perspective";
             orthographic: "orthographic";
+            perspective: "perspective";
         }>>;
-        camera: z.ZodOptional<z.ZodObject<{
+        camera: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
             position: z.ZodArray<z.ZodNumber>;
             target: z.ZodArray<z.ZodNumber>;
-            fov: z.ZodNumber;
+            fov: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
             aspect: z.ZodNumber;
-        }, z.core.$loose>>;
+        }, z.core.$loose>]>>;
+        lighting: z.ZodOptional<z.ZodEnum<{
+            current: "current";
+            day: "day";
+            dusk: "dusk";
+            night: "night";
+            overcast: "overcast";
+            sunset: "sunset";
+        }>>;
+        maxPx: z.ZodOptional<z.ZodNumber>;
         photo: z.ZodOptional<z.ZodObject<{
             source: z.ZodString;
             region: z.ZodArray<z.ZodNumber>;

package/dist/agent-tools/view-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"view-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/view-scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU,8GAUb,CAAA;AAEV,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EzB,CAAA"}
+{"version":3,"file":"view-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/view-scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,kFAAkF;AAClF,eAAO,MAAM,aAAa,YACxB,OAAO,EACP,YAAY,EACZ,MAAM,EACN,YAAY,EACZ,OAAO,EACP,YAAY,EACZ,MAAM,EACN,YAAY,CACJ,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,YAAY,YACvB,QAAQ,EACR,aAAa,EACb,cAAc,EACd,MAAM,EACN,OAAO,EACP,MAAM,EACN,WAAW,EACX,YAAY,CACJ,CAAA;AAEV,eAAO,MAAM,UAAU,2MAAwD,CAAA;AAE/E,+FAA+F;AAC/F,eAAO,MAAM,aAAa,YAAI,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAU,CAAA;AAE/F,6FAA6F;AAC7F,eAAO,MAAM,WAAW,OAAO,CAAA;AAE/B,eAAO,MAAM,aAAa;IACxB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;QAMN,QAAQ;;;;QASR,YAAY;;;;;;;;QAUZ,IAAI;;;;;;;;;;;;;;;;;;;QAMJ,SAAS;QAMT,SAAS;QAKT,QAAQ;QAGR,GAAG;QAKH,UAAU;;;;QAIV,MAAM;;;;;;QAcN,QAAQ;;;;;;;;QAMR,KAAK;QASL,KAAK;;;;;CAmBR,CAAA"}

package/dist/agent-tools/view-scene.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
+import { measurement } from './measurement.js';
 const point = z.array(z.number()).length(3);
-export const VIEW_SIDES = [
+/** Sides on the plan's compass: north is its top edge (z grows south, x east). */
+export const COMPASS_SIDES = [
     'north',
     'north-east',
     'east',
@@ -9,59 +11,100 @@ export const VIEW_SIDES = [
     'south-west',
     'west',
     'north-west',
-    'above',
 ];
+/**
+ * Sides as a front photo names them, standing in the street facing the house: left and right are
+ * that viewer's hands. They turn with the house's street: the one its site records, else its own
+ * front.
+ */
+export const STREET_SIDES = [
+    'street',
+    'street-left',
+    'street-right',
+    'left',
+    'right',
+    'back',
+    'back-left',
+    'back-right',
+];
+export const VIEW_SIDES = [...COMPASS_SIDES, ...STREET_SIDES, 'above'];
+/** The light a view is rendered in: the scene's own, or one a reference photo was taken in. */
+export const VIEW_LIGHTING = ['current', 'day', 'overcast', 'sunset', 'dusk', 'night'];
+/** The longest side of a view, in pixels: past it a vision model scales the picture down. */
+export const VIEW_MAX_PX = 1920;
 export const viewSceneTool = {
     name: 'view_scene',
     title: 'Look at the scene',
-    description: "Look at the building in 3D from a viewpoint you pick and get the picture back. Use it to compare what you built with a reference and say what differs before you fix it: the facade from the photo's own camera (camera: its position, aim, field of view and aspect), rendered at the photo's aspect to lay beside it; or from the photo's side at street height (from, eyeHeight 1.7); one face square on (projection orthographic); the massing from above. North is the plan's top edge (z grows south, x east). The view frames the target (a building, a level, a wall or a zone; the whole building by default) from outside, unless you place the eye yourself with position or camera. To see inside a floor, give interior {levelId}: the other floors and that floor's roofs and ceilings are left out of the picture, and everything on it, walls, openings and furniture alike, is cut at 0.65 of the storey's height (about two thirds), so a tall wardrobe or a door head is cut, not short; a roof level has no inside; with no eye given it looks down into the floor, or into the room or zone you target. The live view is not changed. A door, a window or an item on a floor frames at detail scale, an opening seen from its outside face: a close-up to lay beside the photo's crop of the same element, to see what differs. Over the MCP the user's editor tab open on the project renders the picture: with none open it is refused (editor_tab_required), and a tab in the background must be brought to the front (editor_tab_hidden). A picture is not a measure: take sizes and counts from the tools.",
+    description: "Look at the building in 3D from a viewpoint you pick and get the picture back: the finished house, every storey and the roof by default, or an explicit Solo/Exploded level presentation, whatever view mode the person has on. Use it to compare what you built with a reference and say what differs before you fix it: the facade from the photo's own camera (camera: its position, aim, field of view and aspect), rendered at the photo's aspect to lay beside it; or from the photo's side at street height (from 'street', 'street-left', …, eyeHeight 1.7), in its light (lighting); one face square on (projection orthographic); the massing from above, or an aerial view (elevation 40). The view frames the target (a building, a level, a wall or a zone; the whole building, its roof included, by default) from outside, unless you place the eye yourself with position or camera. To stand inside a room and see its furniture and finishes at a person's height, give interior {zoneId} (a room: an id from get_zones or create_room): the eye stands in the room a step in from a corner, looking across it, with the cut below; from picks the side of the room it stands on, target something in the room to look at it. To see inside a floor, give interior {levelId}: the other floors and that floor's roofs and ceilings are left out of the picture, and everything on it, walls, openings and furniture alike, is cut at 0.65 of the storey's height (about two thirds), so a tall wardrobe or a door head is cut, not short; a roof level has no inside; with no eye given it looks down into the floor, or into the room or zone you target. A level below grade, targeted alone, is looked into the same way (from outside the ground would cover it), the ground over it drawn as a faint veil. The live view is not changed. A door, a window or an item on a floor frames at detail scale, an opening seen from its outside face: a close-up to lay beside the photo's crop of the same element, to see what differs. Over the MCP the user's editor tab open on the project renders the picture: with none open it is refused (editor_tab_required), a tab in the background must be brought to the front (editor_tab_hidden), and a tab that is open but busy or still loading answers editor_tab_busy: call view_scene again in a few seconds, the user need not be asked. Where the host keeps the picture it answers its viewId: name it to use that exact frame later (a Studio render of this view) without taking it again. A picture is not a measure: take sizes and counts from the tools.",
     input: {
         target: z
             .string()
             .optional()
-            .describe('A building, level, wall, zone, door, window or floor item id to frame. Default: every wall in the scene.'),
+            .describe('A building, level, wall, zone, door, window or floor item id to frame. Default: every storey in the scene, walls and roofs.'),
         interior: z
-            .object({ levelId: z.string().min(1) })
+            .object({
+            levelId: z.string().min(1).optional(),
+            zoneId: z.string().min(1).optional(),
+        })
             .optional()
-            .describe('Look inside this floor (a level id): the other floors and its roofs and ceilings are left out of the picture, everything on it (walls, openings, furniture) cut at 0.65 of the storey height. Default framing looks down into it; camera or position still wins.'),
+            .describe("Look inside, with one of: levelId (a floor): the other floors and its roofs and ceilings are left out of the picture, everything on it (walls, openings, furniture) cut at 0.65 of the storey height. Default framing looks down into it; camera or position still wins. zoneId (a room: an id from get_zones or create_room): the same cut, and the eye stands inside the room at a person's height (1.6 m, or eyeHeight), a step in from its corner farthest from what it looks at (from picks the corner on that side), looking across the room with a 75 degree field of view (fov changes it); with a target on the floor it looks at the target. position, elevation, from above or projection orthographic put the eye outside again, over the cut room."),
+        presentation: z
+            .discriminatedUnion('mode', [
+            z.object({ mode: z.literal('stacked') }),
+            z.object({ mode: z.literal('exploded') }),
+            z.object({ mode: z.literal('solo'), levelId: z.string().min(1) }),
+        ])
+            .optional()
+            .describe('Verify the actual level presentation: stacked (default), exploded, or solo with a levelId. Solo keeps full-height geometry, including ceilings and any roofs incorrectly owned by that floor; it is not the clipped interior view. Does not change the live view. Do not combine with interior.'),
         from: z
             .enum(VIEW_SIDES)
             .optional()
-            .describe('The side the eye stands on, as a compass on the plan. Default south-west.'),
-        elevation: z
-            .number()
-            .min(-10)
-            .max(89)
-            .optional()
-            .describe('Degrees above the horizon the eye looks down from. Default 12.'),
-        eyeHeight: z
-            .number()
-            .min(0)
-            .optional()
-            .describe('Metres above the ground for a street view (1.7), instead of elevation.'),
+            .describe("The side the eye stands on: a compass side (north is the plan's top edge, z grows south, x east), above, or a side as a front photo names it, standing in the street facing the house ('street-left' is its left front corner, 'back' the far side), from the street the site records, else the house's own front (its -z, the way a generated house faces). Default south-west."),
+        elevation: measurement('angle', 'deg', {
+            min: -10,
+            max: 89,
+            description: 'Degrees above the horizon the eye looks down from: 35 to 60 for an aerial view. Default 12.',
+        }).optional(),
+        eyeHeight: measurement('length', 'm', {
+            min: 0,
+            description: 'Metres above the ground for a street view (1.7), instead of elevation.',
+        }).optional(),
         // Arrays of three, not tuples: a tuple's list-form schema is refused by some clients.
         position: point
             .optional()
             .describe('The eye exactly, [x, height, z] in metres; it looks at the target.'),
-        fov: z
-            .number()
-            .min(10)
-            .max(100)
-            .optional()
-            .describe('Vertical field of view in degrees for a perspective view. Default 45.'),
+        fov: measurement('angle', 'deg', {
+            min: 10,
+            max: 100,
+            description: 'Vertical field of view in degrees for a perspective view. Default 45.',
+        }).optional(),
         projection: z
             .enum(['perspective', 'orthographic'])
             .optional()
             .describe('orthographic for a square-on elevation of a face, no perspective.'),
         camera: z
-            .looseObject({
-            position: point,
-            target: point,
-            fov: z.number().min(5).max(120),
-            aspect: z.number().min(0.2).max(5),
-        })
+            .union([
+            z.literal('current'),
+            z.looseObject({
+                position: point,
+                target: point,
+                fov: measurement('angle', 'deg', { min: 5, max: 120 }),
+                aspect: z.number().min(0.2).max(5),
+            }),
+        ])
+            .optional()
+            .describe("A photo's camera (position, target, fov, aspect): the render takes its eye, aim and field of view at the photo's aspect. Or 'current': the person's own view, as their editor shows it now (the MCP has none: no_current_camera). Not with from, position, elevation, eyeHeight, fov or projection."),
+        lighting: z
+            .enum(VIEW_LIGHTING)
+            .optional()
+            .describe("The light the picture is rendered in: the scene's own (current, the default), or day, overcast, sunset, dusk (twilight, the lights on) or night, as a reference photo was taken in."),
+        maxPx: z
+            .number()
+            .int()
+            .min(64)
+            .max(VIEW_MAX_PX)
             .optional()
-            .describe("A photo's camera (position, target, fov, aspect): the render takes its eye, aim and field of view at the photo's aspect. Not with from, position, elevation, eyeHeight, fov or projection."),
+            .describe("The picture's longest side in pixels, for a smaller one. Default 1920 by 1200, and never longer than 1920."),
         photo: z
             .looseObject({
             source: z

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

@@ -4,49 +4,30 @@ export declare const addDoorTool: {
     title: string;
     description: string;
     input: {
-        doorType: z.ZodOptional<z.ZodEnum<{
-            double: "double";
-            hinged: "hinged";
-            french: "french";
-            folding: "folding";
-            pocket: "pocket";
-            barn: "barn";
-            sliding: "sliding";
-            "garage-sectional": "garage-sectional";
-            "garage-rollup": "garage-rollup";
-            "garage-tiltup": "garage-tiltup";
-        }>>;
-        style: z.ZodOptional<z.ZodEnum<{
-            glass: "glass";
-            french: "french";
-            barn: "barn";
-            panel: "panel";
-            shaker: "shaker";
-            modern: "modern";
-            "paneled-glass": "paneled-glass";
-            "six-panel": "six-panel";
-            craftsman: "craftsman";
-            "half-louvered": "half-louvered";
-        }>>;
         name: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         category: z.ZodOptional<z.ZodString>;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        t: z.ZodOptional<z.ZodNumber>;
+        position: z.ZodOptional<z.ZodNumber>;
+        force: z.ZodOptional<z.ZodBoolean>;
         code: z.ZodOptional<z.ZodString>;
         language: z.ZodOptional<z.ZodEnum<{
-            three: "three";
             bpy: "bpy";
+            three: "three";
         }>>;
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
         openingShape: z.ZodOptional<z.ZodEnum<{
+            arch: "arch";
             rectangle: "rectangle";
             rounded: "rounded";
-            arch: "arch";
         }>>;
-        archHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        cornerRadius: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        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>>>;
+        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>>>;
         openingKind: z.ZodOptional<z.ZodEnum<{
             door: "door";
             opening: "opening";
@@ -55,15 +36,38 @@ export declare const addDoorTool: {
             left: "left";
             right: "right";
         }>>;
+        handleSide: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
         swingDirection: z.ZodOptional<z.ZodEnum<{
             inward: "inward";
             outward: "outward";
         }>>;
-        t: z.ZodOptional<z.ZodNumber>;
-        position: z.ZodOptional<z.ZodNumber>;
-        force: z.ZodOptional<z.ZodBoolean>;
-        wallId: z.ZodOptional<z.ZodString>;
-        nodeId: z.ZodOptional<z.ZodString>;
+        doorType: z.ZodOptional<z.ZodEnum<{
+            barn: "barn";
+            double: "double";
+            folding: "folding";
+            french: "french";
+            "garage-rollup": "garage-rollup";
+            "garage-sectional": "garage-sectional";
+            "garage-tiltup": "garage-tiltup";
+            hinged: "hinged";
+            pocket: "pocket";
+            sliding: "sliding";
+        }>>;
+        style: z.ZodOptional<z.ZodEnum<{
+            barn: "barn";
+            craftsman: "craftsman";
+            french: "french";
+            glass: "glass";
+            "half-louvered": "half-louvered";
+            modern: "modern";
+            panel: "panel";
+            "paneled-glass": "paneled-glass";
+            shaker: "shaker";
+            "six-panel": "six-panel";
+        }>>;
     };
 };
 export declare const addWindowTool: {
@@ -71,58 +75,58 @@ export declare const addWindowTool: {
     title: string;
     description: string;
     input: {
-        windowType: z.ZodOptional<z.ZodEnum<{
-            fixed: "fixed";
-            sliding: "sliding";
-            casement: "casement";
-            awning: "awning";
-            hopper: "hopper";
-            "single-hung": "single-hung";
-            "double-hung": "double-hung";
-            bay: "bay";
-            bow: "bow";
-            louvered: "louvered";
-        }>>;
-        columns: z.ZodOptional<z.ZodNumber>;
-        rows: z.ZodOptional<z.ZodNumber>;
-        style: z.ZodOptional<z.ZodEnum<{
-            sliding: "sliding";
-            casement: "casement";
-            "double-hung": "double-hung";
-            single: "single";
-            grid: "grid";
-            "triple-hung": "triple-hung";
-            "tall-grid": "tall-grid";
-            "wide-grid": "wide-grid";
-            "horizontal-bands": "horizontal-bands";
-            transom: "transom";
-            picture: "picture";
-        }>>;
         name: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         category: z.ZodOptional<z.ZodString>;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        t: z.ZodOptional<z.ZodNumber>;
+        position: z.ZodOptional<z.ZodNumber>;
+        force: z.ZodOptional<z.ZodBoolean>;
         code: z.ZodOptional<z.ZodString>;
         language: z.ZodOptional<z.ZodEnum<{
-            three: "three";
             bpy: "bpy";
+            three: "three";
         }>>;
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
         openingShape: z.ZodOptional<z.ZodEnum<{
+            arch: "arch";
             rectangle: "rectangle";
             rounded: "rounded";
-            arch: "arch";
         }>>;
-        archHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        cornerRadius: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        sillHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        t: z.ZodOptional<z.ZodNumber>;
-        position: z.ZodOptional<z.ZodNumber>;
-        force: z.ZodOptional<z.ZodBoolean>;
+        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>>>;
         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>>>;
+        windowType: z.ZodOptional<z.ZodEnum<{
+            awning: "awning";
+            bay: "bay";
+            bow: "bow";
+            casement: "casement";
+            "double-hung": "double-hung";
+            fixed: "fixed";
+            hopper: "hopper";
+            louvered: "louvered";
+            "single-hung": "single-hung";
+            sliding: "sliding";
+        }>>;
+        columns: z.ZodOptional<z.ZodNumber>;
+        rows: z.ZodOptional<z.ZodNumber>;
+        style: z.ZodOptional<z.ZodEnum<{
+            casement: "casement";
+            "double-hung": "double-hung";
+            grid: "grid";
+            "horizontal-bands": "horizontal-bands";
+            picture: "picture";
+            single: "single";
+            sliding: "sliding";
+            "tall-grid": "tall-grid";
+            transom: "transom";
+            "triple-hung": "triple-hung";
+            "wide-grid": "wide-grid";
+        }>>;
     };
 };
 export declare const addDoorOutput: {
@@ -143,7 +147,6 @@ export declare const addDoorOutput: {
     doorId: z.ZodString;
 };
 export declare const addWindowOutput: {
-    sillHeight: z.ZodOptional<z.ZodNumber>;
     ok: z.ZodLiteral<true>;
     wallId: z.ZodString;
     localX: z.ZodNumber;
@@ -159,5 +162,6 @@ export declare const addWindowOutput: {
         unchanged: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>;
     windowId: z.ZodString;
+    sillHeight: z.ZodOptional<z.ZodNumber>;
 };
 //# sourceMappingURL=wall-openings.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CvB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CzB,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,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDzB,CAAA;AAkBD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAA2C,CAAA;AAErE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAI3B,CAAA"}

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

@@ -25,7 +25,7 @@ const script = (kind) => ({
         .min(1)
         .max(48_000)
         .optional()
-        .describe(`A module (three.js, or bpy with language) for a ${kind} the fields cannot express (a fan grille, tracery, carved trim): the same module and conventions as add_object, with mount 'wall'. Its size is what it builds (name params width and height so the ${kind}'s size controls edit them), and its cutout mesh cuts the wall. Make it open like a real ${kind}: add an \`open\` clip (${kind === 'door' ? 'the leaves swinging or sliding' : 'the sash sliding or swinging'}; \`close\` is optional, \`open\` reversed by default) unless it is fixed. Fields first; code only beyond them.`),
+        .describe(`An optional module (three.js, or bpy with language) for a ${kind} (a fan grille, tracery, carved trim): the same module and conventions as add_object, with mount 'wall'. Its size is what it builds (name params width and height so the ${kind}'s size controls edit them), and its cutout mesh cuts the wall. Make it open like a real ${kind}: add an \`open\` clip (${kind === 'door' ? 'the leaves swinging or sliding' : 'the sash sliding or swinging'}; \`close\` is optional, \`open\` reversed by default) unless it is fixed. Native fields and code are available to express the requested shape.`),
     language: scriptLanguage,
     params: scriptParams,
     ...geometryMetaFields,
@@ -50,7 +50,7 @@ export const addDoorTool = {
     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.',
     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 first to change its code). Its native fields change with update_node.'),
+        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,
         width: measurement('length', 'm', {
             positive: true,
@@ -65,6 +65,10 @@ export const addDoorTool = {
             .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).'),
+        handleSide: z
+            .enum(['left', 'right'])
+            .optional()
+            .describe('Handle side (default: opposite the hinges).'),
         swingDirection: z
             .enum(['inward', 'outward'])
             .optional()
@@ -81,10 +85,10 @@ export const addDoorTool = {
 export const addWindowTool = {
     name: 'add_window',
     title: 'Add window',
-    description: "Add a window to an existing straight wall at t (0..1 along it), on sillHeight above the floor. 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, 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.",
     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 first to change its code). Its native fields change with update_node.'),
+        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.'),
         ...placement,
         width: measurement('length', 'm', {
             positive: true,
@@ -96,7 +100,7 @@ export const addWindowTool = {
         }).optional(),
         sillHeight: measurement('length', 'm', {
             min: 0,
-            description: 'Height from the floor to the bottom of the window (default 0.9 m).',
+            description: 'Height from the floor to the bottom of the window (default: centred vertically on the wall).',
         }).optional(),
         ...outline('0.35 m'),
         ...script('window'),

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

@@ -3,7 +3,7 @@ import { z } from 'zod';
  * A wall's bend: a rounded corner could only be made with apply_patch, its sign documented
  * nowhere.
  */
-export declare const WALL_CURVE_OFFSET_INPUT: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+export declare const WALL_CURVE_OFFSET_INPUT: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
 export declare const addWallTool: {
     name: string;
     title: string;
@@ -13,9 +13,9 @@ export declare const addWallTool: {
         level: z.ZodOptional<z.ZodString>;
         start: z.ZodArray<z.ZodNumber>;
         end: z.ZodArray<z.ZodNumber>;
-        thickness: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        curveOffset: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        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>>>;
     };
 };
 //# 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;AAIvB;;;GAGG;AACH,eAAO,MAAM,uBAAuB,qGAGlC,CAAA;AAKF,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAmBvB,CAAA"}
+{"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"}

package/dist/agent-tools/walls.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { FOUNDATION_BY_REGION_NOTE } from '../lib/foundation-construction.js';
 import { levelTarget } from './levels.js';
 import { measurement } from './measurement.js';
 /**
@@ -12,13 +13,17 @@ 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.',
+    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, ' +
+        FOUNDATION_BY_REGION_NOTE +
+        '; a partition inside the outline is an ordinary wall; the result says which.',
     input: {
         start: planPoint('start'),
         end: planPoint('end'),
         thickness: measurement('length', 'm', {
             positive: true,
-            description: 'Wall thickness (default 0.1 m).',
+            description: 'Wall thickness (default 0.1 m; a wall against the ground on a level below grade, given none, is a foundation wall ' +
+                FOUNDATION_BY_REGION_NOTE +
+                '; a partition inside it is an ordinary wall).',
         }).optional(),
         height: measurement('length', 'm', {
             positive: true,