@pascal-app/core 1.0.1 → 1.0.4

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const searchAssetsTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        queries: z.ZodArray<z.ZodObject<{
+            query: z.ZodString;
+            category: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    };
+};
+//# sourceMappingURL=assets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../src/agent-tools/assets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,gBAAgB;;;;;;;;;;CAmB5B,CAAA"}

package/dist/agent-tools/assets.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export const searchAssetsTool = {
+    name: 'search_assets',
+    title: 'Search assets',
+    description: "Search the item library (furniture, fixtures, lights, plants, outdoor) by keyword, several queries in one call; call it before placing an item to get a valid asset id. A query matches the items whose name, id, category or tags hold every one of its words. Returns one group per query, each item with its id, name, category, dimensions [width, height, depth] in metres and attachTo (null on the floor, else 'wall', 'wall-side' or 'ceiling'). Batch related lookups (sofa, coffee table, tv stand) instead of separate calls.",
+    input: {
+        queries: z
+            .array(z.object({
+            query: z.string().min(1).describe('Search words, e.g. "sofa", "dining chair", "lamp".'),
+            category: z
+                .string()
+                .optional()
+                .describe('Only items of this category (furniture, kitchen, bathroom, outdoor, …).'),
+        }))
+            .min(1)
+            .describe('One or more searches to run in a single call.'),
+    },
+};

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const clearSceneTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        reason: z.ZodString;
+    };
+};
+//# sourceMappingURL=clear-scene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"clear-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/clear-scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,cAAc;;;;;;;CAQ1B,CAAA"}

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export const clearSceneTool = {
+    name: 'clear_scene',
+    title: 'Clear the project',
+    description: 'Empty the project on purpose, back to the default scaffold: a site, a building and one level of the standard storey height. It is the only way to empty a project: a write that would empty it is refused (scene_wipe_blocked), since that is far more often an accident. Call it only when the person asked to start over, and say what they asked in reason.',
+    input: {
+        reason: z.string().min(1).describe('What the person asked for, in their words.'),
+    },
+};

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare const editCollectionTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        collectionId: z.ZodOptional<z.ZodString>;
+        template: z.ZodOptional<z.ZodEnum<{
+            roof: "roof";
+            lights: "lights";
+            windows: "windows";
+            doors: "doors";
+            electrical: "electrical";
+            plumbing: "plumbing";
+            framing: "framing";
+            masonry: "masonry";
+            cabinetry: "cabinetry";
+            "kitchen-cabinetry": "kitchen-cabinetry";
+        }>>;
+        name: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        add: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        remove: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        delete: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+export declare const listCollectionsTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        collectionId: z.ZodOptional<z.ZodString>;
+    };
+};
+//# sourceMappingURL=collections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/agent-tools/collections.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;CAoB9B,CAAA;AAED,eAAO,MAAM,mBAAmB;;;;;;;CAQ/B,CAAA"}

package/dist/agent-tools/collections.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { COLLECTION_TEMPLATE_IDS } from '../schema/collection-templates.js';
+import { NodeId } from './node-id.js';
+export const editCollectionTool = {
+    name: 'edit_collection',
+    title: 'Edit collection',
+    description: "Create, rename, recolour or delete a collection, or add and remove its elements. A collection is a named set of any scene elements (lights, windows, doors, columns, objects built with add_object…), listed in the editor's Collections; being in one changes nothing about the elements. Without collectionId the call works on the scene's collection with that template, or else that name, and creates it when there is none.",
+    input: {
+        collectionId: z.string().min(1).optional().describe('The collection to change.'),
+        template: z
+            .enum(COLLECTION_TEMPLATE_IDS)
+            .optional()
+            .describe('Start from a template, which gives the name and colour unless you pass them.'),
+        name: z.string().trim().min(1).optional().describe('Name of the collection, or its new name.'),
+        color: z.string().optional().describe('Colour, e.g. #f5b83d.'),
+        add: z.array(NodeId).optional().describe('Ids of the elements to add.'),
+        remove: z.array(NodeId).optional().describe('Ids of the elements to take out.'),
+        delete: z
+            .boolean()
+            .optional()
+            .describe('Delete the collection; its elements stay in the scene.'),
+    },
+};
+export const listCollectionsTool = {
+    name: 'list_collections',
+    title: 'List collections',
+    description: "List the scene's collections with their elements (id, name, type, level), and the templates a collection can start from.",
+    input: {
+        collectionId: z.string().min(1).optional().describe('Only this collection.'),
+    },
+};

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

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const addColumnTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        nodeId: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodEnum<{
+            three: "three";
+            bpy: "bpy";
+        }>>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        x: z.ZodOptional<z.ZodNumber>;
+        z: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        radius: 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>>>;
+        depth: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        style: z.ZodOptional<z.ZodEnum<{
+            plain: "plain";
+            faceted: "faceted";
+            fluted: "fluted";
+            "lathe-turned": "lathe-turned";
+            "dravidian-carved": "dravidian-carved";
+            cluster: "cluster";
+        }>>;
+        crossSection: z.ZodOptional<z.ZodEnum<{
+            round: "round";
+            square: "square";
+            rectangular: "rectangular";
+            octagonal: "octagonal";
+            "sixteen-sided": "sixteen-sided";
+        }>>;
+        level: z.ZodOptional<z.ZodString>;
+        y: z.ZodOptional<z.ZodNumber>;
+    };
+};
+//# sourceMappingURL=columns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"columns.d.ts","sourceRoot":"","sources":["../../src/agent-tools/columns.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DzB,CAAA"}

package/dist/agent-tools/columns.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { geometryMetaFields } from '../schema/geometry-metadata.js';
+import { scriptLanguage, scriptParams } from './add-object.js';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+export const addColumnTool = {
+    name: 'add_column',
+    title: 'Add column',
+    description: 'Add a structural or decorative column at (x, z), or rebuild one by nodeId. Native fields first; optional code uses the same module and conventions as add_object, with floor mount and its bottom centre at the support point. Params named height, width and depth drive the native size controls. Only add columns when requested.',
+    input: {
+        x: z.number().optional().describe('X position of the column center (meters)'),
+        z: z.number().optional().describe('Z position of the column center (meters)'),
+        height: measurement('length', 'm', {
+            positive: true,
+            description: 'Column height (default: 2.5).',
+        }).optional(),
+        radius: measurement('length', 'm', {
+            positive: true,
+            description: 'Radius when crossSection is "round" (default: 0.22).',
+        }).optional(),
+        width: measurement('length', 'm', {
+            positive: true,
+            description: 'Width when crossSection is "square" / "rectangular" (default: 0.44).',
+        }).optional(),
+        depth: measurement('length', 'm', {
+            positive: true,
+            description: 'Depth when crossSection is "square" / "rectangular" (default: 0.44).',
+        }).optional(),
+        rotation: measurement('angle', 'deg', {
+            description: 'Y-axis rotation (default: 0).',
+        }).optional(),
+        style: z
+            .enum(['plain', 'faceted', 'fluted', 'lathe-turned', 'dravidian-carved', 'cluster'])
+            .optional()
+            .describe("Visual style: 'plain' (default smooth pillar), 'faceted' (sharp prism faces), 'fluted' (vertical channels — classical), 'lathe-turned' (turned bands — porch / interior), 'dravidian-carved' (heavy carving — temple), 'cluster' (bundled colonnette — gothic)."),
+        crossSection: z
+            .enum(['round', 'square', 'rectangular', 'octagonal', 'sixteen-sided'])
+            .optional()
+            .describe("Plan shape: 'round' (default), 'square' (equal width/depth), 'rectangular' (independent width/depth), 'octagonal', 'sixteen-sided'."),
+        level: z
+            .string()
+            .optional()
+            .describe('Level id from list_levels; omitted uses the viewed or lowest level.'),
+        y: z
+            .number()
+            .optional()
+            .describe('Support point height above the level, in metres (default 0).'),
+        ...geometryMetaFields,
+        nodeId: NodeId.optional().describe('Rebuild this column with code, params or native size fields; get_source first when changing code.'),
+        code: z
+            .string()
+            .min(1)
+            .max(48_000)
+            .optional()
+            .describe('A module (three.js, or bpy with language) when the native fields cannot express the column. Same module and conventions as add_object; mount floor. Declare height, width and depth params for editable dimensions.'),
+        language: scriptLanguage,
+        params: scriptParams,
+    },
+};

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

@@ -0,0 +1,68 @@
+import type { z } from 'zod';
+/**
+ * MCP tool annotations. Hints for clients and for a host's display, never authorization: a host
+ * decides what a tool may do (write scope, retries, approvals) from its own review of the
+ * operation, not from what a contract declares about itself.
+ */
+export type AgentToolAnnotations = {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+};
+/**
+ * One agent tool as every surface registers it: the name and description the agent reads, and its
+ * input schema. Zod only, so it can be imported where the hosted chat declares its tools.
+ */
+export type AgentToolContract<Input extends Record<string, z.ZodType> = Record<string, z.ZodType>> = {
+    name: string;
+    title: string;
+    description: string;
+    input: Input;
+    annotations?: AgentToolAnnotations;
+};
+/**
+ * Where a plugin's tool runs. `'operation'`: a pure `AgentOperation` over the scene's nodes,
+ * exported from the plugin's `./agent-operations`, so any surface can run it, a server included.
+ * `'editor'`: it needs the live editor (a renderer, the plugin's own stores, the browser), so it
+ * runs in an editor tab open on the project; a surface without one refuses it or hands it to one.
+ */
+export type PluginAgentToolPlacement = 'operation' | 'editor';
+export type PluginAgentTool = AgentToolContract & {
+    runsIn: PluginAgentToolPlacement;
+    /** The call produces a view (a drawing, a report) the host may open beside the scene. */
+    rendersView?: boolean;
+    /** How long a call may take, in milliseconds; the host clamps it to its own limits. */
+    timeoutMs?: number;
+    /**
+     * The plugin asks for this tool in a chat only (it needs the conversation, e.g. it asks the
+     * person something). A request the host reviews, not a way around surface parity.
+     */
+    chatOnly?: boolean;
+};
+/** Knowledge an agent loads on demand: the index shows `name` and `summary`, a load returns `body`. */
+export type PluginSkill = {
+    name: string;
+    summary: string;
+    body: string;
+};
+/**
+ * Everything a plugin contributes to an agent, exported from its `./agent-tools` entry, which,
+ * like this module, imports zod and its own dependency-free files only.
+ */
+export type PluginAgentTools = {
+    /** The `Plugin.id` these tools belong to; a host offers them only where the plugin is installed. */
+    pluginId: string;
+    /** The shape of this object. */
+    apiVersion: 1;
+    /**
+     * The revision of the plugin's contracts. Bump it whenever a tool's name, input or meaning
+     * changes, so a host can pin the exact contracts a run was offered and refuse a stale executor.
+     */
+    version: string;
+    tools: readonly PluginAgentTool[];
+    skills?: readonly PluginSkill[];
+    /** Guidance added to the agent's instructions while the plugin is installed; the host may cap it. */
+    instructions?: string;
+};
+//# sourceMappingURL=contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/agent-tools/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAC/F;IACE,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,KAAK,CAAA;IACZ,WAAW,CAAC,EAAE,oBAAoB,CAAA;CACnC,CAAA;AAEH;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAAG,WAAW,GAAG,QAAQ,CAAA;AAE7D,MAAM,MAAM,eAAe,GAAG,iBAAiB,GAAG;IAChD,MAAM,EAAE,wBAAwB,CAAA;IAChC,yFAAyF;IACzF,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,uGAAuG;AACvG,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzE;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,oGAAoG;IACpG,QAAQ,EAAE,MAAM,CAAA;IAChB,gCAAgC;IAChC,UAAU,EAAE,CAAC,CAAA;IACb;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,SAAS,eAAe,EAAE,CAAA;IACjC,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,CAAA;IAC/B,qGAAqG;IACrG,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA"}

package/dist/agent-tools/contract.js

@@ -0,0 +1 @@
+export {};

package/dist/agent-tools/create-room.d.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+export declare const createRoomTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        name: z.ZodString;
+        polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+        color: z.ZodOptional<z.ZodString>;
+        wallHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        wallThickness: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        outdoor: z.ZodOptional<z.ZodBoolean>;
+        doors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            width: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            hingesSide: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                right: "right";
+            }>>;
+            swingDirection: z.ZodOptional<z.ZodEnum<{
+                inward: "inward";
+                outward: "outward";
+            }>>;
+            style: z.ZodOptional<z.ZodEnum<{
+                glass: "glass";
+                french: "french";
+                barn: "barn";
+                panel: "panel";
+                shaker: "shaker";
+                modern: "modern";
+                "paneled-glass": "paneled-glass";
+                "six-panel": "six-panel";
+                craftsman: "craftsman";
+                "half-louvered": "half-louvered";
+            }>>;
+            wallIndex: z.ZodNumber;
+            t: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        windows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            width: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            sillHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            style: z.ZodOptional<z.ZodEnum<{
+                sliding: "sliding";
+                casement: "casement";
+                "double-hung": "double-hung";
+                single: "single";
+                grid: "grid";
+                "triple-hung": "triple-hung";
+                "tall-grid": "tall-grid";
+                "wide-grid": "wide-grid";
+                "horizontal-bands": "horizontal-bands";
+                transom: "transom";
+                picture: "picture";
+            }>>;
+            wallIndex: z.ZodNumber;
+            t: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+    };
+};
+//# sourceMappingURL=create-room.d.ts.map

package/dist/agent-tools/create-room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-room.d.ts","sourceRoot":"","sources":["../../src/agent-tools/create-room.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsBvB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmF1B,CAAA"}

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

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { DOOR_STYLES, WINDOW_STYLES } from '../building/opening-style-presets.js';
+import { levelTarget } from './levels.js';
+import { measurement } from './measurement.js';
+// A list of two, not a tuple: a tuple's list-form schema is refused by some clients.
+const point = z.array(z.number()).length(2);
+const onEdge = {
+    wallIndex: z
+        .number()
+        .int()
+        .min(0)
+        .describe('The polygon edge it sits on: edge i runs from corner i to corner i + 1.'),
+    t: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe('Position along that edge: 0 = its start, 1 = its end (default 0.5).'),
+};
+export const createRoomTool = {
+    name: 'create_room',
+    title: 'Create room',
+    description: "Create a room on a level from its polygon: a wall per edge, an edge a wall already runs along reusing that wall (rooms share their boundary with their neighbour), and the room zone that names it. The floor plate and the ceiling are derived from the room — never author a slab or a ceiling for it. Declare the room's doors and windows in the same call by polygon edge (wallIndex) and t along it, no wall ids needed; each is placed with add_door's and add_window's rules, and one that cannot be is skipped and listed in skippedOpenings with its code. Returns zoneId, slabId, ceilingId, wallIds in edge order (null where no wall), doorIds, windowIds. outdoor: true draws a terrace instead: separators where no wall runs, no walls of its own and no ceiling.",
+    input: {
+        ...levelTarget,
+        name: z.string().min(1).describe('Room name, e.g. "Bedroom", "Kitchen".'),
+        polygon: z.array(point).min(3).describe('The corners in order, as [x, z] in metres.'),
+        color: z
+            .string()
+            .optional()
+            .describe('Hex colour of the room zone, e.g. "#22c55e"; omit it and the room gets a palette colour picked from its id.'),
+        wallHeight: measurement('length', 'm', {
+            positive: true,
+            description: "Height of the walls it builds (default: the storey's).",
+        }).optional(),
+        wallThickness: measurement('length', 'm', {
+            positive: true,
+            description: 'Thickness of the walls it builds.',
+        }).optional(),
+        outdoor: z
+            .boolean()
+            .optional()
+            .describe("true for an outdoor room (a terrace): closed with separators (the editor's Separator: a room boundary with no wall) where no wall runs, no walls of its own and no ceiling."),
+        doors: z
+            .array(z.object({
+            ...onEdge,
+            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(),
+            hingesSide: z.enum(['left', 'right']).optional().describe('Hinge side (default left).'),
+            swingDirection: z
+                .enum(['inward', 'outward'])
+                .optional()
+                .describe('Which way the door opens (default inward).'),
+            style: z
+                .enum(DOOR_STYLES)
+                .optional()
+                .describe("Visual preset: 'panel' (default raised-panel), 'glass' (mostly glass), 'modern' (flush slab), 'paneled-glass' (glass top, panel bottom — an entry door), 'french' (two narrow glass leaves), 'shaker' (one flat panel), 'six-panel' (3 × 2 traditional grid), 'craftsman' (4 stacked vertical panels), 'half-louvered' (slats on top, panel below — closet, laundry), 'barn' (wide recessed panel). One style per room type across the home; the entry door may differ."),
+        }))
+            .optional()
+            .describe('The entry door and the doors to the rooms next to it.'),
+        windows: z
+            .array(z.object({
+            ...onEdge,
+            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 0.9 m).',
+            }).optional(),
+            style: z
+                .enum(WINDOW_STYLES)
+                .optional()
+                .describe("Visual preset: 'single' (default single pane), 'double-hung', 'triple-hung' (stacked sashes), 'casement' (two panes side by side), 'sliding' (three side by side — wide), 'grid' (2 × 2), 'tall-grid' (2 × 3), 'wide-grid' (3 × 2), 'horizontal-bands' (4 stacked bands), 'transom' (a small row over a larger pane), 'picture' (an alias of 'single'). One style for all the windows of a room, and per room type across the home."),
+        }))
+            .optional()
+            .describe('Windows, on exterior edges only: not on an edge shared with another room.'),
+    },
+};

package/dist/agent-tools/find-by-type.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export declare const findByTypeTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        type: z.ZodString;
+        levelId: z.ZodOptional<z.ZodString>;
+    };
+};
+//# sourceMappingURL=find-by-type.d.ts.map

package/dist/agent-tools/find-by-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-by-type.d.ts","sourceRoot":"","sources":["../../src/agent-tools/find-by-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,cAAc;;;;;;;;CAY1B,CAAA"}

package/dist/agent-tools/find-by-type.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { NodeId } from './node-id.js';
+export const findByTypeTool = {
+    name: 'find_by_type',
+    title: 'Find by type',
+    description: "Find everything of one type in the scene, wherever it lives: nodes of that kind (column, door, window, wall, stair…), items of that category, lights (any item that emits light), and typed parts inside scripted objects, windows and doors (a porch's columns, a window's grille). Parts are read-only: they come back with their object's id, the part id and, for objects directly on a level, its bounds in level coordinates; edit them through their object.",
+    input: {
+        type: z
+            .string()
+            .min(1)
+            .describe('What to find, one word: light, column, door, window, beam, panel, railing, trim…'),
+        levelId: NodeId.optional().describe('Only this level. Default: every level.'),
+    },
+};

package/dist/agent-tools/furnish-room.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const FURNISHED_ROOM_TYPES: readonly ["bedroom", "kitchen", "bathroom", "living", "dining", "hallway", "entry", "laundry", "storage"];
+export declare const furnishRoomTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        polygon: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+        roomType: z.ZodEnum<{
+            entry: "entry";
+            bedroom: "bedroom";
+            kitchen: "kitchen";
+            bathroom: "bathroom";
+            living: "living";
+            dining: "dining";
+            hallway: "hallway";
+            laundry: "laundry";
+            storage: "storage";
+        }>;
+        doorWallIndex: z.ZodOptional<z.ZodNumber>;
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        zoneId: z.ZodOptional<z.ZodString>;
+    };
+};
+//# sourceMappingURL=furnish-room.d.ts.map

package/dist/agent-tools/furnish-room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"furnish-room.d.ts","sourceRoot":"","sources":["../../src/agent-tools/furnish-room.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB,2GAUvB,CAAA;AAEV,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CAyB3B,CAAA"}

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

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { levelTarget } from './levels.js';
+import { NodeId } from './node-id.js';
+export const FURNISHED_ROOM_TYPES = [
+    'bedroom',
+    'kitchen',
+    'bathroom',
+    'living',
+    'dining',
+    'hallway',
+    'entry',
+    'laundry',
+    'storage',
+];
+export const furnishRoomTool = {
+    name: 'furnish_room',
+    title: 'Furnish room',
+    description: "Furnish a room for its type from the host's item catalog: the bed, sofa, counters or toilet against the wall facing the door, the rest along a side wall, each set off its wall by its own depth. Name the room by zoneId (its level and outline come with it), or give its polygon and level. The door wall is the edge a door of the room stands on, else doorWallIndex, else edge 0. Nothing lands in a door's clear zone or on another item: a piece that does not fit is nudged, else skipped, and skipped says why. Items stand on the room's level.",
+    input: {
+        zoneId: NodeId.optional().describe('The room: zoneId from create_room, or an id from get_zones.'),
+        ...levelTarget,
+        polygon: z
+            .array(z.array(z.number()).length(2))
+            .min(3)
+            .optional()
+            .describe("The room's corners as [x, z] in metres, when there is no zoneId."),
+        roomType: z.enum(FURNISHED_ROOM_TYPES).describe('What the room is for.'),
+        doorWallIndex: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe('The polygon edge (i → i + 1) to treat as the door wall: for a room with no door yet, or to override the one found.'),
+    },
+};