@pascal-app/core 1.0.3 → 1.0.4

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

@@ -0,0 +1,144 @@
+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(`A module (three.js, or bpy with language) for a ${kind} the fields cannot express (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. Fields first; code only beyond them.`),
+    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 first to change its code). 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).'),
+        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), on sillHeight above the floor. 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 first to change its code). 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 0.9 m).',
+        }).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<readonly [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<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>>>;
+        curveOffset: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [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;AAIvB;;;GAGG;AACH,eAAO,MAAM,uBAAuB,qGAGlC,CAAA;AAKF,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAmBvB,CAAA"}

package/dist/agent-tools/walls.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+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.',
+    input: {
+        start: planPoint('start'),
+        end: planPoint('end'),
+        thickness: measurement('length', 'm', {
+            positive: true,
+            description: 'Wall thickness (default 0.1 m).',
+        }).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 }) };
+}