@pascal-app/core 1.0.3 → 1.0.5

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

@@ -0,0 +1 @@
+{"version":3,"file":"author-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/author-scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqBvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6D7B,CAAA;AAeF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4D1B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;iBAsC1B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;iBAqB1B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;;;iBAO5B,CAAA;AAEF,eAAO,MAAM,eAAe;;;;;;;;iBAwB1B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;iBAc3B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW3B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQ7B,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,eAAO,MAAM,eAAe;;;;;QAKxB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACP,MAAM;QAON,OAAO;QAOP,OAAO;QAMP,UAAU;QAMV,OAAO;;;QAEM,eAAe;;CAC/B,CAAA"}

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

@@ -0,0 +1,252 @@
+import { z } from 'zod';
+import { DOOR_STYLES, WINDOW_STYLES } from '../building/opening-style-presets.js';
+import { DoorType, WindowType } from '../schema/nodes/opening-types.js';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+const DESCRIPTION = `Turn a whole design you wrote as free three.js into an editable Pascal scene, in one call. You read your own module however you like (its source, running it and reading the objects, both) and hand over a conversion payload: levels, walls with their openings, rooms, slabs, columns, railings, every piece of furniture as an authored object with its own module, and lights. Pascal does the rest server-side: compiles and stores each item, places it, derives the rooms and their floors, paints, runs its checks, saves, and answers with a gate report you iterate against. Nothing you hand over is silently dropped: what cannot be placed comes back by name with a reason, and what Pascal corrected (a wall end snapped onto the centerline it meets) is listed.
+
+Coordinates: metres, plan x/z, Y up, each level's floor at y = 0 in its own frame. A wall is its centerline; walls meet where centerlines meet, so end a partition on the centerline of the wall it runs into. An opening's 'along' is measured from the wall's start to the opening's centre; give each opening its type (how it opens) and style (its look), or its own module for a shape they cannot express. An item's position is where its bottom centre stands; its module follows the add_object contract (metres, Y up, built in its installed orientation; at most 300k triangles and 32 materials per item; name materials slot_<finish>; drawers, doors and lids as animation clips; a THREE light named light:<id> where a bulb is). A hex colour is written as an exact material, one per distinct colour. Pascal builds a wall's cap, the floor plate and the ceiling itself: fold a module's caps, underlays and floor planks into the wall, the room's floor finish and the room (say so in notes), never into slabs or regions: baseboards are the wall's skirting, a plank or tile floor is the room's floorCode, tiles, panelling or boards on a wall are its faceLeft / faceRight (or the room's wallCode); a slab is a terrace, a platform, a balcony. Build the building as it is built: a wall at its real height, nothing lowered or removed for viewing.
+
+The report says what was written, what Pascal defaulted (defaults: a window with no type is fixed and cannot open), what it warns about but wrote (warnings: thin slabs, too many slabs or regions) and what it refused (defects, by your ids).
+
+Call again with the same scene and a corrected payload to update the previous conversion (replace: true). Stable element identities and manual changes are retained; overlapping changes are refused. An existing building without a conversion baseline is never cleared.`;
+const plan = (what) => z.array(z.number()).length(2).describe(`[x, z] ${what} in plan metres.`);
+const xyz = (what) => z.array(z.number()).length(3).describe(`[x, y, z] ${what} in metres, y above the level's floor.`);
+const length = (description, opts = {}) => measurement('length', 'm', { description, ...opts });
+export const authorSceneOpening = z.object({
+    kind: z.enum(['door', 'window']),
+    along: length("From the wall's start to the opening's centre, along the centerline."),
+    width: length('Opening width.', { positive: true }),
+    height: length('Opening height.', { positive: true }),
+    sill: length('Bottom of the opening above the floor; 0 for a door or floor-to-ceiling glazing (default 0).', { default: 0 }),
+    name: z.string().max(80).optional(),
+    type: z
+        .enum([...DoorType.options, ...WindowType.options.filter((t) => t !== 'sliding')])
+        .optional()
+        .describe('How it opens. A door: hinged (default), double (two leaves), french (two glazed leaves), folding, pocket, barn, sliding, garage-sectional, garage-rollup, garage-tiltup. A window: fixed (default; cannot open), sliding, casement, awning, hopper, single-hung, double-hung, bay, bow, louvered. Give it: a window with no type is written fixed.'),
+    style: z
+        .enum([...DOOR_STYLES, ...WINDOW_STYLES])
+        .optional()
+        .describe("Its look, by name. A door's leaf: panel (default), glass, modern, paneled-glass, french, shaker, six-panel, craftsman, half-louvered, barn. A fixed window's panes: single (default), double-hung, triple-hung, casement, sliding, grid, tall-grid, wide-grid, horizontal-bands, transom, picture; an operable window draws its own sashes, so a style on one is dropped and reported."),
+    leaves: z
+        .number()
+        .int()
+        .min(1)
+        .max(4)
+        .optional()
+        .describe("A door's leaves, 1 to 4 (default: what its type has; 2 for double, french and sliding)."),
+    code: z
+        .string()
+        .min(1)
+        .max(48_000)
+        .optional()
+        .describe("A three.js module for an opening type and style cannot express (an arched double door, a round window): the add_door / add_window code contract, mount 'wall', a cutout mesh the wall cuts, an open clip unless it is fixed. Width and height are what it builds; type keeps its meaning (default hinged for a door, fixed for a window), style is ignored. Compiled and stored as an item's module is."),
+    color: z
+        .string()
+        .optional()
+        .describe('Exact #rrggbb for a door’s panel and frame or a window’s frame (default: the opening’s own finish).'),
+    frameColor: z
+        .string()
+        .optional()
+        .describe('Exact #rrggbb for the frame (default: color, or the opening’s own finish when color is absent).'),
+    hinge: z
+        .enum(['start', 'end'])
+        .optional()
+        .describe("Which end of the wall the door's hinge is nearer (default start). The handle goes on the opposite edge."),
+    swing: z
+        .enum(['front', 'back'])
+        .optional()
+        .describe("The side the door opens towards: the wall's front or back face."),
+});
+const WALL_FACE_MODULE = "a three.js module that builds this face's finish (tiles with joints, panelling, boards) for exactly the face: it receives params.outline, params.holes (its doors and windows), params.base and params.thickness in wall-local metres (x along the wall from its start, y up from the face's base, z out of the face) and lays the finish out: Pascal cuts the build to the outline and its openings, so tiles and boards may run past the edges and over the doors and windows (the holes are there for a layout that wants them, tiles centred on a window); Pascal rebuilds it when the wall or its openings change";
+const faceToHeight = (whose) => length(`Where ${whose} stops, metres up from the face's base (default: the full face).`, {
+    positive: true,
+}).optional();
+const authorSceneWallFace = z.object({
+    code: z.string().min(1).max(48_000).describe(`The face's finish: ${WALL_FACE_MODULE}.`),
+    toHeight: faceToHeight('the finish'),
+});
+export const authorSceneWall = z.object({
+    id: z
+        .string()
+        .min(1)
+        .max(64)
+        .describe('Your own id, unique across every wall and item on all levels.'),
+    start: plan('start'),
+    end: plan('end'),
+    height: length('Wall height.', { positive: true }),
+    thickness: length('Wall thickness.', { positive: true }),
+    color: z
+        .string()
+        .optional()
+        .describe('Paint for both faces: #rrggbb, written as an exact material, or a library ref (library:<id>) from search_materials.'),
+    colorLeft: z
+        .string()
+        .optional()
+        .describe("Paint for the face on the left when looking from start to end, same forms as color; over color. The left is the wall's front."),
+    colorRight: z
+        .string()
+        .optional()
+        .describe('Paint for the face on the right when looking from start to end, same forms as color; over color.'),
+    openings: z.array(authorSceneOpening).optional(),
+    skirting: z
+        .object({
+        height: length('Skirting height up the face (default 0.1 m).', {
+            default: 0.1,
+            positive: true,
+        }),
+        depth: length('How far it stands proud of the face (default 0.012 m).', {
+            default: 0.012,
+            positive: true,
+        }),
+        color: z
+            .string()
+            .optional()
+            .describe("#rrggbb, written as an exact material, or library:<id> (default: the skirting's own finish as Pascal draws it)."),
+    })
+        .optional()
+        .describe("The wall's skirting (baseboard), native on the wall: it runs along the faces a room stands on, steps with the floor and breaks at doors. Give it here, never as an item."),
+    faceLeft: authorSceneWallFace
+        .optional()
+        .describe(`The face on the left looking from start to end (the front, colorLeft's face), built by ${WALL_FACE_MODULE}; colorLeft stays the paint under it. Over the room's wallCode. The report warns when the build leaves part of the face uncovered.`),
+    faceRight: authorSceneWallFace
+        .optional()
+        .describe(`The face on the right looking from start to end (colorRight's face), built by ${WALL_FACE_MODULE}; colorRight stays the paint under it. Over the room's wallCode. The report warns when the build leaves part of the face uncovered.`),
+});
+export const authorSceneRoom = z.object({
+    name: z
+        .string()
+        .min(1)
+        .max(80)
+        .describe("The room's name as a person would say it (Bedroom 2, Salle de bains, Living + kitchen)."),
+    seed: plan('a point inside the room'),
+    floor: z
+        .string()
+        .optional()
+        .describe("The floor's material: a library ref (library:<id>) from search_materials, or #rrggbb for an exact flat colour."),
+    floorRegions: z
+        .array(z.object({ polygon: z.array(plan('vertex')).min(3), finish: z.string() }))
+        .default([])
+        .describe('Parts of the floor in another finish (the kitchen tiles inside an open-plan room), library:<id> or #rrggbb. Regions are fixed polygons that do not follow a resize: one region per finish, never one per plank.'),
+    floorCode: z
+        .string()
+        .min(1)
+        .max(48_000)
+        .optional()
+        .describe("A three.js module that builds the floor finish for the room's polygon: it receives params.polygon, params.holes and params.elevation (level coordinates, metres) and lays out the planks, tiles or boards: Pascal cuts the build to the polygon and its holes, so a row may run past the edges (the holes are there for a layout that wants them). Pascal rebuilds it when the room changes; floor stays the fallback finish. The report warns when the build leaves part of the floor uncovered."),
+    wallCode: z
+        .string()
+        .min(1)
+        .max(48_000)
+        .optional()
+        .describe(`The finish of every wall face that looks into this room (the faces its floor meets, where the skirting runs), each built by ${WALL_FACE_MODULE}. A wall's own faceLeft / faceRight wins over it. The report warns when the build leaves part of a face uncovered.`),
+    wallToHeight: faceToHeight("the room's wallCode"),
+});
+export const authorSceneSlab = z.object({
+    name: z.string().max(80).optional(),
+    polygon: z.array(plan('vertex')).min(3),
+    thickness: length('Slab thickness (default 0.15 m).', { default: 0.15, positive: true }),
+    top: length("The slab's top above the level's floor; a balcony at 0, a plinth below 0 (default 0).", {
+        default: 0,
+    }),
+    finish: z.string().optional().describe('library:<id> or #rrggbb (an exact colour).'),
+    railing: z
+        .array(z.object({
+        start: plan('start'),
+        end: plan('end'),
+        height: length('Railing height (default 1.1 m).', { default: 1.1, positive: true }),
+    }))
+        .optional()
+        .describe('Railing runs on this slab (a balcony).'),
+});
+export const authorSceneColumn = z.object({
+    name: z.string().max(80).optional(),
+    position: plan('centre'),
+    width: length('Column width.', { positive: true }),
+    depth: length('Column depth.', { positive: true }),
+    height: length('Column height.', { positive: true }),
+    color: z.string().optional(),
+});
+export const authorSceneItem = z.object({
+    id: z.string().min(1).max(64).describe('Your own id, for the report and for hosting.'),
+    name: z.string().min(1).max(80),
+    category: z
+        .string()
+        .min(1)
+        .max(40)
+        .describe('One word a catalog would use: bed, chair, sofa, plant, lamp, sink.'),
+    code: z
+        .string()
+        .min(1)
+        .max(48_000)
+        .describe("The piece's own three.js module (see the description)."),
+    position: xyz('bottom centre'),
+    rotation: measurement('angle', 'deg', {
+        default: 0,
+        description: 'Turn about the vertical axis (default 0).',
+    }),
+    host: z
+        .string()
+        .optional()
+        .describe('The id of the item this one rests on or hangs from (a lamp on a nightstand), or of the wall it is fixed to (a baseboard, a casing, a mirror, art), so moving the host moves it. On a wall, position is still the world bottom centre: the item faces the room on the nearest face, keeping its outward distance from that face; a point inside the wall moves to the face and is reported. Rotation is ignored.'),
+});
+export const authorSceneLight = z.object({
+    position: xyz('the bulb'),
+    color: z.string().default('#ffffff').describe('#rrggbb (default white).'),
+    intensity: z
+        .number()
+        .positive()
+        .default(1)
+        .describe('Relative brightness, 1 for an ordinary bulb (default 1).'),
+    fixture: z
+        .string()
+        .optional()
+        .describe('The id of the item holding this light (a pendant, a lamp). Default: without a fixture, a minimal ceiling point is created on the ceiling of the room containing the light’s plan position; outside any room, it attaches to the nearest item on this level and reports the fallback.'),
+});
+export const authorSceneLevel = z.object({
+    name: z.string().min(1).max(80),
+    elevation: length("The level's floor height above the ground floor's (default 0).", {
+        default: 0,
+    }),
+    walls: z.array(authorSceneWall).optional(),
+    rooms: z.array(authorSceneRoom).default([]).describe('Room seeds and finishes (default []).'),
+    slabs: z.array(authorSceneSlab).optional(),
+    columns: z.array(authorSceneColumn).optional(),
+    items: z.array(authorSceneItem).optional(),
+    lights: z.array(authorSceneLight).default([]),
+});
+export const authorScenePayload = z.object({
+    levels: z.array(authorSceneLevel).min(1),
+    notes: z
+        .array(z.string().max(1200))
+        .default([])
+        .describe('What you could not convert, or converted with a change, one sentence each. Kept with the scene.'),
+});
+export const authorSceneTool = {
+    name: 'author_scene',
+    title: 'Author scene',
+    description: DESCRIPTION,
+    input: {
+        payload: authorScenePayload,
+        module: z
+            .string()
+            .max(400_000)
+            .optional()
+            .describe('The three.js module the payload was read from. Stored with the scene as its source.'),
+        adapter: z
+            .string()
+            .max(400_000)
+            .optional()
+            .describe('The program that produced the payload from the module. Stored with the scene, so a regenerated design starts from it.'),
+        replace: z
+            .boolean()
+            .default(false)
+            .describe('Apply a new design delta to the previous conversion, preserving manual edits (default false).'),
+        buildingId: z
+            .string()
+            .optional()
+            .describe('The building to convert into. Required when there are several and no active level selects one.'),
+        sceneId: NodeId.optional().describe('The scene to write; the active one when omitted.'),
+    },
+    annotations: { destructiveHint: true },
+};

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/** The shared tools a batch runs; a test keeps this in step with the operations registry. */
+export declare const BATCHABLE_TOOLS: readonly ['paint', 'search_materials', 'list_levels', 'get_node', 'get_level_summary', 'get_walls', 'get_zones', 'duplicate_level', 'verify_scene', 'delete_node', 'measure_stair', 'fit_stair', 'find_by_type', 'create_roof', 'add_wall', 'add_fence', 'add_level', 'create_stair', 'add_corner_window', 'merge_windows', 'add_column', 'add_object', 'place_design', 'place_in_room'];
+/**
+ * Batched tools whose calls do not depend on each other: one that fails is reported with its own
+ * error and the others are applied, whatever onRefusal says. An authored object is made whole or
+ * not at all, and ten of them in one batch should not be lost to one script that does not run.
+ */
+export declare const INDEPENDENT_BATCH_TOOLS: readonly string[];
+export declare const runBatchTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        calls: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        onRefusal: z.ZodOptional<z.ZodEnum<{
+            skip: "skip";
+            stop: "stop";
+        }>>;
+    };
+};
+//# sourceMappingURL=batch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/agent-tools/batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,6FAA6F;AAC7F,eAAO,MAAM,eAAe,YAC1B,OAAO,EACP,kBAAkB,EAClB,aAAa,EACb,UAAU,EACV,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,eAAe,EACf,WAAW,EACX,cAAc,EACd,aAAa,EACb,UAAU,EACV,WAAW,EACX,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,YAAY,EAEZ,YAAY,EACZ,cAAc,EACd,eAAe,CAMP,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EAAmB,CAAA;AAExE,eAAO,MAAM,YAAY;IACvB,IAAI;IACJ,KAAK;IACL,WAAW;IACX,KAAK;QACH,KAAK;;;;QAYL,SAAS;;;;;CAKZ,CAAA"}

package/dist/agent-tools/batch.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+/** The shared tools a batch runs; a test keeps this in step with the operations registry. */
+export const BATCHABLE_TOOLS = [
+    'paint',
+    'search_materials',
+    'list_levels',
+    'get_node',
+    'get_level_summary',
+    'get_walls',
+    'get_zones',
+    'duplicate_level',
+    'verify_scene',
+    'delete_node',
+    'measure_stair',
+    'fit_stair',
+    'find_by_type',
+    'create_roof',
+    'add_wall',
+    'add_fence',
+    'add_level',
+    'create_stair',
+    'add_corner_window',
+    'merge_windows',
+    'add_column',
+    // The host compiles each module before the batch runs.
+    'add_object',
+    'place_design',
+    'place_in_room',
+    // Not search_assets: it reads the host's item library, which a host hands that one tool, and
+    // already runs several queries per call. Not view_assets, whose pictures a batch's result cannot
+    // carry (it returns each call's result as data; a picture rides beside the result of a call
+    // made on its own). Not furnish_room or place_items, for the same library;
+    // not create_room, whose answer names the floor plate and ceiling the host derives after it.
+];
+/**
+ * Batched tools whose calls do not depend on each other: one that fails is reported with its own
+ * error and the others are applied, whatever onRefusal says. An authored object is made whole or
+ * not at all, and ten of them in one batch should not be lost to one script that does not run.
+ */
+export const INDEPENDENT_BATCH_TOOLS = ['add_object'];
+export const runBatchTool = {
+    name: 'run_batch',
+    title: 'Run a batch of scene tools',
+    description: `Optionally run several scene tools in one call: in order, each on the scene the calls before it left, applied as one undo step, with a report per call. Supports repeated or known-in-advance work; individual calls remain available. A call cannot use an id another call of the same batch creates; created ids are available in the report for subsequent calls. onRefusal stop (default): a refused call stops the batch and nothing is applied; skip: the others are applied and each refusal is reported; add_object calls are independent of each other under both: one that fails is reported with its own error and the others are applied, each with the receipt a single add_object gives. Tools: ${BATCHABLE_TOOLS.join(', ')}.`,
+    input: {
+        calls: z
+            .array(z.object({
+            tool: z.string().describe('One of the tools listed in the description.'),
+            input: z
+                .record(z.string(), z.unknown())
+                .optional()
+                .describe("That tool's input, as when calling it on its own."),
+        }))
+            .min(1)
+            .max(64),
+        onRefusal: z
+            .enum(['stop', 'skip'])
+            .optional()
+            .describe('stop (default): nothing is applied if a call is refused. skip: apply the rest.'),
+    },
+};

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+/**
+ * `set_checkpoint`'s contract: the agent names a moment of its build, to look back from.
+ */
+export declare const setCheckpointTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        name: z.ZodString;
+    };
+};
+//# sourceMappingURL=checkpoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoints.d.ts","sourceRoot":"","sources":["../../src/agent-tools/checkpoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,IAAI;;CAMP,CAAA"}

package/dist/agent-tools/checkpoints.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+/**
+ * `set_checkpoint`'s contract: the agent names a moment of its build, to look back from.
+ */
+export const setCheckpointTool = {
+    name: 'set_checkpoint',
+    title: 'Set a checkpoint',
+    description: 'A named moment in your work (a roof, a floor, a batch of walls) that verify_scene({ since: name }) can compare against: it lists what was created, changed and deleted since, grouped by level and kind with a view each, and what you made that is gone. "start", the beginning of your work, is always one; a name used again replaces the first; a session keeps at most 8. A checkpoint is kept with your session, not in the project: it changes nothing in the scene, enters no undo, and does not restore anything. Refused: too_many_checkpoints (naming them), scene_too_large, name_required.',
+    input: {
+        name: z
+            .string()
+            .min(1)
+            .max(40)
+            .describe('A short name for this moment, e.g. "walls done" or "before roof".'),
+    },
+};

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;IACzB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;;CAET,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<{
+            cabinetry: "cabinetry";
+            doors: "doors";
+            electrical: "electrical";
+            framing: "framing";
+            "kitchen-cabinetry": "kitchen-cabinetry";
+            lights: "lights";
+            masonry: "masonry";
+            plumbing: "plumbing";
+            roof: "roof";
+            windows: "windows";
+        }>>;
+        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;IAC7B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,YAAY;QACZ,QAAQ;;;;;;;;;;;;QAIR,IAAI;QACJ,KAAK;QACL,GAAG;QACH,MAAM;QACN,MAAM;;CAKT,CAAA;AAED,eAAO,MAAM,mBAAmB;IAC9B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,YAAY;;CAEf,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: {
+        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<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        radius: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        depth: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        style: z.ZodOptional<z.ZodEnum<{
+            cluster: "cluster";
+            "dravidian-carved": "dravidian-carved";
+            faceted: "faceted";
+            fluted: "fluted";
+            "lathe-turned": "lathe-turned";
+            plain: "plain";
+        }>>;
+        crossSection: z.ZodOptional<z.ZodEnum<{
+            octagonal: "octagonal";
+            rectangular: "rectangular";
+            round: "round";
+            "sixteen-sided": "sixteen-sided";
+            square: "square";
+        }>>;
+        level: z.ZodOptional<z.ZodString>;
+        y: z.ZodOptional<z.ZodNumber>;
+        nodeId: z.ZodOptional<z.ZodString>;
+        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]>>>;
+    };
+};
+//# 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. Supports native fields or optional code using 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 provides current code when needed.'),
+        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,
+    },
+};