@pascal-app/core 1.0.3 → 1.0.5

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

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+import { measurement } from './measurement.js';
+const point = z.array(z.number()).length(3);
+/** Sides on the plan's compass: north is its top edge (z grows south, x east). */
+export const COMPASS_SIDES = [
+    '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 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: 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 storey in the scene, walls and roofs.'),
+        interior: z
+            .object({
+            levelId: z.string().min(1).optional(),
+            zoneId: z.string().min(1).optional(),
+        })
+            .optional()
+            .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: 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: 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
+            .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("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
+                .string()
+                .min(1)
+                .max(8_000_000)
+                .describe('The photo as a data:image/...;base64 URL (read the file and encode it); in the chat, the URL of a file the user attached works too.'),
+            region: z
+                .array(z.number().min(0))
+                .length(4)
+                .describe("[left, top, right, bottom] in the photo's pixels: the element to compare."),
+        })
+            .optional()
+            .describe("The photo's crop of the element the view frames, returned beside it in the same call: a door's glass, a lamp's shape, a window's panes, at detail scale, to say what differs."),
+    },
+};

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

@@ -0,0 +1,167 @@
+import { z } from 'zod';
+export declare const addDoorTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        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<{
+            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";
+        }>>;
+        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";
+        }>>;
+        hingesSide: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
+        handleSide: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
+        swingDirection: z.ZodOptional<z.ZodEnum<{
+            inward: "inward";
+            outward: "outward";
+        }>>;
+        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: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        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<{
+            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";
+        }>>;
+        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: {
+    ok: z.ZodLiteral<true>;
+    wallId: z.ZodString;
+    localX: z.ZodNumber;
+    t: z.ZodNumber;
+    wallLength: z.ZodNumber;
+    clamped: z.ZodBoolean;
+    coordinateSystem: z.ZodLiteral<"wall-local-meters">;
+    message: z.ZodString;
+    achieved: z.ZodObject<{
+        created: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        updated: z.ZodNumber;
+        deleted: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        unchanged: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>;
+    doorId: z.ZodString;
+};
+export declare const addWindowOutput: {
+    ok: z.ZodLiteral<true>;
+    wallId: z.ZodString;
+    localX: z.ZodNumber;
+    t: z.ZodNumber;
+    wallLength: z.ZodNumber;
+    clamped: z.ZodBoolean;
+    coordinateSystem: z.ZodLiteral<"wall-local-meters">;
+    message: z.ZodString;
+    achieved: z.ZodObject<{
+        created: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        updated: z.ZodNumber;
+        deleted: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-openings.d.ts","sourceRoot":"","sources":["../../src/agent-tools/wall-openings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwDvB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDzB,CAAA;AAkBD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAA2C,CAAA;AAErE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAI3B,CAAA"}

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

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+import { DOOR_STYLES, WINDOW_STYLES } from '../building/opening-style-presets.js';
+import { geometryMetaFields } from '../schema/geometry-metadata.js';
+import { DoorType, WindowType } from '../schema/nodes/opening-types.js';
+import { achievedOutput } from './achieved.js';
+import { scriptLanguage, scriptParams } from './add-object.js';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+const placement = {
+    t: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe('Position along the wall, 0..1: 0 = start, 0.5 = centre, 1 = end.'),
+    position: z.number().min(0).max(1).optional().describe('Same as t.'),
+    force: z
+        .boolean()
+        .optional()
+        .describe('Place it even where it overlaps another door, window or wall item, like holding Alt in the editor. Only when the person asks for the overlap.'),
+};
+const script = (kind) => ({
+    code: z
+        .string()
+        .min(1)
+        .max(48_000)
+        .optional()
+        .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,
+});
+const outline = (archDefault) => ({
+    openingShape: z
+        .enum(['rectangle', 'rounded', 'arch'])
+        .optional()
+        .describe('Outline of the opening: rectangle (default), rounded top corners, or arch (round top).'),
+    archHeight: measurement('length', 'm', {
+        positive: true,
+        description: `Rise of the arch above its straight sides, within height (arch only; default ${archDefault}).`,
+    }).optional(),
+    cornerRadius: measurement('length', 'm', {
+        positive: true,
+        description: 'Radius of the rounded top corners (rounded only; default 0.15 m).',
+    }).optional(),
+});
+export const addDoorTool = {
+    name: 'add_door',
+    title: 'Add door',
+    description: 'Add a door to an existing straight wall at t (0..1 along it), or a passage with no leaf (openingKind opening: a cased opening, an arch). The door slides to stay on the wall and reports clamped. Refused with a code, as in the editor: curved walls, walls shorter than the door, and overlapping another door, window or wall item unless force is set. Match the reference with the outline (rectangle, rounded, arch), doorType and style; what they cannot express (glass strips, a pattern of lites, carved panels) is written as a script in code, never left as not possible.',
+    input: {
+        wallId: NodeId.optional().describe('The wall to add the door to.'),
+        nodeId: NodeId.optional().describe('Rebuild this door instead of adding one: new code and/or params (get_source provides current code when needed). Its native fields change with update_node.'),
+        ...placement,
+        width: measurement('length', 'm', {
+            positive: true,
+            description: 'Door width (default 0.9 m).',
+        }).optional(),
+        height: measurement('length', 'm', {
+            positive: true,
+            description: 'Door height (default 2.1 m).',
+        }).optional(),
+        openingKind: z
+            .enum(['door', 'opening'])
+            .optional()
+            .describe("door (default), or opening: a passage with no leaf, framed or arched by the outline, as the editor's door panel offers."),
+        hingesSide: z.enum(['left', 'right']).optional().describe('Hinge side (default left).'),
+        handleSide: z
+            .enum(['left', 'right'])
+            .optional()
+            .describe('Handle side (default: opposite the hinges).'),
+        swingDirection: z
+            .enum(['inward', 'outward'])
+            .optional()
+            .describe('Which way the door opens (default inward).'),
+        ...outline('0.45 m'),
+        ...script('door'),
+        doorType: DoorType.optional().describe('How it opens (default hinged); garage types for garage doors.'),
+        style: z
+            .enum(DOOR_STYLES)
+            .optional()
+            .describe('Visual preset (panels only, never the size); same presets as create_room doors[].'),
+    },
+};
+export const addWindowTool = {
+    name: 'add_window',
+    title: 'Add window',
+    description: "Add a window to an existing straight wall at t (0..1 along it), centred vertically on the wall, or on sillHeight above the floor when given. It slides to stay on the wall and under the wall's ceiling, and reports clamped. Refused with a code, as in the editor: curved walls, walls shorter than the window, overlapping another door, window or wall item unless force is set, and a style on a window that is not Fixed (style_needs_fixed_window). Match the reference with the outline (rectangle, rounded, arch), windowType and panes (columns × rows, or a style); what they cannot express (glass strips, leaded lites, a feature frame) is written as a script in code, never left as not possible.",
+    input: {
+        wallId: NodeId.optional().describe('The wall to add the window to.'),
+        nodeId: NodeId.optional().describe('Rebuild this window instead of adding one: new code and/or params (get_source provides current code when needed). Its native fields change with update_node.'),
+        ...placement,
+        width: measurement('length', 'm', {
+            positive: true,
+            description: 'Window width (default 1.5 m).',
+        }).optional(),
+        height: measurement('length', 'm', {
+            positive: true,
+            description: 'Window height (default 1.5 m).',
+        }).optional(),
+        sillHeight: measurement('length', 'm', {
+            min: 0,
+            description: 'Height from the floor to the bottom of the window (default: centred vertically on the wall).',
+        }).optional(),
+        ...outline('0.35 m'),
+        ...script('window'),
+        windowType: WindowType.optional().describe('How it opens (default fixed).'),
+        columns: z
+            .number()
+            .int()
+            .min(1)
+            .max(12)
+            .optional()
+            .describe("Panes across, equal widths; overrides the style's panes."),
+        rows: z
+            .number()
+            .int()
+            .min(1)
+            .max(12)
+            .optional()
+            .describe("Panes up, equal heights; overrides the style's panes."),
+        style: z
+            .enum(WINDOW_STYLES)
+            .optional()
+            .describe("Visual preset of a Fixed window's panes (never the size); same presets as create_room windows[]. Fixed windows only: an operable window draws its own sashes."),
+    },
+};
+/**
+ * What add_door and add_window answer, on every surface: one result from the core operation, which
+ * the MCP and the chat pass through as it is. `localX` is metres along the wall from its start.
+ */
+const openingOutput = {
+    ok: z.literal(true),
+    wallId: z.string(),
+    localX: z.number(),
+    t: z.number(),
+    wallLength: z.number(),
+    clamped: z.boolean(),
+    coordinateSystem: z.literal('wall-local-meters'),
+    message: z.string(),
+    achieved: achievedOutput,
+};
+export const addDoorOutput = { doorId: z.string(), ...openingOutput };
+export const addWindowOutput = {
+    windowId: z.string(),
+    ...openingOutput,
+    sillHeight: z.number().optional(),
+};

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

@@ -0,0 +1,21 @@
+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<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+export declare const addWallTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        start: z.ZodArray<z.ZodNumber>;
+        end: z.ZodArray<z.ZodNumber>;
+        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

@@ -0,0 +1 @@
+{"version":3,"file":"walls.d.ts","sourceRoot":"","sources":["../../src/agent-tools/walls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;GAGG;AACH,eAAO,MAAM,uBAAuB,4FAGlC,CAAA;AAKF,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAwBvB,CAAA"}

package/dist/agent-tools/walls.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { FOUNDATION_BY_REGION_NOTE } from '../lib/foundation-construction.js';
+import { levelTarget } from './levels.js';
+import { measurement } from './measurement.js';
+/**
+ * A wall's bend: a rounded corner could only be made with apply_patch, its sign documented
+ * nowhere.
+ */
+export const WALL_CURVE_OFFSET_INPUT = measurement('length', 'm', {
+    description: "Bends the wall into an arc: the sagitta, from the middle of the straight line start→end to the middle of the arc. Positive bows the middle toward the back face (the −normal side, normal (−Δz, Δx) of start→end), the arc's centre on the front side; negative the other way. At most half the chord (a half circle); more is clamped. A quarter round of radius r at a corner: end both walls r short of the corner and join their ends with an arc of curveOffset ±0.293·r, the sign that bows it outward.",
+});
+const planPoint = (end) => z.array(z.number()).length(2).describe(`[x, z] ${end} point in level coordinates (metres).`);
+export const addWallTool = {
+    name: 'add_wall',
+    title: 'Add wall',
+    description: 'Add a single wall between two points on a level, straight or, with curveOffset, an arc. Refused with a code: a level that is not a storey (a declared roof level), and a wall shorter than 1 cm. On a level below grade, a wall against the ground (on the outline of the walls of the level) is a foundation wall, ' +
+        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; 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,
+            description: "Wall height (default: the storey's height).",
+        }).optional(),
+        curveOffset: WALL_CURVE_OFFSET_INPUT.optional(),
+        ...levelTarget,
+    },
+};

package/dist/agent-tools/write-target.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Where a write went, on every surface: the project it reached, or `null` and `unsaved` on a
+ * scratch scene no project holds, so an agent that missed a load error does not build on into
+ * nothing (add_wall answered ok with no project bound). Its own key: a result's
+ * `note` is the operation's.
+ */
+export declare const NOT_SAVED_NOTE = "Not saved to any project: create_project or load_scene first, or save_scene to keep it.";
+export declare function writeTarget(project: string | null): {
+    project: string | null;
+    unsaved?: string;
+};
+//# sourceMappingURL=write-target.d.ts.map

package/dist/agent-tools/write-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-target.d.ts","sourceRoot":"","sources":["../../src/agent-tools/write-target.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,cAAc,4FACgE,CAAA;AAE3F,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG;IAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAEhG"}

package/dist/agent-tools/write-target.js

@@ -0,0 +1,10 @@
+/**
+ * Where a write went, on every surface: the project it reached, or `null` and `unsaved` on a
+ * scratch scene no project holds, so an agent that missed a load error does not build on into
+ * nothing (add_wall answered ok with no project bound). Its own key: a result's
+ * `note` is the operation's.
+ */
+export const NOT_SAVED_NOTE = 'Not saved to any project: create_project or load_scene first, or save_scene to keep it.';
+export function writeTarget(project) {
+    return { project, ...(project ? {} : { unsaved: NOT_SAVED_NOTE }) };
+}