@pascal-app/core 1.0.3 → 1.0.5

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-tools/index.ts"],"names":[],"mappings":"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"}

package/dist/agent-tools/index.js

@@ -0,0 +1,126 @@
+import { addObjectTool, getSourceTool } from './add-object.js';
+import { searchAssetsTool, viewAssetsTool } from './assets.js';
+import { authorSceneTool } from './author-scene.js';
+import { runBatchTool } from './batch.js';
+import { setCheckpointTool } from './checkpoints.js';
+import { clearSceneTool } from './clear-scene.js';
+import { editCollectionTool, listCollectionsTool } from './collections.js';
+import { addColumnTool } from './columns.js';
+import { addCornerWindowTool } from './corner-window.js';
+import { createRoomTool } from './create-room.js';
+import { designBriefTool } from './design-brief.js';
+import { placeDesignTool, validateDesignTool } from './designs.js';
+import { addFenceTool } from './fences.js';
+import { findByTypeTool } from './find-by-type.js';
+import { furnishRoomTool } from './furnish-room.js';
+import { addLevelTool, duplicateLevelTool, getLevelSummaryTool, getWallsTool, getZonesTool, listLevelsTool, setGroundLevelTool, } from './levels.js';
+import { mergeWindowsTool } from './merge-windows.js';
+import { deleteNodeTool, getNodeTool } from './nodes.js';
+import { paintTool } from './paint.js';
+import { placeInRoomTool } from './place-in-room.js';
+import { placeItemsTool } from './place-items.js';
+import { createRoofTool, moveRoofsToRoofLevelTool } from './roofs.js';
+import { ROOM_TOOL_CONTRACTS } from './room-structure.js';
+import { searchMaterialsTool } from './search-materials.js';
+import { getSiteTool, placeBuildingTool } from './site.js';
+import { createStairTool, fitStairTool, measureStairTool } from './stairs.js';
+import { verifySceneTool } from './verify-scene.js';
+import { viewSceneTool } from './view-scene.js';
+import { addDoorTool, addWindowTool } from './wall-openings.js';
+import { addWallTool } from './walls.js';
+export * from './achieved.js';
+export * from './add-object.js';
+export * from './assets.js';
+export * from './author-scene.js';
+export * from './clear-scene.js';
+export * from './collections.js';
+export * from './columns.js';
+export * from './contract.js';
+export * from './corner-window.js';
+export * from './create-room.js';
+export * from './fences.js';
+export * from './find-by-type.js';
+export * from './furnish-room.js';
+export * from './hosted-services.js';
+export * from './levels.js';
+export * from './measurement.js';
+export * from './merge-windows.js';
+export { NodeId } from './node-id.js';
+export * from './nodes.js';
+export * from './notation-inventory.js';
+export * from './paint.js';
+export * from './place-items.js';
+export * from './project-files.js';
+export * from './refusal.js';
+export * from './retired.js';
+export * from './roofs.js';
+export * from './room-structure.js';
+export * from './search-materials.js';
+export * from './site.js';
+export { CATALOG_SOURCE, OTHER_SOURCES, OUTSIDE_SOURCES } from './sources.js';
+export * from './stairs.js';
+export * from './verify-scene.js';
+export * from './view-scene.js';
+export * from './wall-openings.js';
+export * from './walls.js';
+export * from './write-target.js';
+/**
+ * Tools defined once for every agent surface — the MCP server and the hosted AI chat register
+ * each from this contract (name, description, input schema), and a parity test fails when a
+ * surface drifts. See wiki/architecture/agent-surfaces.md.
+ */
+export const AGENT_TOOL_CONTRACTS = [
+    addColumnTool,
+    measureStairTool,
+    fitStairTool,
+    viewSceneTool,
+    addDoorTool,
+    addWindowTool,
+    listLevelsTool,
+    getNodeTool,
+    getLevelSummaryTool,
+    getWallsTool,
+    getZonesTool,
+    duplicateLevelTool,
+    verifySceneTool,
+    setCheckpointTool,
+    designBriefTool,
+    placeDesignTool,
+    validateDesignTool,
+    addWallTool,
+    addFenceTool,
+    addCornerWindowTool,
+    mergeWindowsTool,
+    addLevelTool,
+    setGroundLevelTool,
+    placeItemsTool,
+    createStairTool,
+    createRoofTool,
+    moveRoofsToRoofLevelTool,
+    deleteNodeTool,
+    addObjectTool,
+    authorSceneTool,
+    getSourceTool,
+    findByTypeTool,
+    editCollectionTool,
+    listCollectionsTool,
+    clearSceneTool,
+    createRoomTool,
+    furnishRoomTool,
+    paintTool,
+    placeInRoomTool,
+    searchAssetsTool,
+    viewAssetsTool,
+    searchMaterialsTool,
+    getSiteTool,
+    placeBuildingTool,
+    ...ROOM_TOOL_CONTRACTS,
+    runBatchTool,
+];
+export { BATCHABLE_TOOLS, INDEPENDENT_BATCH_TOOLS, runBatchTool } from './batch.js';
+export { setCheckpointTool } from './checkpoints.js';
+export * from './design-brief.js';
+export { placeDesignTool, validateDesignTool } from './designs.js';
+export { straightenFacadePhotoTool } from './photo-elevation.js';
+export { placeInRoomTool } from './place-in-room.js';
+export { createRoofTool } from './roofs.js';

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

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+export declare const listLevelsTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {};
+};
+export declare const levelTarget: {
+    levelId: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodString>;
+};
+export declare const getLevelSummaryTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+    };
+};
+export declare const getWallsTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+    };
+};
+export declare const getZonesTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+    };
+};
+export declare const addLevelTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        buildingId: z.ZodOptional<z.ZodString>;
+        position: z.ZodOptional<z.ZodEnum<{
+            above: "above";
+            below: "below";
+        }>>;
+        name: z.ZodOptional<z.ZodString>;
+        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    };
+};
+export declare const duplicateLevelTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        position: z.ZodOptional<z.ZodEnum<{
+            above: "above";
+            below: "below";
+        }>>;
+        name: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodEnum<{
+            everything: "everything";
+            structure: "structure";
+            "structure-furniture": "structure-furniture";
+            "structure-materials": "structure-materials";
+        }>>;
+    };
+};
+export declare const setGroundLevelTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodString;
+    };
+};
+//# sourceMappingURL=levels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"levels.d.ts","sourceRoot":"","sources":["../../src/agent-tools/levels.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,cAAc;IACzB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;CACN,CAAA;AAGD,eAAO,MAAM,WAAW;IACtB,OAAO;IAGP,KAAK;CACN,CAAA;AAED,eAAO,MAAM,mBAAmB;IAC9B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;;;;CACN,CAAA;AAED,eAAO,MAAM,YAAY;IACvB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;;;;CACN,CAAA;AAED,eAAO,MAAM,YAAY;IACvB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;;;;CACN,CAAA;AAED,eAAO,MAAM,YAAY;IACvB,IAAI;IACJ,KAAK;IACL,WAAW;IAIX,KAAK;QACH,UAAU;QAGV,QAAQ;;;;QAMR,IAAI;QAMJ,MAAM;;CAKT,CAAA;AAED,eAAO,MAAM,kBAAkB;IAC7B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;QAGP,QAAQ;;;;QAIR,IAAI;QAQJ,MAAM;;;;;;;CAOT,CAAA;AAED,eAAO,MAAM,kBAAkB;IAC7B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;;CAEV,CAAA"}

package/dist/agent-tools/levels.js

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { FOUNDATION_BY_REGION_NOTE } from '../lib/foundation-construction.js';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+export const listLevelsTool = {
+    name: 'list_levels',
+    title: 'List levels',
+    description: 'List every level of every building in floor order: id, name, floorIndex, building (parentId), role (occupied storey, roof-only level or support level), child count, gradeStanding (at-grade, partly-below-grade or below-grade against the ground line and the terrain), isGroundLevel, and which one the person is viewing (isActive); groundLevels names, per building, the level at grade (levelId, whether the building names it, floorElevation, gradeElevation, floorOverGrade, seated). A roof-only level is the roof, not a storey.',
+    input: {},
+};
+// `level` is the chat's older name for the same parameter; threads and habits still use it.
+export const levelTarget = {
+    levelId: NodeId.optional().describe('The level, by an id list_levels returned; an id made up from a name ("level_1", "level_ground") does not exist. Default: the floor the person is viewing, else the lowest floor.'),
+    level: NodeId.optional().describe('Same as levelId.'),
+};
+export const getLevelSummaryTool = {
+    name: 'get_level_summary',
+    title: 'Get level summary',
+    description: "Summarise one level so nothing on it goes unseen: its role and counts, then walls (length, heights, doors and windows), zones (name, area, size, floor_choices), slabs, ceilings, items (floor, wall and ceiling), floor openings, stairs, roofs, and anything else by type. Zone polygons: get_zones; a node's full data: get_node.",
+    input: levelTarget,
+};
+export const getWallsTool = {
+    name: 'get_walls',
+    title: 'Get walls',
+    description: 'Get the walls of a level: start and end in metres, length, stored and resolved height, thickness, and their doors and windows. wallFaceChains gives base-chain provenance for geometric faces a (left of start → end) and b (right): ref (authored face slot), legacy (inline spec), or default (declared fallback ref). These are not final rendered finishes: room intent, face paint regions, exterior assembly cladding and reference availability can change appearance. A chosen white or default-matching ref is legitimate; fallback alone is not a defect or a requirement to paint.',
+    input: levelTarget,
+};
+export const getZonesTool = {
+    name: 'get_zones',
+    title: 'Get zones',
+    description: 'Get the zones (rooms) of a level: name, colour, polygon and holes in metres, area in m² (holes taken out), bounding size, and floor_choices: the floor plates the room can take (key, plateId, name, current; drawn and mezzanine flags). A room shares its floor plate with the rooms next to it unless detached. Persisted authored wall intent is wallMaterial (string, or null when absent) and wallOverrides (records of wallId, geometric face a or b, and finish; [] when absent). This is not a final rendered finish or visual verification: local overrides and face paint can take precedence, and absent room intent is not a defect or a requirement to paint.',
+    input: levelTarget,
+};
+export const addLevelTool = {
+    name: 'add_level',
+    title: 'Add level',
+    description: "Add an empty level to a building, as the editor does: above its top storey, under the building's roof level, which moves up one so the roof stays on top; or below its lowest level for a basement, which goes one storey under the lowest level and every existing level keeps its place, the ground floor included. On a scene with no building (a new or cleared scene), it starts the scene as the editor does: a site, a building and its ground level. A level that ends up below grade says in its result how a new wall on it is built (wallConstruction): a wall against the ground is a foundation wall, " +
+        FOUNDATION_BY_REGION_NOTE +
+        ', a partition is an ordinary wall. To copy a floor with its content, use duplicate_level.',
+    input: {
+        buildingId: NodeId.optional().describe("The building. Default: the building of the floor the person is viewing, else the scene's only building."),
+        position: z
+            .enum(['above', 'below'])
+            .optional()
+            .describe('above (default): over the top storey, under the roof level; below: under the lowest, a basement.'),
+        name: z
+            .string()
+            .min(1)
+            .max(120)
+            .optional()
+            .describe('Name of the level, e.g. "Basement", "Attic".'),
+        height: measurement('length', 'm', {
+            positive: true,
+            description: 'Floor-to-floor storey height (default 2.5 m).',
+        }).optional(),
+    },
+};
+export const duplicateLevelTool = {
+    name: 'duplicate_level',
+    title: 'Duplicate level',
+    description: 'Copy a level with everything on it, as the editor does: fresh ids, internal links kept, and units whose rooms are all on that level copied too; plan references, scans and spawn points stay behind. The copy goes above the original (or below it) and the floors past it move up one.',
+    input: {
+        levelId: NodeId.optional().describe('The level to copy, by an id list_levels returned. Default: the floor the person is viewing.'),
+        position: z
+            .enum(['above', 'below'])
+            .optional()
+            .describe('Where the copy goes: above the original (default) or below it.'),
+        name: z
+            .string()
+            .min(1)
+            .max(120)
+            .optional()
+            .describe('Name of the copy. Default: none, so it reads by its floor like a new level (Floor 1, Ground floor…).'),
+        preset: z
+            .enum(['everything', 'structure', 'structure-materials', 'structure-furniture'])
+            .optional()
+            .describe('What to copy, as in the editor: everything (default); structure (walls, zones, slabs, ceilings, roofs, stairs, doors, windows) without materials; structure with its materials; or structure and furniture.'),
+    },
+};
+export const setGroundLevelTool = {
+    name: 'set_ground_level',
+    title: 'Set ground level',
+    description: "Make a level the building's ground floor: the one standing at grade, its floor 8 in over the ground (about 6 in on cast concrete foundations, 12 in on stone: the building's foundation construction seats it; the result names it). A building's levels stack on a ground line; the levels with a lower floor index are below grade (basements), the ones at or over it are not, and list_levels reads it as groundLevels (levelId, floorElevation, floorOverGrade, seated) and each level's gradeStanding (at-grade, partly-below-grade, below-grade) and isGroundLevel. This names the level on the building, seats the building so that level's floor datum, the top of the foundation where the wood framing starts, stands 0.203 m (8 in) over grade on a block foundation, 0.15 m on cast concrete (Europe), 0.3 m on stone (a historic style) (flat site: world Y 0.203; sculpted terrain: 0.203 m over the mean ground height under its floor), moving the building in height only — the plan stays where it is and every level keeps its place relative to the others — and renumbers the floor indices so it is 0 and the ones under it are -1, -2…. A level added below (add_level position below) stacks under the lowest level without moving the ground floor. A roof level or a support level cannot be the ground floor (not_a_storey). One undo step. Refusals: level_not_found, not_a_level, no_building, not_a_storey. Answering unchanged: true when the level is already the named ground floor, at that seat, at index 0.",
+    input: {
+        levelId: NodeId.describe('The level to stand at grade, by an id list_levels returned.'),
+    },
+};

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

@@ -0,0 +1,55 @@
+import { type Kind } from '@pascal-app/lingo';
+import { z } from 'zod';
+/**
+ * Lengths, angles and roof pitches as every agent tool takes them (the tool catalogue's "one
+ * convention per quantity"). A field states its unit, and a model may answer with a bare number
+ * in that unit or with text in any unit: `measurement('length', 'm')` accepts `0.15`, `"6 in"`,
+ * `"180cm"`, `"2 ft 3 in"`; `measurement('angle', 'deg')` accepts `45`, `"45°"`, `"1.57rad"`;
+ * `roofPitch('twelfths')` accepts `6`, `"6:12"`, `"26.6°"`. The value reaches the handler as a
+ * number in the field's unit, so a bare number keeps its meaning and no handler converts.
+ * `min`/`max` (in the unit) refuse out-of-range values with a model-readable message.
+ *
+ * The emitted JSON Schema is `number | string`. The AI SDK and the MCP SDK apply the transform
+ * when they validate a call, and every tab that runs a call parses it again with its contract.
+ *
+ * Tool-boundary safety: genuinely ambiguous separators (`"1,234"`, which could mean 1234 or
+ * 1.234) are refused rather than absorbed, so a European decimal never becomes a 1000× value.
+ * The MCP and the hosted chat import this module (`@pascal-app/core/agent-tools`).
+ */
+export interface MeasurementOptions {
+    /** Semantic description (e.g. "Wall thickness"). The natural-language note is appended. */
+    description?: string;
+    /**
+     * What a call that leaves the field out gets, in `unit`. The description states it: a field
+     * that converts loses its JSON Schema `default` in what the model is shown.
+     */
+    default?: number;
+    /** Upper bound, in `unit`. */
+    max?: number;
+    /** Inclusive lower bound, in `unit`. */
+    min?: number;
+    /** Require the value to be strictly greater than 0 (for non-zero dimensions). */
+    positive?: boolean;
+}
+type QuantityField = z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+type Defaulted = MeasurementOptions & {
+    default: number;
+};
+type Undefaulted = MeasurementOptions & {
+    default?: undefined;
+};
+/** A length or an angle in `unit` (`m`, `in`, `ft`, `mm`; `deg`, `rad`). */
+export declare function measurement(kind: Kind, unit: string, opts: Defaulted): z.ZodDefault<QuantityField>;
+export declare function measurement(kind: Kind, unit: string, opts?: Undefaulted): QuantityField;
+export declare function measurement(kind: Kind, unit: string, opts?: MeasurementOptions): QuantityField | z.ZodDefault<QuantityField>;
+/** A roof's pitch: its angle in degrees, or its rise per 12 of run (`6` for a 6:12 roof). */
+export type PitchUnit = 'deg' | 'twelfths';
+/**
+ * A roof pitch in `unit`, read from either way of saying it: degrees (`26.6`, `"26.6°"`,
+ * `"0.46 rad"`) or rise over run (`"6:12"`, `"6/12"`, `"6 in 12"`). A bare number is in `unit`.
+ */
+export declare function roofPitch(unit: PitchUnit, opts: Defaulted): z.ZodDefault<QuantityField>;
+export declare function roofPitch(unit: PitchUnit, opts?: Undefaulted): QuantityField;
+export declare function roofPitch(unit: PitchUnit, opts?: MeasurementOptions): QuantityField | z.ZodDefault<QuantityField>;
+export {};
+//# sourceMappingURL=measurement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../src/agent-tools/measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAiB,MAAM,mBAAmB,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,kBAAkB;IACjC,2FAA2F;IAC3F,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,8BAA8B;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,wCAAwC;IACxC,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,iFAAiF;IACjF,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAwGD,KAAK,aAAa,GAAG,CAAC,CAAC,OAAO,CAC5B,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,EACtC,CAAC,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CACxC,CAAA;AACD,KAAK,SAAS,GAAG,kBAAkB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AACzD,KAAK,WAAW,GAAG,kBAAkB,GAAG;IAAE,OAAO,CAAC,EAAE,SAAS,CAAA;CAAE,CAAA;AAE/D,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,CAAC,CAAC,UAAU,CAAC,aAAa,CAAC,CAAA;AACnG,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,CAAA;AACxF,wBAAgB,WAAW,CACzB,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,kBAAkB,GACxB,aAAa,GAAG,CAAC,CAAC,UAAU,CAAC,aAAa,CAAC,CAAA;AAW9C,6FAA6F;AAC7F,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,UAAU,CAAA;AAsD1C;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,CAAC,CAAC,UAAU,CAAC,aAAa,CAAC,CAAA;AACxF,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,CAAA;AAC7E,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,EACf,IAAI,CAAC,EAAE,kBAAkB,GACxB,aAAa,GAAG,CAAC,CAAC,UAAU,CAAC,aAAa,CAAC,CAAA"}

package/dist/agent-tools/measurement.js

@@ -0,0 +1,144 @@
+import { parseQuantity } from '@pascal-app/lingo';
+import { z } from 'zod';
+// What a field says once per field, read on every call: its unit, named first so a bare number
+// is read in it (a bare "45" in a radians field is 45 rad), and text in other units.
+const UNIT_NOTES = {
+    m: 'In metres, or text with a unit ("6 ft").',
+    in: 'In inches, or text with a unit ("1.5 ft").',
+    ft: 'In feet, or text with a unit ("72 in").',
+    mm: 'In millimetres, or text with a unit ("2.6cm").',
+    deg: 'In degrees, or text with a unit ("1.57rad").',
+    rad: 'In radians, or text with a unit ("90°").',
+};
+function boundsNote(unit, min, max, positive) {
+    if (positive) {
+        return max === undefined
+            ? ` Must be greater than 0 ${unit}.`
+            : ` Greater than 0, up to ${max} ${unit}.`;
+    }
+    if (min !== undefined && max !== undefined)
+        return ` Range ${min}–${max} ${unit}.`;
+    if (min !== undefined)
+        return ` Minimum ${min} ${unit}.`;
+    if (max !== undefined)
+        return ` Maximum ${max} ${unit}.`;
+    return '';
+}
+const BARE_NUMBER = /^\s*[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?\s*$/i;
+/** A conversion's float noise dropped: "6" read as inches is 6, not 5.999999999999999. */
+const clean = (value) => Number(value.toPrecision(12));
+/** `unitRequired`: text without a unit is refused, not read in `unit`. */
+const parse = (text, kind, unit, unitRequired) => parseQuantity(text, {
+    kind,
+    unit,
+    strictness: 'forgiving',
+    accept: { bareNumbers: !unitRequired },
+    // A genuinely ambiguous separator ("1,234") must not silently become a 1000× value at a
+    // tool boundary: fail so the model self-corrects.
+    escalate: { AMBIGUOUS_NUMBER: 'error' },
+});
+function readQuantity(text, kind, unit) {
+    const result = parse(text, kind, unit, false);
+    if (!result.ok)
+        return { error: result.issues[0]?.message ?? `Could not read "${text}" as a ${kind}.` };
+    return clean(result.quantity.to(unit).value);
+}
+// Superscript and subscript digits, which Unicode folding would turn into plain ones ("6²" → "62").
+const SCRIPT_DIGITS = /[\u00B2\u00B3\u00B9\u2070-\u209F]/;
+/** A value as a person says it in `unit`: "18 in", "6:12", "40°". */
+const said = (value, unit) => unit === 'twelfths' ? `${value}:12` : unit === 'deg' ? `${value}°` : `${value} ${unit}`;
+/** A number or text field, read to a number in `unit` and held to the bounds. */
+function quantityField(read, what, unit, note, opts) {
+    const { min, max, positive = false, default: fallback } = opts;
+    const outOfBounds = (value) => {
+        if (!Number.isFinite(value))
+            return `Value must be a finite ${what} in ${unit}.`;
+        if (positive && value <= 0)
+            return `Must be greater than 0 ${unit} (got ${value}).`;
+        if (min !== undefined && value < min)
+            return `Must be at least ${min} ${unit} (got ${value}).`;
+        if (max !== undefined && value > max)
+            return `Must be at most ${max} ${unit} (got ${value}).`;
+    };
+    const description = [
+        opts.description,
+        note + boundsNote(unit, min, max, positive),
+        fallback === undefined ? undefined : `Default ${said(fallback, unit)}.`,
+    ]
+        .filter(Boolean)
+        .join(' ');
+    const field = z
+        .union([z.number(), z.string()])
+        .transform((val, ctx) => {
+        const refuse = (message) => {
+            ctx.addIssue({ code: 'custom', message });
+            return z.NEVER;
+        };
+        if (typeof val === 'string' && SCRIPT_DIGITS.test(val))
+            return refuse(`"${val}" has a superscript or subscript: write the number plainly.`);
+        const value = typeof val === 'number' ? val : read(val);
+        if (typeof value !== 'number')
+            return refuse(value.error);
+        const problem = outOfBounds(value);
+        return problem === undefined ? value : refuse(problem);
+    })
+        .describe(description);
+    return fallback === undefined ? field : field.default(fallback);
+}
+export function measurement(kind, unit, opts = {}) {
+    return quantityField((text) => readQuantity(text, kind, unit), kind, unit, UNIT_NOTES[unit] ?? `In ${unit}, or text with a unit.`, opts);
+}
+/** Rise over run, as a pitch is said: "6:12", "6/12", "6 in 12", "6-in-12", "6 on 12", "6:12 pitch". */
+const RISE_OVER_RUN = /^\s*\+?(\d+\.?\d*|\.\d+)\s*(?::|\/|-?\s*(?:in|on)\s*-?)\s*(\d+\.?\d*|\.\d+)(\s*pitch)?\s*$/i;
+/**
+ * Angles a pitch is never given in: the marks of minutes and seconds (' " ′ ″) are a builder's
+ * feet and inches, so a 6" pitch (6 in of rise per foot) would read as 6 arcseconds.
+ */
+const MINUTES_AND_SECONDS = new Set(['arcmin', 'arcsec']);
+const degreesToTwelfths = (degrees) => 12 * Math.tan((degrees * Math.PI) / 180);
+const PITCH_NOTES = {
+    deg: 'In degrees, or rise over run ("6:12").',
+    twelfths: 'Rise per 12 of run (6 for 6:12), or "6:12" or "26.6°".',
+};
+/** Full-width forms ("６／１２") as their ASCII twins; nothing else is folded. */
+const ascii = (text) => text
+    .replace(/[\uFF01-\uFF5E]/g, (c) => String.fromCharCode(c.charCodeAt(0) - 0xfee0))
+    .replace(/\u3000/g, ' ');
+function readPitch(text, unit) {
+    const unreadable = {
+        error: `Could not read "${text}" as a roof pitch: give degrees ("26.6°") or the rise per 12 ("6:12").`,
+    };
+    const plain = ascii(text);
+    const ratio = RISE_OVER_RUN.exec(plain);
+    if (ratio) {
+        const rise = Number(ratio[1]);
+        const run = Number(ratio[2]);
+        // A carpenter's "1/4 pitch" is rise over span, a 6:12 roof: only a run of 12 is said with it.
+        if (ratio[3] && run !== 12)
+            return unreadable;
+        // Past the largest number, a rise and run of 1e309 and 2e309 would divide as 45°.
+        if (!Number.isFinite(rise) || !Number.isFinite(run))
+            return unreadable;
+        if (run === 0)
+            return { error: `"${text}" has no run: give the rise per 12, as "6:12".` };
+        // Divided first, so a huge rise and run still give their slope.
+        return clean(unit === 'twelfths' ? 12 * (rise / run) : (Math.atan2(rise, run) * 180) / Math.PI);
+    }
+    if (BARE_NUMBER.test(plain))
+        return Number(plain);
+    // Anything else must name its angle unit ("26.6°", "0.46 rad"): without one, the unit parser
+    // reads text such as "6,0" or "6 / 12 / 1" as degrees.
+    const angle = parse(plain, 'angle', 'deg', true);
+    if (!angle.ok || MINUTES_AND_SECONDS.has(angle.quantity.unit))
+        return unreadable;
+    const degrees = clean(angle.quantity.to('deg').value);
+    if (unit === 'deg')
+        return degrees;
+    // A plane at 90° rises forever per 12 of run: no roof.
+    if (Math.abs(degrees) >= 90)
+        return { error: `A roof pitch is under 90° (got ${degrees}°).` };
+    return clean(degreesToTwelfths(degrees));
+}
+export function roofPitch(unit, opts = {}) {
+    return quantityField((text) => readPitch(text, unit), 'roof pitch', unit, PITCH_NOTES[unit], opts);
+}

package/dist/agent-tools/merge-windows.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const mergeWindowsTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        windowIds: z.ZodArray<z.ZodString>;
+    };
+};
+//# sourceMappingURL=merge-windows.d.ts.map

package/dist/agent-tools/merge-windows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-windows.d.ts","sourceRoot":"","sources":["../../src/agent-tools/merge-windows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,gBAAgB;IAC3B,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,SAAS;;CAOZ,CAAA"}

package/dist/agent-tools/merge-windows.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export const mergeWindowsTool = {
+    name: 'merge_windows',
+    title: 'Merge windows',
+    description: "Make two windows that exist one window, as the editor's Merge windows does: nothing is recreated. On two walls that meet at a corner, each window within 0.30 m of that corner, they become one corner window (the add_corner_window result): each is slid to the corner keeping its width, the glass fused (post none), and both take the first window's height, sill and type, so name first the window whose look you want; the corner is refused over 170° or under 10° (walls_not_meeting, corner_angle, window_not_at_corner, height_exceeds_wall). On one wall, two windows with at most 0.30 m between them and nothing between become one window spanning both outer edges, from the lower sill to the higher head, with the first window's type and style (windows_not_adjacent, opening_between). Refused with a code and a sentence that says why: window_not_found, not_a_window, same_window, window_not_on_wall, window_already_joined (unwrap it first), windows_already_joined, opening_overlap (sliding to the corner would land on another opening). Returns kind (corner or same_wall), the windows that stay (windowIds) and the one that went (removedIds). Use it for two windows already built that open a corner or one wide opening; add_corner_window builds a new pair, and verify_scene's corner_unjoined names two windows this joins.",
+    input: {
+        windowIds: z
+            .array(z.string())
+            .length(2)
+            .describe('The two windows, the one whose height, sill and type the result keeps named first.'),
+    },
+};

package/dist/agent-tools/node-id.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const NodeId: z.ZodString;
+//# sourceMappingURL=node-id.d.ts.map

package/dist/agent-tools/node-id.d.ts.map

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

package/dist/agent-tools/node-id.js

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const NodeId = z.string().min(1);

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

@@ -0,0 +1,17 @@
+export declare const getNodeTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        id: import("zod").ZodString;
+    };
+};
+export declare const deleteNodeTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        id: import("zod").ZodString;
+    };
+};
+//# sourceMappingURL=nodes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../src/agent-tools/nodes.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;IACtB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QAAI,EAAE;;CACZ,CAAA;AAED,eAAO,MAAM,cAAc;IACzB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QAAI,EAAE;;CACZ,CAAA"}

package/dist/agent-tools/nodes.js

@@ -0,0 +1,13 @@
+import { NodeId } from './node-id.js';
+export const getNodeTool = {
+    name: 'get_node',
+    title: 'Get node',
+    description: "Get the full data of any node by its id: its fields as stored, with what the scene decides for it beside them (a wall's or a ceiling's resolvedHeight, and heightIsExplicit, false when it follows its storey; a wall's resolvedThickness; a door's or window's resolvedOpening, its floor and what it hangs from; the displayName a level or a floor plate is shown by); its ancestorIds, its parent first (a door's wall, then the level, the building, the site); and the scene materials (scene:<id>) its finishes use. A container's node lists its children as stored; any that name no node are listed again in missingChildIds. A node its schema rejects comes back as stored, with nothing derived (verify_scene says what is wrong).",
+    input: { id: NodeId.describe('The node id.') },
+};
+export const deleteNodeTool = {
+    name: 'delete_node',
+    title: 'Delete node',
+    description: "Delete a node with everything under it, as the editor's Delete does: a wall goes with its doors and windows, a level with everything on it. The floors above a deleted level keep their index.",
+    input: { id: NodeId.describe('The node id.') },
+};

package/dist/agent-tools/notation-inventory.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { AgentToolContract } from './contract.js';
+/** The schema of one field of a contract, by its path: `patch.thickness`, `walls[].along[]`. */
+export declare function fieldSchema(contract: AgentToolContract, path: string): z.ZodType;
+/**
+ * Every number the contracts take by name as a bare number, as `tool.path`: what is neither a
+ * `measurement()` nor a `roofPitch()`. Each must be a coordinate, a fraction or a ratio, which a
+ * notation test lists.
+ */
+export declare function bareNumberPaths(contracts: readonly AgentToolContract[]): string[];
+/**
+ * Every defaulted field whose default the model is not shown, as `tool.path`: its input JSON
+ * Schema has no `default` (a field that converts loses it) and its description does not state it.
+ */
+export declare function unshownDefaultPaths(contracts: readonly AgentToolContract[]): string[];
+//# sourceMappingURL=notation-inventory.d.ts.map

package/dist/agent-tools/notation-inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notation-inventory.d.ts","sourceRoot":"","sources":["../../src/agent-tools/notation-inventory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AA+CnD,gGAAgG;AAChG,wBAAgB,WAAW,CAAC,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,CAIhF;AAkCD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,iBAAiB,EAAE,GAAG,MAAM,EAAE,CAMjF;AAwBD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,iBAAiB,EAAE,GAAG,MAAM,EAAE,CAYrF"}