@pascal-app/core 1.0.1 → 1.0.4

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

@@ -0,0 +1,259 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { ItemNode } from '../schema/index.js';
+import { edgeProjection } from './create-room.js';
+import { collectDoorKeepouts, itemBlocksDoorKeepout, itemPlanAabb, keepoutCoversPlanned, keepoutForPolygonEdge, } from './door-clearance.js';
+import { collectOccupiedFootprints, findValidPlacement } from './layout-clearance.js';
+import { targetLevel } from './level-target.js';
+import { polygonArea, polygonBounds } from './plan-geometry.js';
+import { levelIdOf, levelRole } from './scene-queries.js';
+// A door belongs to a room edge when it stands this close to the edge's line, within its span.
+const DOOR_EDGE_TOLERANCE = 0.25;
+// Clearance between a piece's back and the wall's centreline: half a wall and a hand's width.
+const WALL_GAP = 0.1;
+/** The room asked for: a zone's level and outline, or a polygon on the level named. */
+function roomToFurnish(nodes, input, context) {
+    if (input.zoneId) {
+        const zone = nodes[input.zoneId];
+        if (!zone)
+            refuse('zone_not_found', `Room not found: ${input.zoneId}. Use a zoneId create_room or get_zones returned.`, { zoneId: input.zoneId });
+        if (zone.type !== 'zone')
+            refuse('not_a_zone', `Node ${input.zoneId} is a ${zone.type}, not a room: pass the room's zoneId (create_room, get_zones).`, { zoneId: input.zoneId, type: zone.type });
+        const levelId = levelIdOf(nodes, zone.id);
+        if (!levelId)
+            refuse('level_not_found', `Room ${zone.id} is not on a level.`);
+        return { levelId, polygon: zone.polygon };
+    }
+    if (!input.polygon)
+        refuse('room_required', 'Say which room: its zoneId, or its polygon (and its level).');
+    return { levelId: targetLevel(nodes, input, context).id, polygon: input.polygon };
+}
+/** The doors of the level that stand on an edge of the room, by where they stand. */
+function doorsOfRoom(nodes, levelId, polygon) {
+    const found = [];
+    for (const wall of Object.values(nodes)) {
+        if (wall.type !== 'wall' || wall.parentId !== levelId)
+            continue;
+        const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+        if (length < 1e-9)
+            continue;
+        for (const childId of wall.children) {
+            const door = nodes[childId];
+            if (door?.type !== 'door')
+                continue;
+            const t = door.position[0] / length;
+            const point = [
+                wall.start[0] + t * (wall.end[0] - wall.start[0]),
+                wall.start[1] + t * (wall.end[1] - wall.start[1]),
+            ];
+            const edge = polygon.findIndex((a, i) => {
+                const along = edgeProjection(a, polygon[(i + 1) % polygon.length], point);
+                return along.distance < DOOR_EDGE_TOLERANCE && along.t >= 0 && along.t <= 1;
+            });
+            if (edge >= 0)
+                found.push({ doorId: door.id, edge });
+        }
+    }
+    return found;
+}
+/** A polygon edge seen from inside the room: its middle, its direction, and the way into the room. */
+function edgeFrame(polygon, index, center) {
+    const a = polygon[index % polygon.length];
+    const b = polygon[(index + 1) % polygon.length];
+    const length = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1;
+    const along = { x: (b[0] - a[0]) / length, z: (b[1] - a[1]) / length };
+    const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+    const towardCenter = (center[0] - mid[0]) * -along.z + (center[1] - mid[1]) * along.x;
+    const inward = towardCenter >= 0 ? { x: -along.z, z: along.x } : { x: along.z, z: -along.x };
+    // An item's front is its +Z: turned to face into the room.
+    const facing = (Math.atan2(inward.x, inward.z) * 180) / Math.PI;
+    return { mid, along, inward, length, facing };
+}
+/** Where each piece of a room type goes, sized from the catalog's own dimensions. */
+function layout(roomType, polygon, doorWall, catalog) {
+    const bounds = polygonBounds(polygon);
+    const center = [bounds.centerX, bounds.centerZ];
+    const n = polygon.length;
+    const door = edgeFrame(polygon, doorWall, center);
+    const back = edgeFrame(polygon, doorWall + Math.floor(n / 2), center);
+    const side = edgeFrame(polygon, doorWall + 1, center);
+    const area = polygonArea(polygon);
+    const size = (assetId) => catalog.find((asset) => asset.id === assetId)?.dimensions;
+    const width = (assetId) => size(assetId)?.[0] ?? 1;
+    const depth = (assetId) => size(assetId)?.[2] ?? 1;
+    const poses = [];
+    /** Back against `edge`, `lateral` along it from its middle, `out` further into the room. */
+    const against = (edge, assetId, lateral = 0, out = 0) => {
+        const inset = depth(assetId) / 2 + WALL_GAP + out;
+        poses.push({
+            assetId,
+            x: edge.mid[0] + edge.inward.x * inset + edge.along.x * lateral,
+            z: edge.mid[1] + edge.inward.z * inset + edge.along.z * lateral,
+            rotationDeg: edge.facing,
+            along: edge.along,
+            inward: edge.inward,
+        });
+    };
+    const free = (assetId, x, z, rotationDeg = 0) => poses.push({ assetId, x, z, rotationDeg });
+    switch (roomType) {
+        case 'bedroom': {
+            const bed = Math.max(bounds.width, bounds.depth) >= 3.2 ? 'double-bed' : 'single-bed';
+            against(back, bed);
+            const table = width('bedside-table');
+            if (back.length >= width(bed) + 2 * table + 0.2) {
+                const lateral = width(bed) / 2 + table / 2 + 0.05;
+                against(back, 'bedside-table', -lateral);
+                against(back, 'bedside-table', lateral);
+            }
+            if (area >= 10)
+                against(side, 'dresser', side.length * 0.22);
+            if (area >= 13)
+                against(side, 'closet', -side.length * 0.22);
+            break;
+        }
+        case 'kitchen':
+            against(back, back.length >= 2.6 ? 'kitchen' : 'kitchen-counter');
+            if (back.length >= 3.5)
+                against(back, 'stove', back.length / 2 - width('stove') / 2 - 0.1);
+            against(side, 'fridge', side.length * 0.25);
+            break;
+        case 'bathroom':
+            against(back, 'toilet', back.length * 0.25);
+            against(back, 'bathroom-sink', -back.length * 0.2);
+            if (area >= 6.5)
+                against(side, 'bathtub');
+            else
+                free('shower-square', bounds.centerX, bounds.centerZ);
+            break;
+        case 'living':
+            against(back, 'sofa');
+            against(back, 'coffee-table', 0, depth('sofa') + 0.4);
+            against(side, 'livingroom-chair', -side.length * 0.18);
+            // The TV faces the sofa from the door wall; the placement slides it off the door's clear zone.
+            against(door, 'tv-stand');
+            break;
+        case 'dining': {
+            free('dining-table', bounds.centerX, bounds.centerZ);
+            const ahead = depth('dining-table') / 2 + depth('dining-chair') / 2;
+            const beside = width('dining-table') / 2 + depth('dining-chair') / 2;
+            free('dining-chair', bounds.centerX, bounds.centerZ - ahead);
+            free('dining-chair', bounds.centerX, bounds.centerZ + ahead, 180);
+            if (Math.min(bounds.width, bounds.depth) >= 3) {
+                free('dining-chair', bounds.centerX - beside, bounds.centerZ, 90);
+                free('dining-chair', bounds.centerX + beside, bounds.centerZ, 270);
+            }
+            break;
+        }
+        case 'laundry':
+            against(back, 'washing-machine', -0.55);
+            against(back, 'drying-rack', 0.65);
+            break;
+        case 'entry':
+        case 'hallway':
+            if (Math.min(bounds.width, bounds.depth) >= 1.4)
+                against(side, 'coat-rack');
+            break;
+        case 'storage':
+            against(back, 'closet');
+            break;
+    }
+    return poses;
+}
+const SKIP_REASONS = {
+    outside_bounds: 'outside the room',
+    overlaps_item: 'overlaps another item',
+};
+const round = (value) => Math.round(value * 100) / 100;
+/**
+ * Why a piece was skipped, with its size: told only "bathtub: blocks door clearance", an agent
+ * set the same tub there with place_items. An item the room cannot hold in any turn says so and
+ * what instead; one in a door's way names the door.
+ */
+function skipReason(asset, pose, reason, room, doors) {
+    const [width = 1, , depth = 1] = asset.dimensions ?? [1, 1, 1];
+    const named = `${asset.id} (${round(width)} × ${round(depth)} m)`;
+    const [roomWidth, roomDepth] = [room.maxX - room.minX, room.maxZ - room.minZ];
+    const fits = (a, b) => a <= roomWidth && b <= roomDepth;
+    if (!fits(width, depth) && !fits(depth, width))
+        return `${named}: too large for the room (${round(roomWidth)} × ${round(roomDepth)} m); a smaller one, or add_object at the room's size`;
+    if (reason === 'blocks_door_clearance') {
+        const footprint = itemPlanAabb([pose.x, 0, pose.z], asset.dimensions, (pose.rotationDeg * Math.PI) / 180);
+        const door = doors.find((keepout) => itemBlocksDoorKeepout(footprint, keepout));
+        return `${named}: in the way of ${door ? `door ${door.doorId}` : 'the door wall kept clear for a door'}`;
+    }
+    return `${named}: ${SKIP_REASONS[reason]}`;
+}
+/**
+ * `furnish_room`: a room type's pieces from the host's catalog, against the walls the door decides,
+ * each moved off door clear zones and other items or skipped with the reason. The door wall is the
+ * edge a door of the room stands on (found by position), else doorWallIndex, else edge 0.
+ */
+export const furnishRoom = (nodes, input, context) => {
+    const catalog = context.catalog;
+    if (!catalog)
+        refuse('no_catalog', 'This host has no item catalog to furnish from.');
+    const { levelId, polygon } = roomToFurnish(nodes, input, context);
+    const level = nodes[levelId];
+    if (level && levelRole(nodes, level).role === 'roof')
+        refuse('roof_level', `${level.name || level.id} is a roof level, not a storey.`, { levelId });
+    if (input.doorWallIndex !== undefined && input.doorWallIndex >= polygon.length)
+        refuse('edge_out_of_range', `The room has ${polygon.length} edges (0–${polygon.length - 1}); there is no edge ${input.doorWallIndex}.`);
+    const doors = doorsOfRoom(nodes, levelId, polygon);
+    const doorWall = input.doorWallIndex ?? doors[0]?.edge ?? 0;
+    const all = Object.values(nodes);
+    const doorKeepouts = collectDoorKeepouts(all, { levelId });
+    const keepouts = doorKeepouts.map((door) => door.aabb);
+    // A door wall without a door yet keeps the middle of it clear for the one to come.
+    if (!doors.some((door) => door.edge === doorWall)) {
+        const planned = keepoutForPolygonEdge(polygon, doorWall, { t: 0.5, width: 0.9 });
+        if (planned && !keepouts.some((keepout) => keepoutCoversPlanned(keepout, planned)))
+            keepouts.push(planned);
+    }
+    const occupied = collectOccupiedFootprints(all, { levelId, floorOnly: true }).map((footprint) => footprint.aabb);
+    const { minX, maxX, minZ, maxZ } = polygonBounds(polygon);
+    const items = [];
+    const skipped = [];
+    for (const pose of layout(input.roomType, polygon, doorWall, catalog)) {
+        const asset = catalog.find((entry) => entry.id === pose.assetId);
+        if (!asset) {
+            skipped.push(`${pose.assetId}: not in the catalog`);
+            continue;
+        }
+        const { candidate, reason } = findValidPlacement({
+            primary: { x: pose.x, z: pose.z, rotationDeg: pose.rotationDeg },
+            dimensions: asset.dimensions,
+            doorKeepouts: keepouts,
+            occupied,
+            roomBounds: { minX, maxX, minZ, maxZ },
+            along: pose.along,
+            inward: pose.inward,
+        });
+        if (!candidate) {
+            skipped.push(skipReason(asset, pose, reason, { minX, maxX, minZ, maxZ }, doorKeepouts));
+            continue;
+        }
+        const rotation = (candidate.rotationDeg * Math.PI) / 180;
+        occupied.push(itemPlanAabb([candidate.x, 0, candidate.z], asset.dimensions, rotation));
+        items.push(ItemNode.parse({
+            name: asset.name,
+            parentId: levelId,
+            position: [candidate.x, 0, candidate.z],
+            rotation: [0, rotation, 0],
+            asset,
+        }));
+    }
+    const itemIds = items.map((item) => item.id);
+    return {
+        result: {
+            ok: true,
+            placed: items.length,
+            itemIds,
+            skipped,
+            doorWallIndex: doorWall,
+            doorsDetected: doors.length,
+            message: `Furnished the ${input.roomType} with ${items.length} item${items.length === 1 ? '' : 's'}${skipped.length ? `, skipped ${skipped.length}` : ''}.`,
+        },
+        ...(items.length
+            ? { changes: { create: items.map((node) => ({ node, parentId: levelId })) } }
+            : {}),
+    };
+};

package/dist/agent-operations/get-node.d.ts

@@ -0,0 +1,9 @@
+import type { AgentOperation } from './types.js';
+/**
+ * `get_node`: a node, whole; a door or window also says where its floor is and what it hangs from;
+ * with the scene's materials lent, the ones its finishes use.
+ */
+export declare const getNode: AgentOperation<{
+    id: string;
+}>;
+//# sourceMappingURL=get-node.d.ts.map

package/dist/agent-operations/get-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-node.d.ts","sourceRoot":"","sources":["../../src/agent-operations/get-node.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,cAAc,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CA0BlD,CAAA"}

package/dist/agent-operations/get-node.js

@@ -0,0 +1,33 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { isFloorAnchoredOpening } from '../lib/floor-opening-footprints.js';
+import { getOpeningFloorDatum } from '../lib/opening-floor-datum.js';
+import { referencedSceneMaterialIds } from './scene-materials.js';
+/**
+ * `get_node`: a node, whole; a door or window also says where its floor is and what it hangs from;
+ * with the scene's materials lent, the ones its finishes use.
+ */
+export const getNode = (nodes, { id }, { materials }) => {
+    const node = nodes[id];
+    if (!node)
+        refuse('node_not_found', `Node not found: ${id}.`, { id });
+    const wall = node.parentId ? nodes[node.parentId] : undefined;
+    const resolvedOpening = (node.type === 'door' || node.type === 'window') && wall?.type === 'wall'
+        ? {
+            floorDatum: getOpeningFloorDatum(wall, node, nodes),
+            anchor: isFloorAnchoredOpening(node) ? 'floor' : 'wall',
+        }
+        : undefined;
+    const used = referencedSceneMaterialIds(node);
+    return {
+        result: {
+            node: resolvedOpening ? { ...node, resolvedOpening } : node,
+            ...(materials
+                ? {
+                    materials: Object.fromEntries(Object.values(materials)
+                        .filter((material) => used.has(material.id))
+                        .map((material) => [material.id, material])),
+                }
+                : {}),
+        },
+    };
+};

package/dist/agent-operations/hosted-services.d.ts

@@ -0,0 +1,13 @@
+import { type HostedServiceAction } from '../agent-tools/hosted-services.js';
+export type HostedServiceRequest = {
+    action: HostedServiceAction;
+    pluginId: string;
+    projectId?: string;
+    maxCredits?: number;
+    input: Record<string, unknown>;
+    signal?: AbortSignal;
+};
+/** Identity, project access, provider credentials and billing are supplied by the host. */
+export type HostedServiceExecutor = (request: HostedServiceRequest) => Promise<unknown>;
+export declare function executeHostedServiceTool(name: string, raw: unknown, execute: HostedServiceExecutor, signal?: AbortSignal): Promise<unknown>;
+//# sourceMappingURL=hosted-services.d.ts.map

package/dist/agent-operations/hosted-services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-services.d.ts","sourceRoot":"","sources":["../../src/agent-operations/hosted-services.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,gCAAgC,CAAA;AAGvC,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,mBAAmB,CAAA;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB,CAAA;AAED,2FAA2F;AAC3F,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAEvF,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,qBAAqB,EAC9B,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,OAAO,CAAC,CA0BlB"}

package/dist/agent-operations/hosted-services.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { findHostedServiceTool, siteContextInputSchema, } from '../agent-tools/hosted-services.js';
+import { AgentRefusal } from '../agent-tools/refusal.js';
+export async function executeHostedServiceTool(name, raw, execute, signal) {
+    const contract = findHostedServiceTool(name);
+    if (!contract)
+        throw new AgentRefusal('unknown_service_tool', 'This hosted service tool is not available.');
+    const parsed = z.object(contract.input).strict().safeParse(raw);
+    if (!parsed.success)
+        throw new AgentRefusal('invalid_service_input', 'Invalid hosted service input.', {
+            issues: parsed.error.issues.map(({ path, message }) => ({ path, message })),
+        });
+    const { pluginId, projectId, maxCredits, ...input } = parsed.data;
+    if (contract.action === 'site.pull') {
+        const { pullKey: _key, ...location } = input;
+        const valid = siteContextInputSchema.safeParse(location);
+        if (!valid.success)
+            throw new AgentRefusal('invalid_site_location', 'Supply an address or both latitude and longitude.');
+    }
+    signal?.throwIfAborted();
+    return execute({ action: contract.action, pluginId, projectId, maxCredits, input, signal });
+}

package/dist/agent-operations/index.d.ts

@@ -0,0 +1,277 @@
+export * from './achieved.js';
+export * from './add-column.js';
+export * from './add-level.js';
+export * from './add-object.js';
+export * from './add-wall.js';
+export * from './apply-changes.js';
+export * from './apply-outcome.js';
+export * from './collections.js';
+export * from './create-room.js';
+export * from './create-stair.js';
+export * from './delete-node.js';
+export * from './door-clearance.js';
+export * from './duplicate-level.js';
+export * from './find-by-type.js';
+export * from './furnish-room.js';
+export * from './get-node.js';
+export * from './hosted-services.js';
+export * from './layout-clearance.js';
+export * from './level-reads.js';
+export * from './level-target.js';
+export * from './list-levels.js';
+export * from './material-preset.js';
+export * from './material-refs.js';
+export * from './node-patch.js';
+export * from './paint.js';
+export * from './place-items.js';
+export * from './plan-geometry.js';
+export * from './room-structure.js';
+export * from './scene-materials.js';
+export * from './scene-measure.js';
+export * from './scene-queries.js';
+export * from './scene-view.js';
+export * from './search-assets.js';
+export * from './search-materials.js';
+export * from './stairs.js';
+export * from './types.js';
+export * from './verify-scene.js';
+export * from './wall-opening.js';
+/** Each shared agent tool's operation, by tool name: what every surface executes. */
+export declare const AGENT_OPERATIONS: {
+    readonly cut_floor_opening: import("./types.js").AgentOperation<{
+        levelId?: string;
+        zoneId?: string;
+        levelIds?: string[];
+        polygon?: number[][];
+        rect?: {
+            x: number;
+            z: number;
+            width: number;
+            depth: number;
+        };
+        drawnOn?: "floor" | "ceiling";
+        cutsPrimary?: boolean;
+        cutsAdjacent?: boolean;
+    }>;
+    readonly remove_floor_opening: import("./types.js").AgentOperation<{
+        id: string;
+    }>;
+    readonly set_floor_foundation: import("./types.js").AgentOperation<{
+        slabId?: string;
+        slabIds?: string[];
+    } & {
+        patch: unknown;
+    }>;
+    readonly set_room_floor_construction: import("./types.js").AgentOperation<{
+        zoneId: string;
+        slabId?: string;
+        patch: unknown;
+    }>;
+    readonly rebase_floor_reference: import("./types.js").AgentOperation<{
+        slabId?: string;
+        slabIds?: string[];
+    } & {
+        referenceFloorElevation: number | null;
+    }>;
+    readonly create_mezzanine: import("./types.js").AgentOperation<{
+        hostZoneId: string;
+        polygon: number[][];
+        elevation?: number;
+        thickness?: number;
+    }>;
+    readonly move_zone: import("./types.js").AgentOperation<{
+        zoneId: string;
+        translate?: number[];
+        rotate?: {
+            angle: number;
+            pivot?: number[];
+        };
+        force?: boolean;
+    }>;
+    readonly duplicate_zone: import("./types.js").AgentOperation<{
+        zoneId: string;
+        translate?: number[];
+        rotate?: {
+            angle: number;
+            pivot?: number[];
+        };
+        force?: boolean;
+    } & {
+        translate: number[];
+    }>;
+    readonly rotate_zone: import("./types.js").AgentOperation<{
+        zoneId: string;
+        quarterTurns: number;
+        gridStep?: number;
+        force?: boolean;
+    }>;
+    readonly lock_outside_faces: import("./types.js").AgentOperation<{
+        levelId?: string;
+        zoneIds?: string[];
+    }>;
+    readonly set_zone_intent: import("./types.js").AgentOperation<{
+        zoneId: string;
+        patch: unknown;
+    }>;
+    readonly divide_zone: import("./types.js").AgentOperation<{
+        zoneId: string;
+        cut?: number[][];
+        path?: number[][];
+        closed?: boolean;
+        startBoundaryId?: string;
+        endBoundaryId?: string;
+    }>;
+    readonly merge_zones: import("./types.js").AgentOperation<{
+        zoneIds: string[];
+    }>;
+    readonly delete_zone: import("./types.js").AgentOperation<{
+        zoneId: string;
+        contents: "delete" | "keep";
+    }>;
+    readonly measure_stair: import("./types.js").AgentOperation<{
+        stairId: string;
+        available?: {
+            width: number;
+            length: number;
+        } | undefined;
+    }>;
+    readonly fit_stair: import("./types.js").AgentOperation<{
+        stairId: string;
+        fitRun: boolean;
+        layout?: "straight" | "u" | "l" | undefined;
+        turn?: "left" | "right" | undefined;
+        width?: number | undefined;
+        landingDepth?: number | undefined;
+        turningStrategy?: "landing" | "winder" | undefined;
+        innerGap?: number | undefined;
+        walkingLineOffset?: number | undefined;
+        division?: "equal-going" | "equal-angle" | undefined;
+        targets?: {
+            maxRiserHeight?: number | undefined;
+            minimumGoing?: number | undefined;
+            targetGoing?: number | undefined;
+            minimumHeadroom?: number | undefined;
+        } | undefined;
+    }>;
+    readonly list_levels: import("./types.js").AgentOperation;
+    readonly get_node: import("./types.js").AgentOperation<{
+        id: string;
+    }>;
+    readonly get_level_summary: import("./types.js").AgentOperation<import("./level-target.js").LevelTargetInput>;
+    readonly get_walls: import("./types.js").AgentOperation<import("./level-target.js").LevelTargetInput>;
+    readonly get_zones: import("./types.js").AgentOperation<import("./level-target.js").LevelTargetInput>;
+    readonly duplicate_level: import("./types.js").AgentOperation<{
+        levelId?: string;
+        position?: "above" | "below";
+        name?: string;
+        preset?: import("../building/index.js").LevelDuplicatePreset;
+    }>;
+    readonly verify_scene: import("./types.js").AgentOperation<Readonly<Record<string, unknown>> | undefined>;
+    readonly add_wall: import("./types.js").AgentOperation<import("./level-target.js").LevelTargetInput & {
+        start: number[];
+        end: number[];
+        thickness?: number;
+        height?: number;
+        curveOffset?: number;
+    }>;
+    readonly add_level: import("./types.js").AgentOperation<{
+        buildingId?: string;
+        position?: "above" | "below";
+        name?: string;
+        height?: number;
+    }>;
+    readonly create_stair: import("./types.js").AgentOperation<import("./level-target.js").LevelTargetInput & {
+        x: number;
+        z: number;
+        rotation?: number;
+        width?: number;
+        length?: number;
+        height?: number;
+        steps?: number;
+        toLevelId?: string;
+        railingMode?: "none" | "left" | "right" | "both";
+        materialPreset?: string;
+        name?: string;
+        createDestinationSlabOpening?: boolean;
+        createSourceCeilingOpening?: boolean;
+        destinationSlabId?: string;
+        sourceCeilingId?: string;
+        openingWidth?: number;
+        openingLength?: number;
+        openingOffset?: number;
+        openingCenter?: [number, number];
+        openingRotation?: number;
+    }>;
+    readonly place_items: import("./types.js").AgentOperation<import("./level-target.js").LevelTargetInput & {
+        items: {
+            assetId: string;
+            x: number;
+            z: number;
+            y?: number;
+            rotation?: number;
+            targetNodeId?: string;
+        }[];
+    }>;
+    readonly delete_node: import("./types.js").AgentOperation<{
+        id: string;
+    }>;
+    readonly find_by_type: import("./types.js").AgentOperation<{
+        type: string;
+        levelId?: string;
+    }>;
+    readonly create_room: import("./types.js").AgentOperation<import("./level-target.js").LevelTargetInput & {
+        name: string;
+        polygon: number[][];
+        color?: string;
+        wallHeight?: number;
+        wallThickness?: number;
+        outdoor?: boolean;
+        doors?: {
+            wallIndex: number;
+            t?: number;
+            width?: number;
+            height?: number;
+            sillHeight?: number;
+            hingesSide?: "left" | "right";
+            swingDirection?: "inward" | "outward";
+            style?: string;
+        }[];
+        windows?: {
+            wallIndex: number;
+            t?: number;
+            width?: number;
+            height?: number;
+            sillHeight?: number;
+            hingesSide?: "left" | "right";
+            swingDirection?: "inward" | "outward";
+            style?: string;
+        }[];
+    }>;
+    readonly furnish_room: import("./types.js").AgentOperation<import("./level-target.js").LevelTargetInput & {
+        zoneId?: string;
+        polygon?: number[][];
+        roomType: "entry" | "bedroom" | "kitchen" | "bathroom" | "living" | "dining" | "hallway" | "laundry" | "storage";
+        doorWallIndex?: number;
+    }>;
+    readonly search_assets: import("./types.js").AgentOperation<{
+        queries: {
+            query: string;
+            category?: string;
+        }[];
+    }>;
+    readonly paint: import("./types.js").AgentOperation<{
+        targets: string[];
+        role?: string;
+        color?: string;
+        material?: string | import("../index.js").MaterialSchema;
+        materialName?: string;
+        erase?: true;
+    }>;
+    readonly search_materials: import("./types.js").AgentOperation<{
+        queries: {
+            query: string;
+            surface?: import("../index.js").MaterialSurface;
+        }[];
+    }>;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent-operations/index.ts"],"names":[],"mappings":"AAoBA,cAAc,YAAY,CAAA;AAC1B,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,SAAS,CAAA;AACvB,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAE9B,qFAAqF;AACrF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuB2pE,CAAC;;;;;;;;;iBAAD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA/ErpE,CAAC;;;;;;;;;;;;;;mBACxB,CAAC;;;CA6EsB,CAAA"}