@pascal-app/core 1.0.3 → 1.0.5

package/dist/agent-operations/achieved.js

@@ -0,0 +1,48 @@
+import { applySceneChanges } from './apply-changes.js';
+const countByType = (ids, nodes) => {
+    const counts = {};
+    for (const id of ids) {
+        const type = nodes[id]?.type;
+        if (type)
+            counts[type] = (counts[type] ?? 0) + 1;
+    }
+    return counts;
+};
+/**
+ * What a mutating call really changed, read from the scene before and after its changes, so a
+ * result never claims what the scene does not hold (a facade was once reported "applied" on 432
+ * walls that placed no window). Cheap: one pass over the ids; a scene check per call is not (2.7 s
+ * on a scene of 4,362 nodes).
+ */
+export function achievedChanges(before, changes) {
+    const after = applySceneChanges(before, changes);
+    const created = Object.keys(after).filter((id) => !(id in before));
+    const deleted = Object.keys(before).filter((id) => !(id in after));
+    // Once per node, and only when its data changed: an update that writes what a node already
+    // holds is no change.
+    const updated = [...new Set((changes.update ?? []).map(({ id }) => id))].filter((id) => id in before &&
+        id in after &&
+        before[id] !== after[id] &&
+        JSON.stringify(before[id]) !== JSON.stringify(after[id])).length;
+    return {
+        created: countByType(created, after),
+        updated,
+        deleted: countByType(deleted, before),
+        ...(created.length || deleted.length || updated ? {} : { unchanged: true }),
+    };
+}
+/**
+ * Reads changes made through a host's own write path. `before` must be a copy
+ * when the host mutates the node map it returns.
+ */
+export function achievedBetween(before, after) {
+    const created = Object.keys(after).filter((id) => !(id in before));
+    const deleted = Object.keys(before).filter((id) => !(id in after));
+    const updated = Object.keys(after).filter((id) => id in before && before[id] !== after[id]).length;
+    return {
+        created: countByType(created, after),
+        updated,
+        deleted: countByType(deleted, before),
+        ...(created.length || deleted.length || updated ? {} : { unchanged: true }),
+    };
+}

package/dist/agent-operations/add-column.d.ts

@@ -0,0 +1,23 @@
+import type { z } from 'zod';
+import type { addColumnTool } from '../agent-tools/columns.js';
+import { ColumnNode, type CompiledGeometryScript, type GeometryScriptParamValue } from '../schema/index.js';
+import type { AgentOperation } from './types.js';
+export type AddColumnInput = z.infer<z.ZodObject<typeof addColumnTool.input>> & {
+    compiled?: CompiledGeometryScript;
+};
+/**
+ * The params a column's script compiles with for this edit: native sizes edit
+ * the declared params, keeping the module's other values. Undefined when the
+ * edit leaves the geometry alone (a rename, a move), so nothing recompiles.
+ */
+export declare function columnScriptParams(node: ColumnNode | undefined, input: {
+    code?: string;
+    params?: Record<string, GeometryScriptParamValue>;
+    height?: number;
+    width?: number;
+    depth?: number;
+}): {
+    [x: string]: string | number | boolean;
+} | undefined;
+export declare const addColumn: AgentOperation<AddColumnInput>;
+//# sourceMappingURL=add-column.d.ts.map

package/dist/agent-operations/add-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-column.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-column.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAU3D,OAAO,EAAE,UAAU,EAAE,KAAK,sBAAsB,EAAE,KAAK,wBAAwB,EAAE,MAAM,WAAW,CAAA;AAGlG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC,GAAG;IAC9E,QAAQ,CAAC,EAAE,sBAAsB,CAAA;CAClC,CAAA;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,UAAU,GAAG,SAAS,EAC5B,KAAK,EAAE;IACL,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAA;IACjD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;;cAeF;AAED,eAAO,MAAM,SAAS,EAAE,cAAc,CAAC,cAAc,CAwFpD,CAAA"}

package/dist/agent-operations/add-column.js

@@ -0,0 +1,99 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { matchScriptSlotsToLibrary, requireMeasured, scriptedSize, scriptSource, withSourceMeta, } from '../lib/geometry-script-node.js';
+import { resettledPosition } from '../lib/geometry-surfaces.js';
+import { ColumnNode } from '../schema/index.js';
+import { editedScriptParams, refuseParamsWithoutScript } from './add-object.js';
+import { targetLevel } from './level-target.js';
+/**
+ * The params a column's script compiles with for this edit: native sizes edit
+ * the declared params, keeping the module's other values. Undefined when the
+ * edit leaves the geometry alone (a rename, a move), so nothing recompiles.
+ */
+export function columnScriptParams(node, input) {
+    const sizes = ['height', 'width', 'depth'].filter((key) => input[key] !== undefined);
+    if (!(input.code || (node?.source && (input.params || sizes.length > 0))))
+        return undefined;
+    const params = { ...editedScriptParams(node, input.params) };
+    for (const key of sizes) {
+        if (node?.source && !input.code && !node.source.manifest.params.some((spec) => spec.id === key))
+            refuse('missing_size_param', `This column's script has no ${key} parameter. Rebuild its code to make ${key} editable.`, { id: node.id, dimension: key });
+        params[key] = input[key];
+    }
+    return params;
+}
+export const addColumn = (nodes, input, context) => {
+    const previous = input.nodeId ? nodes[input.nodeId] : undefined;
+    if (input.nodeId && !previous)
+        refuse('node_not_found', `Node not found: ${input.nodeId}.`);
+    if (previous && previous.type !== 'column')
+        refuse('not_a_column', `${previous.id} is not a column.`);
+    refuseParamsWithoutScript(nodes, input);
+    const parent = previous
+        ? nodes[previous.parentId]
+        : targetLevel(nodes, { level: input.level }, context);
+    if (parent?.type !== 'level')
+        refuse('not_a_level', 'A column belongs to a level.');
+    if (!previous && (input.x === undefined || input.z === undefined))
+        refuse('position_required', 'Pass x and z for the column support point.');
+    const { compiled } = input;
+    if (compiled && compiled.mount !== 'floor')
+        refuse('wrong_mount', "A column's script uses mount 'floor'.");
+    if (compiled)
+        requireMeasured(compiled, { label: input.name, nodeId: input.nodeId, tool: 'add_column' });
+    const dimensions = compiled ? scriptedSize(compiled.manifest) : undefined;
+    const { nodeId: _, code: _code, params: _params, level: _level, compiled: _compiled, x, y, z, rotation, ...fields } = input;
+    const node = ColumnNode.parse({
+        ...previous,
+        ...fields,
+        ...(compiled?.nodeId ? { id: compiled.nodeId } : {}),
+        name: input.name ??
+            previous?.name ??
+            `Column ${Object.values(nodes).filter((node) => node.type === 'column').length + 1}`,
+        parentId: parent.id,
+        position: [
+            x ?? previous?.position[0] ?? 0,
+            y ?? previous?.position[1] ?? 0,
+            z ?? previous?.position[2] ?? 0,
+        ],
+        rotation: rotation === undefined ? previous?.rotation : (rotation * Math.PI) / 180,
+        ...(previous?.source && !compiled ? { source: withSourceMeta(previous.source, input) } : {}),
+        ...(compiled && dimensions
+            ? {
+                source: scriptSource(compiled, input, previous?.source),
+                slots: matchScriptSlotsToLibrary(compiled.manifest, previous?.slots, previous?.source?.manifest),
+                width: dimensions[0],
+                height: dimensions[1],
+                depth: dimensions[2],
+            }
+            : {}),
+    });
+    const slotIds = new Set(compiled?.manifest.slots.map((slot) => slot.id));
+    const orphanedSlots = compiled
+        ? Object.keys(previous?.slots ?? {}).filter((id) => !slotIds.has(id))
+        : [];
+    const resettled = [];
+    if (compiled && previous) {
+        for (const id of previous.children) {
+            const child = nodes[id];
+            if (child?.type !== 'item' || child.wallId)
+                continue;
+            const position = resettledPosition(compiled.manifest, child, [1, 1, 1]);
+            if (position?.some((value, i) => Math.abs(value - child.position[i]) > 1e-4))
+                resettled.push({ id, data: { position } });
+        }
+    }
+    return {
+        result: {
+            ok: true,
+            columnId: node.id,
+            nodeId: node.id,
+            height: node.height,
+            width: node.width,
+            depth: node.depth,
+            ...(orphanedSlots.length ? { orphanedSlots } : {}),
+        },
+        changes: previous
+            ? { update: [{ id: node.id, data: node }, ...resettled] }
+            : { create: [{ node, parentId: parent.id }] },
+    };
+};

package/dist/agent-operations/add-fence.d.ts

@@ -0,0 +1,18 @@
+import { FenceNode } from '../schema/index.js';
+import { type LevelTargetInput } from './level-target.js';
+import type { AgentOperation } from './types.js';
+type AddFenceInput = LevelTargetInput & {
+    points: number[][];
+    closed?: boolean;
+    height?: number;
+    style?: FenceNode['style'];
+    baseStyle?: FenceNode['baseStyle'];
+    materialPreset?: string;
+};
+/**
+ * `add_fence`: one fence per side along the points, privacy unless asked (one made with no style
+ * came out as open rails). Fences stand on the level, as the editor's fence tool puts them.
+ */
+export declare const addFence: AgentOperation<AddFenceInput>;
+export {};
+//# sourceMappingURL=add-fence.d.ts.map

package/dist/agent-operations/add-fence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-fence.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-fence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AACrC,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAGnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAO7C,KAAK,aAAa,GAAG,gBAAgB,GAAG;IACtC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAA;IAClB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;IAC1B,SAAS,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAA;IAClC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAID;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,aAAa,CAyClD,CAAA"}

package/dist/agent-operations/add-fence.js

@@ -0,0 +1,48 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { FenceNode } from '../schema/index.js';
+import { targetLevel } from './level-target.js';
+import { finishSurface, requireMaterialRef } from './material-refs.js';
+import { refuseRoofLevel } from './roof-writes.js';
+/** A fence side shorter than this is a slip, not a fence. */
+const FENCE_MIN_SIDE = 0.1;
+const round = (value) => Math.round(value * 100) / 100;
+/**
+ * `add_fence`: one fence per side along the points, privacy unless asked (one made with no style
+ * came out as open rails). Fences stand on the level, as the editor's fence tool puts them.
+ */
+export const addFence = (nodes, input, context) => {
+    const level = targetLevel(nodes, input, context);
+    refuseRoofLevel(nodes, level.id, 'a fence');
+    const materialPreset = input.materialPreset === undefined
+        ? undefined
+        : requireMaterialRef(input.materialPreset, 'materialPreset', finishSurface('fence'));
+    const points = input.points;
+    const sides = points.slice(1).map((point, i) => [points[i], point]);
+    if (input.closed && points.length > 2)
+        sides.push([points.at(-1), points[0]]);
+    const short = sides.find(([a, b]) => Math.hypot(b[0] - a[0], b[1] - a[1]) < FENCE_MIN_SIDE);
+    if (short)
+        refuse('fence_too_short', `The side from [${short[0]}] to [${short[1]}] is shorter than ${FENCE_MIN_SIDE * 100} cm: drop the repeated point.`, { start: short[0], end: short[1] });
+    const first = Object.values(nodes).filter((node) => node.type === 'fence').length;
+    const fences = sides.map(([start, end], i) => FenceNode.parse({
+        name: `Fence ${first + i + 1}`,
+        parentId: level.id,
+        start,
+        end,
+        style: input.style ?? 'privacy',
+        ...(input.height === undefined ? {} : { height: input.height }),
+        ...(input.baseStyle === undefined ? {} : { baseStyle: input.baseStyle }),
+        ...(materialPreset === undefined ? {} : { materialPreset }),
+    }));
+    const length = sides.reduce((sum, [a, b]) => sum + Math.hypot(b[0] - a[0], b[1] - a[1]), 0);
+    return {
+        result: {
+            ok: true,
+            count: fences.length,
+            fenceIds: fences.map((fence) => fence.id),
+            levelId: level.id,
+            length: round(length),
+        },
+        changes: { create: fences.map((node) => ({ node, parentId: level.id })) },
+    };
+};

package/dist/agent-operations/add-level.d.ts

@@ -0,0 +1,17 @@
+import { BuildingNode } from '../schema/index.js';
+import type { AgentContext, AgentOperation, SceneNodes } from './types.js';
+type AddLevelInput = {
+    buildingId?: string;
+    position?: 'above' | 'below';
+    name?: string;
+    height?: number;
+};
+/** The building named, else the one holding the viewed floor, else the scene's only building. */
+export declare function targetBuilding(nodes: SceneNodes, buildingId: string | undefined, context: AgentContext): BuildingNode;
+/**
+ * `add_level`: an empty level over the building's top storey, under its roof level (which moves up
+ * one), or under its lowest level — the editor's +.
+ */
+export declare const addLevel: AgentOperation<AddLevelInput>;
+export {};
+//# sourceMappingURL=add-level.d.ts.map

package/dist/agent-operations/add-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-level.d.ts","sourceRoot":"","sources":["../../src/agent-operations/add-level.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAuB,MAAM,WAAW,CAAA;AAK7D,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAgB,UAAU,EAAE,MAAM,SAAS,CAAA;AAErF,KAAK,aAAa,GAAG;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,iGAAiG;AACjG,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EACjB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,YAAY,GACpB,YAAY,CAwBd;AAuCD;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,aAAa,CAyDlD,CAAA"}

package/dist/agent-operations/add-level.js

@@ -0,0 +1,130 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { buildLevelBelowChanges } from '../building/level-insertion.js';
+import { foundationReadingOfLevel } from '../lib/foundation-construction.js';
+import { foundationWallRule, levelHoldsFoundationWalls } from '../lib/foundation-wall.js';
+import { BuildingNode, LevelNode, SiteNode } from '../schema/index.js';
+import { DEFAULT_LEVEL_HEIGHT } from '../services/level-height.js';
+import { storeyInsertIndex } from '../services/roof-level.js';
+import { applySceneChanges } from './apply-changes.js';
+import { levelsOf } from './scene-queries.js';
+/** The building named, else the one holding the viewed floor, else the scene's only building. */
+export function targetBuilding(nodes, buildingId, context) {
+    if (buildingId) {
+        const node = nodes[buildingId];
+        if (!node)
+            refuse('building_not_found', `Building not found: ${buildingId}.`, { buildingId });
+        if (node.type !== 'building')
+            refuse('not_a_building', `Node ${buildingId} is a ${node.type}, not a building.`, {
+                buildingId,
+                type: node.type,
+            });
+        return node;
+    }
+    const viewed = context.activeLevelId ? nodes[context.activeLevelId] : undefined;
+    const holder = viewed?.parentId ? nodes[viewed.parentId] : undefined;
+    if (holder?.type === 'building')
+        return holder;
+    const buildings = Object.values(nodes).filter((node) => node.type === 'building');
+    if (buildings.length === 1)
+        return buildings[0];
+    if (!buildings.length)
+        refuse('no_building', 'The scene has no building.');
+    return refuse('building_required', `The scene has ${buildings.length} buildings; say which: ${buildings.map((building) => building.id).join(', ')}.`, { buildingIds: buildings.map((building) => building.id) });
+}
+/**
+ * On a scene with no building, the editor's own empty scene: a site (unless one stands), its
+ * building, the ground level. An agent that cleared the scene to restart begins again here.
+ */
+function freshStart(nodes, input) {
+    const standing = Object.values(nodes).find((node) => node.type === 'site');
+    const site = standing ? null : SiteNode.parse({ children: [] });
+    const siteId = standing?.id ?? site.id;
+    const building = BuildingNode.parse({ parentId: siteId, children: [] });
+    const level = LevelNode.parse({
+        parentId: building.id,
+        level: 0,
+        height: input.height ?? DEFAULT_LEVEL_HEIGHT,
+        children: [],
+        ...(input.name ? { name: input.name } : {}),
+    });
+    return {
+        result: {
+            ok: true,
+            levelId: level.id,
+            buildingId: building.id,
+            ...(site ? { siteId: site.id } : {}),
+            floorIndex: 0,
+            ...(level.name ? { name: level.name } : {}),
+            height: level.height,
+            message: `The scene had no building: made ${site ? 'a site, ' : ''}a building and its ground level.`,
+        },
+        changes: {
+            create: [
+                ...(site ? [{ node: site }] : []),
+                { node: building, parentId: siteId },
+                { node: level, parentId: building.id },
+            ],
+        },
+    };
+}
+/**
+ * `add_level`: an empty level over the building's top storey, under its roof level (which moves up
+ * one), or under its lowest level — the editor's +.
+ */
+export const addLevel = (nodes, input, context) => {
+    if (!(input.buildingId || Object.values(nodes).some((node) => node.type === 'building')))
+        return freshStart(nodes, input);
+    const building = targetBuilding(nodes, input.buildingId, context);
+    const floors = levelsOf(nodes)
+        .filter((level) => level.parentId === building.id || building.children.includes(level.id))
+        .map((level) => level.level);
+    const below = input.position === 'below';
+    const above = storeyInsertIndex(nodes, building.id);
+    // A basement goes under the lowest floor and leaves every floor where
+    // it stands, as the editor's "+" below does: the ground floor keeps its grade.
+    const stacked = below && floors.length
+        ? buildLevelBelowChanges({
+            nodes,
+            buildingId: building.id,
+            height: input.height ?? DEFAULT_LEVEL_HEIGHT,
+        })
+        : null;
+    const floorIndex = stacked
+        ? stacked.newLevel.level
+        : below && floors.length
+            ? Math.min(...floors) - 1
+            : above.floorIndex;
+    const shift = below ? [] : above.shift;
+    const level = stacked?.newLevel ??
+        LevelNode.parse({
+            parentId: building.id,
+            level: floorIndex,
+            height: input.height ?? DEFAULT_LEVEL_HEIGHT,
+            children: [],
+            ...(input.name ? { name: input.name } : {}),
+        });
+    if (stacked && input.name)
+        level.name = input.name;
+    const changes = {
+        create: [{ node: level, parentId: building.id }],
+        update: stacked ? stacked.update : shift,
+    };
+    const after = applySceneChanges(nodes, changes);
+    const foundation = levelHoldsFoundationWalls(after, level.id)
+        ? foundationWallRule(foundationReadingOfLevel(after, level.id))
+        : null;
+    return {
+        result: {
+            ok: true,
+            levelId: level.id,
+            buildingId: building.id,
+            floorIndex,
+            ...(level.name ? { name: level.name } : {}),
+            height: level.height,
+            ...(foundation ? { wallConstruction: foundation } : {}),
+            ...(shift.length ? { shiftedLevelIds: shift.map(({ id }) => id) } : {}),
+            message: `Added ${level.name ?? `level ${floorIndex}`} ${below ? (stacked ? 'below the existing levels, every floor keeping its place' : 'below the existing levels') : shift.length ? 'on top of the storeys, under the roof level' : 'above the existing levels'} of ${building.name ?? building.id}.${foundation ? ` It is below grade: ${foundation}; a wall given a thickness keeps it.` : ''}`,
+        },
+        changes,
+    };
+};

package/dist/agent-operations/add-object.d.ts

@@ -0,0 +1,143 @@
+import { type ScriptedNode } from '../lib/geometry-script-node.js';
+import { type AnyNode, type CompiledGeometryScript, type GeometryScriptLanguage, type GeometryScriptParamValue, type WallFace } from '../schema/index.js';
+import type { AgentOperation, BatchedObject } from './types.js';
+export type AddObjectInput = {
+    /** Absent for a params-only edit: the host compiled the object's stored script. */
+    code?: string;
+    params?: Record<string, GeometryScriptParamValue>;
+    nodeId?: string;
+    parentId?: string;
+    position?: number[];
+    /** Degrees about Y, as the contract parses it. */
+    rotation?: number;
+    side?: 'front' | 'back';
+    name?: string;
+    description?: string;
+    tags?: string[];
+    category?: string;
+    /** What the object stands in for; kept in `metadata.reason`, listed by verify_scene. */
+    reason?: string;
+    /** What the surface's compile produced from `code` (compiled before the operation runs). */
+    compiled: CompiledGeometryScript;
+};
+/**
+ * Words that name what Pascal already builds, with the tool that builds it. An object named so is
+ * built with a hint naming that tool: authored objects are for what has no type.
+ */
+export declare const PASCAL_TYPES: [RegExp, string][];
+/**
+ * `add_object`: the item a compiled three.js module becomes. Not in
+ * AGENT_OPERATIONS: each surface compiles `code` first (the chat in its
+ * worker, the MCP on the server) and passes the result as `compiled`.
+ * The artifact is referenced by hash and its bounds become the item's dimensions; editing
+ * keeps the item's identity, placement, children, paint and reason. Only a new object is judged
+ * by its shape and must give a reason: the editor's inspector rebuilds through the edit path.
+ */
+/**
+ * A new object says what it stands in for. Hosts check it before running the script: a missing
+ * reason refused after the compile has run it and stored its artifacts for nothing.
+ */
+export declare function requireAddObjectReason(input: {
+    nodeId?: string;
+    reason?: string;
+}): void;
+export declare const addObject: AgentOperation<AddObjectInput>;
+/**
+ * `add_object` inside run_batch: the batch's host built the module before the batch ran (a compile
+ * is async, the operations are not), and the call places what was built, with the receipt a lone
+ * add_object gives.
+ */
+export declare const addObjectInBatch: AgentOperation<Omit<AddObjectInput, 'compiled'>>;
+/**
+ * Builds the module of every add_object call of a batch with the host's own compile, a few at a
+ * time, by call index. A call that fails (a reason missing, a script that does not run, a host
+ * that refuses) is kept with its own message, so the batch reports it and the others stand. A call
+ * whose input does not parse is left out: the batch refuses it with the contract's message.
+ */
+export declare function buildBatchObjects(calls: readonly {
+    tool?: unknown;
+    input?: unknown;
+}[], build: (input: Omit<AddObjectInput, 'compiled'>) => Promise<CompiledGeometryScript>): Promise<Record<number, BatchedObject>>;
+export type RescriptOpeningInput = {
+    description?: string;
+    category?: string;
+    tags?: string[];
+    nodeId: string;
+    /** Where it goes; without one its bottom edge stays put. */
+    position?: number[];
+    name?: string;
+    /** What the host compiled: new code, or the stored script with new params. */
+    compiled: CompiledGeometryScript;
+};
+/**
+ * `add_window` / `add_door` with a nodeId: a window or door built from (or
+ * given) a script, rebuilt from what the host compiled. Its size is what the
+ * script built; marks, hosting and the opening's own fields are kept.
+ */
+export declare const rescriptOpening: AgentOperation<RescriptOpeningInput>;
+/**
+ * The param values a rebuild of `node` compiles with: its current ones under the
+ * edit's. The compile then keeps only what the module declares, clamps numbers to
+ * their new range and gives a param new to the code, or one whose type changed,
+ * its default. A node without a script just takes the edit's.
+ */
+export declare function editedScriptParams(node: AnyNode | undefined, params: Record<string, GeometryScriptParamValue> | undefined): Record<string, GeometryScriptParamValue> | undefined;
+/**
+ * The language a build of `node` runs in: new code's own (the node's when not
+ * given), and the stored script's for a params-only rebuild.
+ */
+export declare function editedScriptLanguage(node: AnyNode | undefined, input: {
+    code?: string;
+    language?: GeometryScriptLanguage;
+}): GeometryScriptLanguage;
+/** The scripted node `get_source` and a params-only rebuild act on, or a refusal. */
+export declare function authoredObject(nodes: Record<string, AnyNode>, nodeId: string): ScriptedNode;
+/**
+ * Params are a script's values: without code, only a node already built from a
+ * script has one to rerun, so a new node, or one without a script, is refused.
+ */
+export declare function refuseParamsWithoutScript(nodes: Record<string, AnyNode>, input: {
+    code?: string;
+    params?: unknown;
+    nodeId?: string;
+}): void;
+/**
+ * Why a raw update (chat `update_node`, MCP `apply_patch`) may not write what a
+ * node's script owns, its `source` or the size it built, or null: the stored
+ * fields would no longer match the geometry. Restating the current value passes.
+ */
+export declare function scriptedFieldRefusal(node: AnyNode, data: Record<string, unknown>): string | null;
+/** What `get_source` reads: a scripted node, a room's floor script, or a wall face's script. */
+export type ScriptReadable = Pick<ScriptedNode, 'name' | 'source'> & {
+    id: string;
+    type: ScriptedNode['type'] | 'zone' | 'wall';
+    /** The wall face whose script it is. */
+    face?: WallFace;
+};
+/**
+ * The script `get_source` reads at `nodeId`: an authored object's, a room's floor script by its
+ * zone id, or a wall's face script (`face`, which a wall with one scripted face may leave out).
+ */
+export declare function readableScript(nodes: Record<string, AnyNode>, nodeId: string, face?: WallFace): ScriptReadable;
+/** What `get_source` answers once the host has the module's text. */
+export declare function readSourceResult(node: ScriptReadable, code: string): {
+    nodeId: string;
+    type: "column" | "door" | "item" | "wall" | "window" | "zone";
+    face?: WallFace | undefined;
+    name: string | undefined;
+    language: "bpy" | "three";
+    code: string;
+    params: {
+        id: string;
+        label?: string | undefined;
+        kind: "boolean" | "number" | "string";
+        default: string | number | boolean;
+        min?: number | undefined;
+        max?: number | undefined;
+        step?: number | undefined;
+        unit?: string | undefined;
+        options?: string[] | undefined;
+        value: string | number | boolean;
+    }[];
+};
+//# sourceMappingURL=add-object.d.ts.map

package/dist/agent-operations/add-object.d.ts.map

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