@pascal-app/core 1.0.4 → 1.0.5

package/dist/agent-tools/room-structure.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { measurement } from './measurement.js';
 import { NodeId } from './node-id.js';
 // Room transforms and floor construction, as the editor's room and floor commands do them. Points
 // are arrays of two, not tuples: a tuple's list-form schema is refused by some clients. The patches
@@ -11,8 +12,8 @@ const zoneIntentPatch = z.strictObject({
     floor: z
         .strictObject({
         footprint: z.string().min(1).nullable().optional(),
-        thickness: z.number().min(0.02).nullable().optional(),
-        elevation: z.number().nullable().optional(),
+        thickness: measurement('length', 'm', { min: 0.02 }).nullable().optional(),
+        elevation: measurement('length', 'm').nullable().optional(),
         finish: finish.nullable().optional(),
         regions: paintRegions.nullable().optional(),
     })
@@ -28,26 +29,28 @@ const zoneIntentPatch = z.strictObject({
     wallMaterial: z.string().nullable().optional(),
     hasFloor: z.boolean().nullable().optional(),
     hasCeiling: z.boolean().nullable().optional(),
+    daylight: z
+        .strictObject({
+        artificialLight: z.boolean().describe('The room is lit by artificial light.'),
+        mechanicalVentilation: z.boolean().describe('The room is aired by mechanical ventilation.'),
+    })
+        .nullable()
+        .optional(),
 });
 const floorFoundationPatch = z.strictObject({
-    thickness: z
-        .number()
-        .finite()
-        .min(0)
-        .optional()
-        .describe('Slab thickness in meters. On the ground it sits on the foundation (or the ground) and grows upward: a thicker slab raises the floor top and everything on it. Never below 0.01 m (smaller values are clamped). Upstairs the underside stays on the walls below.'),
-    foundationHeight: z
-        .number()
-        .finite()
-        .min(0)
-        .optional()
-        .describe('Ground-bearing floors only: height of the foundation under the slab, in meters. 0 = on the ground (no foundation); > 0 = raised on a solid foundation. The floor top is derived: grade + foundationHeight + thickness.'),
-    floorHeight: z
-        .number()
-        .finite()
+    thickness: measurement('length', 'm', {
+        min: 0,
+        description: 'Slab thickness in meters. On the ground it sits on the foundation (or the ground) and grows upward: a thicker slab raises the floor top and everything on it. Never below 0.01 m (smaller values are clamped). Upstairs the underside stays on the walls below.',
+    }).optional(),
+    foundationHeight: measurement('length', 'm', {
+        min: 0,
+        description: 'Ground-bearing floors only: height of the foundation under the slab, in meters. 0 = on the ground (no foundation); > 0 = raised on a solid foundation. The floor top is derived: grade + foundationHeight + thickness.',
+    }).optional(),
+    floorHeight: measurement('length', 'm', {
+        description: 'Legacy: a target floor top in level-local meters. On the ground it is mapped to foundationHeight = top - grade - thickness (never below 0); null = on the ground. Prefer thickness and foundationHeight.',
+    })
         .nullable()
-        .optional()
-        .describe('Legacy: a target floor top in level-local meters. On the ground it is mapped to foundationHeight = top - grade - thickness (never below 0); null = on the ground. Prefer thickness and foundationHeight.'),
+        .optional(),
     foundation: z.object({ type: z.enum(['solid', 'none']), material: finish.optional() }).optional(),
     slots: z
         .strictObject({
@@ -60,7 +63,7 @@ const floorFoundationPatch = z.strictObject({
 const roomTransform = {
     zoneId: NodeId,
     translate: point.optional(),
-    rotate: z.object({ angle: z.number().finite(), pivot: point.optional() }).optional(),
+    rotate: z.object({ angle: measurement('angle', 'rad'), pivot: point.optional() }).optional(),
     force: z.boolean().optional(),
 };
 export const cutFloorOpeningTool = {
@@ -76,8 +79,8 @@ export const cutFloorOpeningTool = {
             .object({
             x: z.number().finite(),
             z: z.number().finite(),
-            width: z.number().finite().positive(),
-            depth: z.number().finite().positive(),
+            width: measurement('length', 'm', { positive: true }),
+            depth: measurement('length', 'm', { positive: true }),
         })
             .optional(),
         drawnOn: z.enum(['floor', 'ceiling']).optional(),
@@ -114,7 +117,7 @@ export const rebaseFloorReferenceTool = {
     input: {
         slabId: NodeId.optional(),
         slabIds: z.array(NodeId).min(1).optional(),
-        referenceFloorElevation: z.number().finite().nullable(),
+        referenceFloorElevation: measurement('length', 'm').nullable(),
     },
 };
 export const createMezzanineTool = {
@@ -124,8 +127,8 @@ export const createMezzanineTool = {
     input: {
         hostZoneId: NodeId,
         polygon: z.array(point).min(3),
-        elevation: z.number().finite().optional(),
-        thickness: z.number().finite().min(0.02).optional(),
+        elevation: measurement('length', 'm').optional(),
+        thickness: measurement('length', 'm', { min: 0.02 }).optional(),
     },
 };
 export const moveZoneTool = {
@@ -147,7 +150,7 @@ export const rotateZoneTool = {
     input: {
         zoneId: NodeId,
         quarterTurns: z.number().int().min(-1).max(1).describe('1 or -1.'),
-        gridStep: z.number().finite().positive().optional(),
+        gridStep: measurement('length', 'm', { positive: true }).optional(),
         force: z.boolean().optional(),
     },
 };
@@ -160,7 +163,7 @@ export const lockOutsideFacesTool = {
 export const setZoneIntentTool = {
     name: 'set_zone_intent',
     title: 'Set room intent',
-    description: 'Update room name, floor finish/elevation/regions, floor.footprint ("new" mints a unique floor key tied to this creator room, an existing key joins that floor on this level, null returns to the shared floor). Touching rooms with the same key share a base plate; disconnected pieces share construction settings. Conversion preserves world geometry in one edit and refuses when infeasible. get_zones exposes floor_choices. A keyed floor uses "<creator room name> floor" while the creator remains on that key; otherwise it uses the largest named room. Existing keys such as "own" without a creator use that fallback. A user-given plate name wins; the shared floor stays "Shared floor". Keyed rooms can have raised or sunken floor.elevation, stored as a level-local walking top. Slab thickness, foundation height and edge finish use set_room_floor_construction, updating every piece of the key. Update ceiling paint regions (ceiling.regions: [x, z] polygons with a finish, later wins), step finishes (floorStepFinish for every step of the room; floorStepOverrides: [{ key, step?, finish }] per doorway, key = the door id the step sits under or the lower room id), wall material and construction opt-outs. Absent fields are unchanged; null clears.',
+    description: 'Update room name, floor finish/elevation/regions, floor.footprint ("new" mints a unique floor key tied to this creator room, an existing key joins that floor on this level, null returns to the shared floor). Touching rooms with the same key share a base plate; disconnected pieces share construction settings. Conversion preserves world geometry in one edit and refuses when infeasible. get_zones exposes floor_choices. A keyed floor uses "<creator room name> floor" while the creator remains on that key; otherwise it uses the largest named room. Existing keys such as "own" without a creator use that fallback. A user-given plate name wins; the shared floor stays "Shared floor". Keyed rooms can have raised or sunken floor.elevation, stored as a level-local walking top. Slab thickness, foundation height and edge finish use set_room_floor_construction, updating every piece of the key. Update ceiling paint regions (ceiling.regions: [x, z] polygons with a finish, later wins), step finishes (floorStepFinish for every step of the room; floorStepOverrides: [{ key, step?, finish }] per doorway, key = the door id the step sits under or the lower room id), wall material and construction opt-outs. daylight { artificialLight, mechanicalVentilation } declares a habitable room lit and aired by artificial means (the IRC R303.1 exceptions to daylight; both true), stored in the room\'s metadata; a bedroom, living room or kitchen needs a window to outside or this declaration, above and below grade alike. Absent fields are unchanged; null clears.',
     input: { zoneId: NodeId, patch: zoneIntentPatch },
 };
 export const divideZoneTool = {

package/dist/agent-tools/search-materials.d.ts

@@ -5,15 +5,34 @@ export declare const searchMaterialsTool: {
     description: string;
     input: {
         queries: z.ZodArray<z.ZodObject<{
-            query: z.ZodString;
+            query: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                brick: "brick";
+                carpet: "carpet";
+                colors: "colors";
+                concrete: "concrete";
+                fabric: "fabric";
+                glass: "glass";
+                ground: "ground";
+                leather: "leather";
+                metal: "metal";
+                other: "other";
+                plastic: "plastic";
+                roofing: "roofing";
+                stone: "stone";
+                tile: "tile";
+                wallpaper: "wallpaper";
+                wood: "wood";
+            }>>;
             surface: z.ZodOptional<z.ZodEnum<{
-                wall: "wall";
-                roof: "roof";
                 ceiling: "ceiling";
                 floor: "floor";
                 furniture: "furniture";
                 outdoor: "outdoor";
+                roof: "roof";
+                wall: "wall";
             }>>;
+            offset: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     };
 };

package/dist/agent-tools/search-materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-materials.d.ts","sourceRoot":"","sources":["../../src/agent-tools/search-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAavB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;CAwB/B,CAAA"}
+{"version":3,"file":"search-materials.d.ts","sourceRoot":"","sources":["../../src/agent-tools/search-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,mBAAmB;IAC9B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BV,CAAA"}

package/dist/agent-tools/search-materials.js

@@ -1,32 +1,31 @@
 import { z } from 'zod';
-// The library's surfaces, named here so the contract stays free of the catalog it searches.
-const SURFACES = [
-    'floor',
-    'wall',
-    'ceiling',
-    'roof',
-    'furniture',
-    'outdoor',
-];
+import { MATERIAL_CATEGORIES, MATERIAL_SURFACES } from '../material-kinds.js';
 export const searchMaterialsTool = {
     name: 'search_materials',
     title: 'Search materials',
-    description: "Search the material library (the finishes paint gives) by words, several queries in one call: find a library material's id here rather than guessing it. A query's words match the words of a material's id, name and kind, building words as the library writes them (timber is wood, weatherboard is siding, render is stucco), colour words by its shade (dark, light, white, grey) and surface words (roof, wall, floor, ceiling) by what it suits. Returns one group per query: each material's ref (library:<id>), name, kind, the surfaces it suits and its colour, best first, and the words no material answers (missing), so a finish the library lacks is said, not guessed.",
+    description: "Search or browse the material library (the finishes paint gives), several queries in one call: find a library material's ref here rather than guessing it. The library is Pascal's materials and, in the editor, the ones it holds besides (the community's, yours, your workspace's). A query's words match the words of a material's id, name and kind, or a piece of its id (plank48, cco), building words as the library writes them (timber is wood, weatherboard is siding, render is stucco), colour words by its shade (dark, light, white, grey) and surface words (roof, wall, floor, ceiling) by what it suits; a word of one or two letters, or one as common as 'the', searches nothing. Without a query, a browse lists by name every material of its kind, or that suits its surface (flat colours suit every one), or the whole library. Returns one group per query: each material's ref (library:<id>), name, kind, the surfaces it suits and its colour, best first (a browse by name), 12 at a time for a search and 150 for a browse; the words no material answers (missing), so a finish the library lacks is said, not guessed; and on a long list how many more there are (more) and the offset that lists them (next).",
     input: {
         queries: z
             .array(z.object({
             query: z
                 .string()
                 .trim()
-                .min(1)
-                .describe('Search words, e.g. "white render", "grey metal roofing", "oak floor".'),
+                .optional()
+                .describe('Search words, e.g. "white render", "grey metal roofing", "oak floor"; leave them out to browse.'),
+            kind: z.enum(MATERIAL_CATEGORIES).optional().describe('Only materials of this kind.'),
             surface: z
-                .enum(SURFACES)
+                .enum(MATERIAL_SURFACES)
                 .optional()
                 .describe('Only materials that suit this surface; flat colours suit every one.'),
+            offset: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe('The next page of a long search or browse: the next it returned.'),
         }))
             .min(1)
             .max(12)
-            .describe('One or more searches to run in one call.'),
+            .describe('One or more searches or browses to run in one call.'),
     },
 };

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const getSiteTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        building: z.ZodOptional<z.ZodString>;
+        site: z.ZodOptional<z.ZodString>;
+    };
+};
+export declare const placeBuildingTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        building: z.ZodOptional<z.ZodString>;
+        outline: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+        yards: z.ZodOptional<z.ZodObject<{
+            front: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            rear: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            left: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            right: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        }, z.core.$strip>>;
+        rotationDeg: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    };
+};
+//# sourceMappingURL=site.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"site.d.ts","sourceRoot":"","sources":["../../src/agent-tools/site.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,eAAO,MAAM,WAAW;;;;;;;;CAMvB,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;CA8B7B,CAAA"}

package/dist/agent-tools/site.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+const building = NodeId.optional().describe("The building, by its id (list_levels' parentId). Default: the building of the floor the person is viewing, else the scene's only building.");
+const yard = (side) => measurement('length', 'm', {
+    min: 0,
+    description: `The ${side} yard: from the lot line to the house, square to the house.`,
+}).optional();
+const site = NodeId.optional().describe("The site, by its id (get_site's siteId), when the scene has several: a lot no building stands on yet reads in site coordinates. Default: the building's site.");
+export const getSiteTool = {
+    name: 'get_site',
+    title: 'Get site',
+    description: "Read the site a building stands on, in its level coordinates: the lot and its area, with the footprint a house usually covers on it (30 to 45%); the buildable area inside the setbacks with its centre, its area, each edge's frontage and depth, and its front edge (behind the street; while no street is recorded, behind the edge facing north, which the setbacks take as the front); the street side with the lot's frontage and depth on it; north; the ground (sloped with its fall, read flat, or not read); the address, parcel and zoning when known; whether the lot is only the new-project placeholder; and where the footprint sits now with its yards.",
+    input: { building, site },
+};
+export const placeBuildingTool = {
+    name: 'place_building',
+    title: 'Place building',
+    description: "Stand a building on its site before or after its walls go up. It moves only the building node, so walls, levels and roofs keep their coordinates and move with it. The footprint (outline, the plan you are about to draw, in the coordinates you will draw it; else the walls standing) lands centred in the buildable area, or at the yards a site plan or the person gives. A building with walls keeps its rotation unless rotationDeg is given (get_site's squareRotationDeg squares it to the street); one with none yet is turned square to the street. Fences, paths and plants on its levels move with it.",
+    input: {
+        building,
+        outline: z
+            .array(z.array(z.number()).length(2))
+            .min(3)
+            .optional()
+            .describe("The footprint's corners in order, as [x, z] in metres, in the level coordinates the walls are (or will be) drawn in. Default: the walls standing."),
+        yards: z
+            .object({
+            front: yard('front'),
+            rear: yard('rear'),
+            left: yard('left (seen from the street)'),
+            right: yard('right (seen from the street)'),
+        })
+            .optional()
+            .describe('Where the house stands instead of centred: at most one of front and rear, and one of left and right, from a site plan or the person. An axis not given stays centred in the buildable area. Needs the site to know its street (frontEdge).'),
+        rotationDeg: measurement('angle', 'deg', {
+            description: "The building's rotation about the vertical. Default: the rotation it has, or square to the street while it has no walls.",
+        }).optional(),
+    },
+};

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

@@ -0,0 +1,12 @@
+/**
+ * What a dead end of a tool says about the other sources that exist for the same need: the
+ * catalog's tools name what authors, the creation tools name the catalog. Facts, in both
+ * directions.
+ */
+/** Where a catalog item is missing, or does not fit: the ways to make one. */
+export declare const OTHER_SOURCES = "add_object builds an object of any shape and size, place_design places a procedural design.";
+/** Outside the rooms: what stands there besides a catalog item. */
+export declare const OUTSIDE_SOURCES = "add_object builds an object of any shape and size, and place_design places a procedural design.";
+/** Where a creation fails or is refused: the ready items. */
+export declare const CATALOG_SOURCE = "The catalog has ready items: search_assets finds them, place_items and furnish_room place them.";
+//# sourceMappingURL=sources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sources.d.ts","sourceRoot":"","sources":["../../src/agent-tools/sources.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,8EAA8E;AAC9E,eAAO,MAAM,aAAa,gGACqE,CAAA;AAE/F,mEAAmE;AACnE,eAAO,MAAM,eAAe,oGACuE,CAAA;AAEnG,6DAA6D;AAC7D,eAAO,MAAM,cAAc,oGACwE,CAAA"}

package/dist/agent-tools/sources.js

@@ -0,0 +1,11 @@
+/**
+ * What a dead end of a tool says about the other sources that exist for the same need: the
+ * catalog's tools name what authors, the creation tools name the catalog. Facts, in both
+ * directions.
+ */
+/** Where a catalog item is missing, or does not fit: the ways to make one. */
+export const OTHER_SOURCES = 'add_object builds an object of any shape and size, place_design places a procedural design.';
+/** Outside the rooms: what stands there besides a catalog item. */
+export const OUTSIDE_SOURCES = 'add_object builds an object of any shape and size, and place_design places a procedural design.';
+/** Where a creation fails or is refused: the ready items. */
+export const CATALOG_SOURCE = 'The catalog has ready items: search_assets finds them, place_items and furnish_room place them.';

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

@@ -6,8 +6,8 @@ export declare const measureStairTool: {
     input: {
         stairId: z.ZodString;
         available: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            length: z.ZodNumber;
+            width: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+            length: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
         }, z.core.$strip>>;
     };
 };
@@ -19,31 +19,31 @@ export declare const fitStairTool: {
         stairId: z.ZodString;
         fitRun: z.ZodDefault<z.ZodBoolean>;
         layout: z.ZodOptional<z.ZodEnum<{
+            l: "l";
             straight: "straight";
             u: "u";
-            l: "l";
         }>>;
         turn: z.ZodOptional<z.ZodEnum<{
             left: "left";
             right: "right";
         }>>;
-        width: z.ZodOptional<z.ZodNumber>;
-        landingDepth: z.ZodOptional<z.ZodNumber>;
+        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        landingDepth: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         turningStrategy: z.ZodOptional<z.ZodEnum<{
             landing: "landing";
             winder: "winder";
         }>>;
-        innerGap: z.ZodOptional<z.ZodNumber>;
-        walkingLineOffset: z.ZodOptional<z.ZodNumber>;
+        innerGap: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        walkingLineOffset: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         division: z.ZodOptional<z.ZodEnum<{
-            "equal-going": "equal-going";
             "equal-angle": "equal-angle";
+            "equal-going": "equal-going";
         }>>;
         targets: z.ZodOptional<z.ZodObject<{
-            maxRiserHeight: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-            minimumGoing: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-            targetGoing: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-            minimumHeadroom: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            maxRiserHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            minimumGoing: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            targetGoing: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            minimumHeadroom: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         }, z.core.$strip>>;
     };
 };
@@ -52,35 +52,55 @@ export declare const createStairTool: {
     title: string;
     description: string;
     input: {
-        toLevelId: z.ZodOptional<z.ZodString>;
-        railingMode: z.ZodOptional<z.ZodEnum<{
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        x: z.ZodNumber;
+        z: z.ZodNumber;
+        rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        layout: z.ZodOptional<z.ZodEnum<{
+            l: "l";
+            straight: "straight";
+            u: "u";
+        }>>;
+        turn: z.ZodOptional<z.ZodEnum<{
             left: "left";
             right: "right";
-            none: "none";
+        }>>;
+        lowerSteps: z.ZodOptional<z.ZodNumber>;
+        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        length: 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>>>;
+        steps: z.ZodOptional<z.ZodNumber>;
+        toLevelId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        railingMode: z.ZodOptional<z.ZodEnum<{
             both: "both";
+            left: "left";
+            none: "none";
+            right: "right";
+        }>>;
+        railingStyle: z.ZodOptional<z.ZodEnum<{
+            balusters: "balusters";
+            boards: "boards";
+            cable: "cable";
+            glass: "glass";
+            metal: "metal";
+            "post-and-rail": "post-and-rail";
         }>>;
+        railingMaterial: z.ZodOptional<z.ZodString>;
         materialPreset: z.ZodOptional<z.ZodString>;
         name: z.ZodOptional<z.ZodString>;
         createDestinationSlabOpening: z.ZodOptional<z.ZodBoolean>;
         createSourceCeilingOpening: z.ZodOptional<z.ZodBoolean>;
         destinationSlabId: z.ZodOptional<z.ZodString>;
         sourceCeilingId: z.ZodOptional<z.ZodString>;
-        openingWidth: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        openingLength: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        openingOffset: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        openingWidth: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        openingLength: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        openingOffset: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         openingCenter: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-        openingRotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-        levelId: z.ZodOptional<z.ZodString>;
-        level: z.ZodOptional<z.ZodString>;
-        x: z.ZodNumber;
-        z: z.ZodNumber;
-        rotation: 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>>>;
-        length: 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>>>;
-        steps: z.ZodOptional<z.ZodNumber>;
+        openingRotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     };
 };
 export type MeasureStairInput = z.infer<z.ZodObject<typeof measureStairTool.input>>;
 export type FitStairInput = z.infer<z.ZodObject<typeof fitStairTool.input>>;
+export type CreateStairInput = z.infer<z.ZodObject<typeof createStairTool.input>>;
 //# sourceMappingURL=stairs.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"stairs.d.ts","sourceRoot":"","sources":["../../src/agent-tools/stairs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAS5B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBxB,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiF3B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAA;AACnF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAA"}
+{"version":3,"file":"stairs.d.ts","sourceRoot":"","sources":["../../src/agent-tools/stairs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,gBAAgB;IAC3B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;QACP,SAAS;;;;;CAQZ,CAAA;AAsBD,eAAO,MAAM,YAAY;IACvB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;QACP,MAAM;QACN,MAAM;;;;;QACN,IAAI;;;;QACJ,KAAK;QACL,YAAY;QACZ,eAAe;;;;QACf,QAAQ;QACR,iBAAiB;QACjB,QAAQ;;;;QACR,OAAO;;;;;;;CAEV,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyG3B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAA;AACnF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAA;AAC3E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC,CAAA"}

package/dist/agent-tools/stairs.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { StairDesignTargets } from '../schema/nodes/stair-design-targets.js';
+import { StairRailingMode, StairRailingStyle } from '../schema/nodes/stair-types.js';
 import { levelTarget } from './levels.js';
 import { measurement } from './measurement.js';
 import { NodeId } from './node-id.js';
@@ -9,9 +9,34 @@ export const measureStairTool = {
     description: 'Inspect actual flight risers, walking-line going, slope, arrival, uniformity, headroom against floors, ceilings and stair bodies, and design-target diagnostics without changing measured geometry.',
     input: {
         stairId: NodeId,
-        available: z.object({ width: z.number().positive(), length: z.number().positive() }).optional(),
+        available: z
+            .object({
+            width: measurement('length', 'm', { positive: true }),
+            length: measurement('length', 'm', { positive: true }),
+        })
+            .optional()
+            .describe('The space a new layout may take, to propose layouts that fit it.'),
     },
 };
+/** A stair's design targets, each in metres; only the ones given change. */
+const designTargets = z.object({
+    maxRiserHeight: measurement('length', 'm', {
+        positive: true,
+        description: 'The tallest riser (default 0.18 m).',
+    }).optional(),
+    minimumGoing: measurement('length', 'm', {
+        positive: true,
+        description: 'The shortest going (default 0.25 m).',
+    }).optional(),
+    targetGoing: measurement('length', 'm', {
+        positive: true,
+        description: 'The going a fit aims for (default 0.28 m).',
+    }).optional(),
+    minimumHeadroom: measurement('length', 'm', {
+        positive: true,
+        description: 'The least headroom over the flight (default 2 m).',
+    }).optional(),
+});
 export const fitStairTool = {
     name: 'fit_stair',
     title: 'Fit stair',
@@ -21,32 +46,46 @@ export const fitStairTool = {
         fitRun: z.boolean().default(false),
         layout: z.enum(['straight', 'l', 'u']).optional(),
         turn: z.enum(['left', 'right']).optional(),
-        width: z.number().positive().optional(),
-        landingDepth: z.number().positive().optional(),
+        width: measurement('length', 'm', { positive: true }).optional(),
+        landingDepth: measurement('length', 'm', { positive: true }).optional(),
         turningStrategy: z.enum(['landing', 'winder']).optional(),
-        innerGap: z.number().nonnegative().optional(),
-        walkingLineOffset: z.number().positive().optional(),
+        innerGap: measurement('length', 'm', { min: 0 }).optional(),
+        walkingLineOffset: measurement('length', 'm', { positive: true }).optional(),
         division: z.enum(['equal-going', 'equal-angle']).optional(),
-        targets: StairDesignTargets.partial().optional(),
+        targets: designTargets.optional(),
     },
 };
 export const createStairTool = {
     name: 'create_stair',
     title: 'Create stair',
-    description: "Create a straight staircase rising from a level to the level above, as the editor's stair tool does: it owns the floor opening it cuts in every floor it passes, and when no level stands above, a blank one is created for it. Refused with a code: a flight to or from a declared roof level, and a toLevelId that is not above the level it rises from.\n\nGEOMETRY (get this wrong and the stair pokes through a wall):\n- (x, z) is the BACK-CENTRE of the first (bottom) step, not the centre of the footprint.\n- The footprint is width × length: width side to side, length along the climb. At rotation 0 it covers x − width/2 .. x + width/2 and z .. z + length.\n- rotation in degrees about Y: 0 climbs toward +Z, 90 → +X, 180 → −Z, 270 → −X. Point the climb into the room, away from the wall the bottom step sits against.\n- Leave at least 0.5 m clear at the foot of the flight, and keep the whole footprint inside one room on both levels (a hall is typical): read the room's outline first (get_zones).\n\nOPENINGS: by default the stair owns the opening over its flight and keeps it as the flight moves (openingOffset widens it). An opening of another size, centre or turn, through a slab or ceiling you name, or through one of the two only, is cut as an opening the stair owns, as given.",
+    description: "Create a staircase rising from a level, as the editor's stair tool builds one: straight, L (a flight, a landing as deep as the stair is wide, a flight turned 90°) or U (a flight, a landing across, a flight back beside the first). It rises to the level above and owns the floor opening it cuts in every floor it passes; when no level stands above, a blank one is made for it. toLevelId null makes a flight to no level (porch steps, a deck, a raised platform): it rises height, cuts nothing and makes no level. Refused with a code: a flight to or from a declared roof level, and a toLevelId that is not above the level it rises from.\n\nGEOMETRY (get this wrong and the stair pokes through a wall):\n- (x, z) is the middle of the bottom riser, where the flight starts. The first flight runs from there along the climb: at rotation 0 it covers x − width/2 .. x + width/2 and z .. z + its run.\n- rotation in degrees about Y: 0 climbs toward +Z, 90 → +X, 180 → −Z, 270 → −X. Point the climb into the room, away from the wall the bottom step sits against.\n- An L or U turns to the climber's left or right (turn). The result gives the whole footprint and the point the top step arrives at.\n- Keep 0.9 m clear at the foot and at the head of the flight, and the whole footprint inside one room on both levels (a hall is typical): read the room's outline first (get_zones).\n\nOPENINGS: by default the stair owns the opening over its flights and keeps it as the stair moves (openingOffset widens it). An opening of another size, centre or turn, through a slab or ceiling you name, or through one of the two only, is cut as an opening the stair owns, as given.",
     input: {
-        x: z.number().describe('X of the back-centre of the first step.'),
-        z: z.number().describe('Z of the back-centre of the first step.'),
+        x: z.number().describe('X of the middle of the bottom riser.'),
+        z: z.number().describe('Z of the middle of the bottom riser.'),
         rotation: measurement('angle', 'deg', {
-            description: 'The climb direction (default 0 = toward +Z; 90 = +X, 180 = −Z, 270 = −X).',
+            description: "The first flight's climb (default 0 = toward +Z; 90 = +X, 180 = −Z, 270 = −X).",
         }).optional(),
+        layout: z
+            .enum(['straight', 'l', 'u'])
+            .optional()
+            .describe('straight (default); l: a flight, a landing, a flight turned 90°; u: a flight, a landing across, a flight back beside the first.'),
+        turn: z
+            .enum(['left', 'right'])
+            .optional()
+            .describe("Which way an L or U turns, to the climber's left or right (default left)."),
+        lowerSteps: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("An L or U's risers in the first flight; the rest are in the last (default half)."),
         width: measurement('length', 'm', {
             positive: true,
             description: 'Side-to-side width, across the climb (default 1.0 m).',
         }).optional(),
         length: measurement('length', 'm', {
             positive: true,
-            description: "Horizontal run along the climb (default: from the stair's design targets, 0.28 m of going per riser, risers of at most 0.18 m).",
+            description: "The flights' horizontal run along the climb, landings aside (default: from the stair's design targets, 0.28 m of going per riser, risers of at most 0.18 m).",
         }).optional(),
         height: measurement('length', 'm', {
             positive: true,
@@ -55,15 +94,19 @@ export const createStairTool = {
         steps: z
             .number()
             .int()
-            .min(3)
+            .min(2)
             .optional()
-            .describe('Number of risers. Omit it to derive ~18 cm risers from the rise; pass it when the run was planned from a step count.'),
+            .describe('Number of risers in all. Omit it to derive ~18 cm risers from the rise; pass it when the run was planned from a step count.'),
         ...levelTarget,
-        toLevelId: NodeId.optional().describe('The level the flight arrives on. Default: the next level above, created when there is none.'),
-        railingMode: z
-            .enum(['none', 'left', 'right', 'both'])
+        toLevelId: NodeId.nullable()
+            .optional()
+            .describe("The level the flight arrives on. Default: the next level above, created when there is none. null: a flight to no level, rising height (default the storey's floor-to-floor height)."),
+        railingMode: StairRailingMode.optional().describe('Which sides have a railing, looking up the flight (default both).'),
+        railingStyle: StairRailingStyle.optional().describe('How the railings are built (default balusters): post-and-rail, cable (contemporary with a black railingMaterial), boards, glass or metal.'),
+        railingMaterial: z
+            .string()
             .optional()
-            .describe('Which sides have a railing, looking up the flight (default both).'),
+            .describe('A library material for the railings (library:<id>); an unknown one is refused.'),
         materialPreset: z
             .string()
             .optional()
@@ -81,11 +124,11 @@ export const createStairTool = {
         sourceCeilingId: NodeId.optional().describe('The ceiling it rises through. Default: the ceiling of the level it leaves.'),
         openingWidth: measurement('length', 'm', {
             positive: true,
-            description: 'The opening across the climb (default the flight width).',
+            description: "The opening across the climb (default the stair's footprint).",
         }).optional(),
         openingLength: measurement('length', 'm', {
             positive: true,
-            description: 'The opening along the climb (default the run length).',
+            description: "The opening along the climb (default the stair's footprint).",
         }).optional(),
         openingOffset: measurement('length', 'm', {
             min: 0,
@@ -95,9 +138,9 @@ export const createStairTool = {
             .array(z.number())
             .length(2)
             .optional()
-            .describe('The opening centre (x, z). Default: the middle of the flight.'),
+            .describe("The opening centre (x, z). Default: the middle of the stair's footprint."),
         openingRotation: measurement('angle', 'deg', {
-            description: "The opening's turn (default the flight's).",
+            description: "The opening's turn (default the stair's).",
         }).optional(),
     },
 };

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

@@ -1 +1 @@
-{"version":3,"file":"verify-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/verify-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAS5B,iGAAiG;AACjG,wBAAgB,iBAAiB,CAAC,SAAS,EAAE;IAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;IAChC,WAAW,EAAE,MAAM,CAAA;CACpB,QAEA;AAKD,eAAO,MAAM,eAAe;;;;oBAMb,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC;CAGvC,CAAA"}
+{"version":3,"file":"verify-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/verify-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAS5B,iGAAiG;AACjG,wBAAgB,iBAAiB,CAAC,SAAS,EAAE;IAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;IAChC,WAAW,EAAE,MAAM,CAAA;CACpB,QAEA;AAKD,eAAO,MAAM,eAAe;IAC1B,IAAI;IACJ,KAAK;aACD,WAAW;aAGX,KAAK,EAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC;CAGvC,CAAA"}