@pascal-app/core 1.0.3 → 1.0.5

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

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const searchMaterialsTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        queries: z.ZodArray<z.ZodObject<{
+            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<{
+                ceiling: "ceiling";
+                floor: "floor";
+                furniture: "furniture";
+                outdoor: "outdoor";
+                roof: "roof";
+                wall: "wall";
+            }>>;
+            offset: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    };
+};
+//# sourceMappingURL=search-materials.d.ts.map

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

@@ -0,0 +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;AAGvB,eAAO,MAAM,mBAAmB;IAC9B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BV,CAAA"}

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { MATERIAL_CATEGORIES, MATERIAL_SURFACES } from '../material-kinds.js';
+export const searchMaterialsTool = {
+    name: 'search_materials',
+    title: 'Search materials',
+    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()
+                .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(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 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

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+export declare const measureStairTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        stairId: z.ZodString;
+        available: z.ZodOptional<z.ZodObject<{
+            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>>;
+    };
+};
+export declare const fitStairTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        stairId: z.ZodString;
+        fitRun: z.ZodDefault<z.ZodBoolean>;
+        layout: z.ZodOptional<z.ZodEnum<{
+            l: "l";
+            straight: "straight";
+            u: "u";
+        }>>;
+        turn: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
+        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.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-angle": "equal-angle";
+            "equal-going": "equal-going";
+        }>>;
+        targets: z.ZodOptional<z.ZodObject<{
+            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>>;
+    };
+};
+export declare const createStairTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        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";
+        }>>;
+        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<[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<[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

@@ -0,0 +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;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

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+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';
+export const measureStairTool = {
+    name: 'measure_stair',
+    title: 'Measure stair',
+    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: 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',
+    description: 'Explicitly replace stair riser proportions with uniform risers from design targets. Optionally fit going by changing flight runs or arc sweep; preserves landing elevations. Optional straight, L or U layout replaces the flight chain with width-sized turning landings or quarter-turn winders. Winder going is measured along the selected walking line. One atomic edit.',
+    input: {
+        stairId: NodeId,
+        fitRun: z.boolean().default(false),
+        layout: z.enum(['straight', 'l', 'u']).optional(),
+        turn: z.enum(['left', 'right']).optional(),
+        width: measurement('length', 'm', { positive: true }).optional(),
+        landingDepth: measurement('length', 'm', { positive: true }).optional(),
+        turningStrategy: z.enum(['landing', 'winder']).optional(),
+        innerGap: measurement('length', 'm', { min: 0 }).optional(),
+        walkingLineOffset: measurement('length', 'm', { positive: true }).optional(),
+        division: z.enum(['equal-going', 'equal-angle']).optional(),
+        targets: designTargets.optional(),
+    },
+};
+export const createStairTool = {
+    name: 'create_stair',
+    title: 'Create stair',
+    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 middle of the bottom riser.'),
+        z: z.number().describe('Z of the middle of the bottom riser.'),
+        rotation: measurement('angle', 'deg', {
+            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: "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,
+            description: "Vertical rise. Omit it unless asked for a specific rise: the flight then follows the storey's floor-to-floor height and keeps tracking it.",
+        }).optional(),
+        steps: z
+            .number()
+            .int()
+            .min(2)
+            .optional()
+            .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.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('A library material for the railings (library:<id>); an unknown one is refused.'),
+        materialPreset: z
+            .string()
+            .optional()
+            .describe('A library material for the flight (library:<id>); an unknown one is refused.'),
+        name: z.string().optional().describe('Its name (default Staircase N).'),
+        createDestinationSlabOpening: z
+            .boolean()
+            .optional()
+            .describe('Cut the floor it arrives through (default true).'),
+        createSourceCeilingOpening: z
+            .boolean()
+            .optional()
+            .describe('Cut the ceiling of the floor it leaves (default true).'),
+        destinationSlabId: NodeId.optional().describe('The slab it arrives through. Default: the floor of the level it arrives on.'),
+        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 stair's footprint).",
+        }).optional(),
+        openingLength: measurement('length', 'm', {
+            positive: true,
+            description: "The opening along the climb (default the stair's footprint).",
+        }).optional(),
+        openingOffset: measurement('length', 'm', {
+            min: 0,
+            description: 'A margin round the opening on every side (default 0.08 m).',
+        }).optional(),
+        openingCenter: z
+            .array(z.number())
+            .length(2)
+            .optional()
+            .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 stair's).",
+        }).optional(),
+    },
+};

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

@@ -0,0 +1,13 @@
+import type { z } from 'zod';
+/** Adds inputs and a sentence of description to verify_scene, for a check registered with it. */
+export declare function extendVerifyScene(extension: {
+    input: Record<string, z.ZodType>;
+    description: string;
+}): void;
+export declare const verifySceneTool: {
+    name: string;
+    title: string;
+    readonly description: string;
+    readonly input: Record<string, z.ZodType>;
+};
+//# sourceMappingURL=verify-scene.d.ts.map

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

@@ -0,0 +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;IAC1B,IAAI;IACJ,KAAK;aACD,WAAW;aAGX,KAAK,EAAI,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC;CAGvC,CAAA"}

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

@@ -0,0 +1,21 @@
+/**
+ * `verify_scene`'s contract. Other modules extend it with an input and a sentence for the check
+ * they register (the photo's: `photo`), so it stays one tool agents know, with one contract on
+ * both surfaces, and imports none of them.
+ */
+const extensions = [];
+/** Adds inputs and a sentence of description to verify_scene, for a check registered with it. */
+export function extendVerifyScene(extension) {
+    extensions.push(extension);
+}
+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',
+    get description() {
+        return [DESCRIPTION, ...extensions.map((extension) => extension.description)].join(' ');
+    },
+    get input() {
+        return Object.assign({}, ...extensions.map((extension) => extension.input));
+    },
+};

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

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+/** 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;
+    description: string;
+    input: {
+        target: z.ZodOptional<z.ZodString>;
+        interior: z.ZodOptional<z.ZodObject<{
+            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";
+            "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";
+        }>>;
+        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.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        projection: z.ZodOptional<z.ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        camera: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+            position: z.ZodArray<z.ZodNumber>;
+            target: z.ZodArray<z.ZodNumber>;
+            fov: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+            aspect: z.ZodNumber;
+        }, 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>;
+        }, z.core.$loose>>;
+    };
+};
+//# sourceMappingURL=view-scene.d.ts.map

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

@@ -0,0 +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;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"}