@pascal-app/core 1.0.1 → 1.0.4

package/dist/agent-operations/index.js

@@ -0,0 +1,80 @@
+import { addLevel } from './add-level.js';
+import { addWall } from './add-wall.js';
+import { createRoom } from './create-room.js';
+import { createStair } from './create-stair.js';
+import { deleteNode } from './delete-node.js';
+import { duplicateLevel } from './duplicate-level.js';
+import { findByType } from './find-by-type.js';
+import { furnishRoom } from './furnish-room.js';
+import { getNode } from './get-node.js';
+import { getLevelSummary, getWalls, getZones } from './level-reads.js';
+import { listLevels } from './list-levels.js';
+import { paint } from './paint.js';
+import { placeItems } from './place-items.js';
+import { ROOM_OPERATIONS } from './room-structure.js';
+import { searchAssets } from './search-assets.js';
+import { searchMaterials } from './search-materials.js';
+import { fitStair, measureStairOperation } from './stairs.js';
+import { verifyScene } from './verify-scene.js';
+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 const AGENT_OPERATIONS = {
+    measure_stair: measureStairOperation,
+    fit_stair: fitStair,
+    list_levels: listLevels,
+    get_node: getNode,
+    get_level_summary: getLevelSummary,
+    get_walls: getWalls,
+    get_zones: getZones,
+    duplicate_level: duplicateLevel,
+    verify_scene: verifyScene,
+    add_wall: addWall,
+    add_level: addLevel,
+    create_stair: createStair,
+    place_items: placeItems,
+    delete_node: deleteNode,
+    find_by_type: findByType,
+    create_room: createRoom,
+    furnish_room: furnishRoom,
+    search_assets: searchAssets,
+    paint,
+    search_materials: searchMaterials,
+    ...ROOM_OPERATIONS,
+};

package/dist/agent-operations/layout-clearance.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Shared plan-layout clearance for agent tools.
+ *
+ * - Door keep-outs (level-scoped)
+ * - Item–item AABB overlap (rotation + scale aware)
+ * - Placement candidate search when primary pose is blocked
+ *
+ * See packages/mcp/docs/layout-clearance-error-log.md for regression checklist.
+ */
+import type { AnyNode } from '../schema/index.js';
+import { type PlanAabb } from './door-clearance.js';
+export { aabbsOverlap, collectDoorKeepouts, findBlockedDoors, itemNodePlanAabb, itemPlanAabb, type PlanAabb, resolveNodeLevelId, } from './door-clearance.js';
+/** Minimum free space (m) required between item footprints. */
+export declare const DEFAULT_ITEM_GAP = 0.08;
+export type OccupiedFootprint = {
+    id: string;
+    name?: string;
+    levelId?: string | null;
+    aabb: PlanAabb;
+};
+export type ItemCollision = {
+    aId: string;
+    bId: string;
+    aName?: string;
+    bName?: string;
+    levelId?: string | null;
+    kind: 'item-aabb';
+    violation: 'overlap' | 'clearance';
+    minimumClearanceMeters: number;
+    message: string;
+};
+export declare function nodeItemAabb(node: AnyNode): PlanAabb | null;
+export declare function collectOccupiedFootprints(nodes: Iterable<AnyNode>, options?: {
+    levelId?: string;
+    excludeIds?: Set<string>;
+    floorOnly?: boolean;
+}): OccupiedFootprint[];
+export declare function findItemItemCollisions(args: {
+    nodes: Iterable<AnyNode>;
+    levelId?: string;
+    gap?: number;
+}): ItemCollision[];
+export type PlacementCandidate = {
+    x: number;
+    z: number;
+    rotationDeg: number;
+};
+export type PlacementRejectReason = 'outside_bounds' | 'blocks_door_clearance' | 'overlaps_item' | 'ok';
+export declare function classifyPlacement(args: {
+    aabb: PlanAabb;
+    doorKeepouts: PlanAabb[];
+    occupied: PlanAabb[];
+    roomBounds?: {
+        minX: number;
+        maxX: number;
+        minZ: number;
+        maxZ: number;
+    };
+    padding?: number;
+    itemGap?: number;
+    doorGap?: number;
+}): PlacementRejectReason;
+export declare function generatePlacementCandidates(primary: PlacementCandidate, options?: {
+    lateralsM?: number[];
+    insetsM?: number[];
+    inward?: {
+        x: number;
+        z: number;
+    };
+    along?: {
+        x: number;
+        z: number;
+    };
+}): PlacementCandidate[];
+export declare function findValidPlacement(args: {
+    primary: PlacementCandidate;
+    dimensions: [number, number, number] | number[] | undefined;
+    doorKeepouts: PlanAabb[];
+    occupied: PlanAabb[];
+    roomBounds?: {
+        minX: number;
+        maxX: number;
+        minZ: number;
+        maxZ: number;
+    };
+    along?: {
+        x: number;
+        z: number;
+    };
+    inward?: {
+        x: number;
+        z: number;
+    };
+}): {
+    candidate: PlacementCandidate;
+    reason: PlacementRejectReason;
+} | {
+    candidate: null;
+    reason: PlacementRejectReason;
+};
+/**
+ * Collect layout issues, scoped per level so stacked floors do not false-positive.
+ */
+export declare function layoutIssuesFromScene(nodes: Iterable<AnyNode>): {
+    type: 'door_blocked' | 'item_overlap' | 'item_too_close';
+    message: string;
+}[];
+//# sourceMappingURL=layout-clearance.d.ts.map

package/dist/agent-operations/layout-clearance.d.ts.map

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

package/dist/agent-operations/layout-clearance.js

@@ -0,0 +1,190 @@
+/**
+ * Shared plan-layout clearance for agent tools.
+ *
+ * - Door keep-outs (level-scoped)
+ * - Item–item AABB overlap (rotation + scale aware)
+ * - Placement candidate search when primary pose is blocked
+ *
+ * See packages/mcp/docs/layout-clearance-error-log.md for regression checklist.
+ */
+import { aabbsOverlap, findBlockedDoors, itemNodePlanAabb, itemPlanAabb, resolveNodeLevelId, } from './door-clearance.js';
+export { aabbsOverlap, collectDoorKeepouts, findBlockedDoors, itemNodePlanAabb, itemPlanAabb, resolveNodeLevelId, } from './door-clearance.js';
+/** Minimum free space (m) required between item footprints. */
+export const DEFAULT_ITEM_GAP = 0.08;
+export function nodeItemAabb(node) {
+    return itemNodePlanAabb(node);
+}
+export function collectOccupiedFootprints(nodes, options) {
+    const list = [...nodes];
+    const byId = new Map(list.map((n) => [n.id, n]));
+    const out = [];
+    for (const node of list) {
+        if (node.type !== 'item')
+            continue;
+        if (options?.excludeIds?.has(node.id))
+            continue;
+        const attach = node.asset?.attachTo;
+        if (options?.floorOnly &&
+            (attach === 'wall' || attach === 'wall-side' || attach === 'ceiling')) {
+            continue;
+        }
+        const levelId = resolveNodeLevelId(node.id, byId);
+        if (options?.levelId && levelId !== options.levelId)
+            continue;
+        // Floor packing: prefer level-parented items (not wall-hosted children).
+        if (options?.floorOnly && node.parentId && levelId && node.parentId !== levelId) {
+            if (attach === 'wall' || attach === 'wall-side' || attach === 'ceiling')
+                continue;
+            // Wall-parented items without attachTo still skipped for floor packing.
+            if (byId.get(node.parentId)?.type === 'wall')
+                continue;
+        }
+        const aabb = nodeItemAabb(node);
+        if (!aabb)
+            continue;
+        const name = node.name ?? node.asset?.name;
+        out.push({
+            id: node.id,
+            name: typeof name === 'string' ? name : undefined,
+            levelId,
+            aabb,
+        });
+    }
+    return out;
+}
+export function findItemItemCollisions(args) {
+    const gap = args.gap ?? DEFAULT_ITEM_GAP;
+    const footprints = collectOccupiedFootprints(args.nodes, { levelId: args.levelId });
+    const collisions = [];
+    for (let i = 0; i < footprints.length; i++) {
+        for (let j = i + 1; j < footprints.length; j++) {
+            const a = footprints[i];
+            const b = footprints[j];
+            if (a.levelId && b.levelId && a.levelId !== b.levelId)
+                continue;
+            if (!aabbsOverlap(a.aabb, b.aabb, gap))
+                continue;
+            collisions.push({
+                aId: a.id,
+                bId: b.id,
+                aName: a.name,
+                bName: b.name,
+                levelId: a.levelId ?? b.levelId,
+                kind: 'item-aabb',
+                violation: aabbsOverlap(a.aabb, b.aabb, 0) ? 'overlap' : 'clearance',
+                minimumClearanceMeters: gap,
+                message: aabbsOverlap(a.aabb, b.aabb, 0)
+                    ? `Items overlap: ${a.name ?? a.id} (${a.id}) and ${b.name ?? b.id} (${b.id})`
+                    : `Items are closer than ${gap} m: ${a.name ?? a.id} (${a.id}) and ${b.name ?? b.id} (${b.id})`,
+            });
+        }
+    }
+    return collisions;
+}
+export function classifyPlacement(args) {
+    const padding = args.padding ?? 0.05;
+    const itemGap = args.itemGap ?? DEFAULT_ITEM_GAP;
+    const doorGap = args.doorGap ?? 0.02;
+    if (args.roomBounds) {
+        const b = args.roomBounds;
+        if (args.aabb.minX < b.minX + padding ||
+            args.aabb.maxX > b.maxX - padding ||
+            args.aabb.minZ < b.minZ + padding ||
+            args.aabb.maxZ > b.maxZ - padding) {
+            return 'outside_bounds';
+        }
+    }
+    if (args.doorKeepouts.some((k) => aabbsOverlap(args.aabb, k, doorGap))) {
+        return 'blocks_door_clearance';
+    }
+    if (args.occupied.some((o) => aabbsOverlap(args.aabb, o, itemGap))) {
+        return 'overlaps_item';
+    }
+    return 'ok';
+}
+export function generatePlacementCandidates(primary, options) {
+    const laterals = options?.lateralsM ?? [0, -0.4, 0.4, -0.8, 0.8, -1.2, 1.2];
+    const insets = options?.insetsM ?? [0, 0.25, 0.5, 0.75];
+    const along = options?.along ?? { x: 1, z: 0 };
+    const inward = options?.inward ?? { x: 0, z: 1 };
+    const out = [];
+    const seen = new Set();
+    for (const lat of laterals) {
+        for (const inset of insets) {
+            const x = primary.x + along.x * lat + inward.x * inset;
+            const z = primary.z + along.z * lat + inward.z * inset;
+            const key = `${x.toFixed(3)},${z.toFixed(3)},${primary.rotationDeg}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ x, z, rotationDeg: primary.rotationDeg });
+        }
+    }
+    return out;
+}
+export function findValidPlacement(args) {
+    const candidates = generatePlacementCandidates(args.primary, {
+        along: args.along,
+        inward: args.inward,
+    });
+    // Prefer reporting why the **primary** pose failed (door/overlap), not the
+    // last lateral/inset candidate (often outside_bounds after large nudges).
+    let primaryReason = null;
+    const reasonPriority = [
+        'blocks_door_clearance',
+        'overlaps_item',
+        'outside_bounds',
+    ];
+    let bestFailReason = 'overlaps_item';
+    for (let i = 0; i < candidates.length; i++) {
+        const c = candidates[i];
+        const rot = (c.rotationDeg * Math.PI) / 180;
+        const aabb = itemPlanAabb([c.x, 0, c.z], args.dimensions, rot);
+        const reason = classifyPlacement({
+            aabb,
+            doorKeepouts: args.doorKeepouts,
+            occupied: args.occupied,
+            roomBounds: args.roomBounds,
+        });
+        if (reason === 'ok')
+            return { candidate: c, reason };
+        if (i === 0)
+            primaryReason = reason;
+        const prevRank = reasonPriority.indexOf(bestFailReason);
+        const nextRank = reasonPriority.indexOf(reason);
+        if (nextRank >= 0 && (prevRank < 0 || nextRank < prevRank)) {
+            bestFailReason = reason;
+        }
+    }
+    return { candidate: null, reason: primaryReason ?? bestFailReason };
+}
+/**
+ * Collect layout issues, scoped per level so stacked floors do not false-positive.
+ */
+export function layoutIssuesFromScene(nodes) {
+    const list = [...nodes];
+    const byId = new Map(list.map((n) => [n.id, n]));
+    const levelIds = new Set();
+    for (const n of list) {
+        if (n.type === 'level')
+            levelIds.add(n.id);
+    }
+    // Also collect levels referenced by walls/items (in case filter missed)
+    for (const n of list) {
+        const lid = resolveNodeLevelId(n.id, byId);
+        if (lid)
+            levelIds.add(lid);
+    }
+    const issues = new Map();
+    const levels = levelIds.size > 0 ? [...levelIds] : [undefined];
+    for (const levelId of levels) {
+        for (const b of findBlockedDoors({ nodes: list, levelId })) {
+            issues.set(b.message, 'door_blocked');
+        }
+        for (const c of findItemItemCollisions({ nodes: list, levelId })) {
+            issues.set(c.message, c.violation === 'overlap' ? 'item_overlap' : 'item_too_close');
+        }
+    }
+    // Deduplicate (node may appear under multiple walks)
+    return [...issues].map(([message, type]) => ({ type, message }));
+}

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

@@ -0,0 +1,33 @@
+import type { WallNode } from '../schema/index.js';
+import { type LevelTargetInput } from './level-target.js';
+import type { AgentOperation, SceneNodes } from './types.js';
+/**
+ * The height a wall stands at, as rendered: its own, or its storey's plane (clamped under a
+ * covering slab) above the slab it stands on. Pure over the scene, unlike the viewer's grid.
+ */
+export declare function wallResolvedHeight(nodes: SceneNodes, wall: WallNode): number;
+export declare function wallSummary(nodes: SceneNodes, wall: WallNode): {
+    id: `wall_${string}`;
+    name: string | undefined;
+    start: [number, number];
+    end: [number, number];
+    length: number;
+    height: number | undefined;
+    resolvedHeight: number;
+    heightIsExplicit: boolean;
+    thickness: number | undefined;
+    openings: {
+        id: `item_${string}` | `procedural-item_${string}` | `door_${string}` | `window_${string}` | `leanto_${string}`;
+        type: "door" | "window";
+        position: [number, number, number];
+        width: number;
+        height: number;
+    }[];
+};
+/** `get_level_summary`. */
+export declare const getLevelSummary: AgentOperation<LevelTargetInput>;
+/** `get_walls`. */
+export declare const getWalls: AgentOperation<LevelTargetInput>;
+/** `get_zones`. */
+export declare const getZones: AgentOperation<LevelTargetInput>;
+//# sourceMappingURL=level-reads.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"level-reads.d.ts","sourceRoot":"","sources":["../../src/agent-operations/level-reads.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAA2C,QAAQ,EAAY,MAAM,WAAW,CAAA;AAK5F,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,gBAAgB,CAAA;AAEnE,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAQzD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,CAe5E;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ;;;;;;;;;;;;;;;;;EAkB5D;AA2GD,2BAA2B;AAC3B,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,gBAAgB,CAE3D,CAAA;AAEF,mBAAmB;AACnB,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,gBAAgB,CAIrD,CAAA;AAED,mBAAmB;AACnB,eAAO,MAAM,QAAQ,EAAE,cAAc,CAAC,gBAAgB,CAIrD,CAAA"}

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

@@ -0,0 +1,161 @@
+import { area } from '../lib/polygon-boolean.js';
+import { roomFloorChoices } from '../lib/room-floor-choices.js';
+import { DEFAULT_LEVEL_HEIGHT } from '../services/level-height.js';
+import { getWallPlaneTop } from '../services/storey.js';
+import { computeWallSlabSupport } from '../systems/slab/slab-support.js';
+import { resolveWallEffectiveHeight } from '../systems/wall/wall-top.js';
+import { targetLevel } from './level-target.js';
+import { contentCounts, levelIdOf, levelRole, nodesOnLevel } from './scene-queries.js';
+const round2 = (value) => Math.round(value * 100) / 100;
+function ofType(content, type) {
+    return content.filter((node) => node.type === type);
+}
+/**
+ * The height a wall stands at, as rendered: its own, or its storey's plane (clamped under a
+ * covering slab) above the slab it stands on. Pure over the scene, unlike the viewer's grid.
+ */
+export function wallResolvedHeight(nodes, wall) {
+    const levelId = levelIdOf(nodes, wall.id);
+    if (!levelId)
+        return resolveWallEffectiveHeight(wall, DEFAULT_LEVEL_HEIGHT, 0);
+    const onLevel = nodesOnLevel(nodes, levelId);
+    const support = computeWallSlabSupport(wall, ofType(onLevel, 'slab'), ofType(onLevel, 'wall'), wall.supportSlabId, undefined, 0, nodes);
+    const planeTop = getWallPlaneTop(wall, levelId, nodes);
+    return resolveWallEffectiveHeight(wall, planeTop, support.elevation);
+}
+export function wallSummary(nodes, wall) {
+    return {
+        id: wall.id,
+        name: wall.name,
+        start: wall.start,
+        end: wall.end,
+        length: round2(Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1])),
+        height: wall.height,
+        resolvedHeight: wallResolvedHeight(nodes, wall),
+        heightIsExplicit: wall.height !== undefined,
+        thickness: wall.thickness,
+        openings: wall.children.flatMap((id) => {
+            const child = nodes[id];
+            if (child?.type !== 'door' && child?.type !== 'window')
+                return [];
+            const { type, position, width, height } = child;
+            return [{ id, type, position, width, height }];
+        }),
+    };
+}
+function zoneSize(zone) {
+    const xs = zone.polygon.map((point) => point[0]);
+    const zs = zone.polygon.map((point) => point[1]);
+    return {
+        areaSqMeters: round2(area([{ outer: zone.polygon, holes: zone.holes ?? [] }])),
+        bounds: {
+            width: round2(Math.max(...xs) - Math.min(...xs)),
+            depth: round2(Math.max(...zs) - Math.min(...zs)),
+        },
+    };
+}
+const zoneSummary = (nodes, zone) => ({
+    id: zone.id,
+    name: zone.name,
+    color: zone.color,
+    polygon: zone.polygon,
+    holes: zone.holes ?? [],
+    ...zoneSize(zone),
+    floor_choices: roomFloorChoices(nodes, zone.id),
+});
+const itemSummary = (item) => ({
+    id: item.id,
+    name: item.name ?? item.asset.name,
+    parentId: item.parentId,
+    position: item.position,
+    assetId: item.asset.id,
+    category: item.asset.category,
+});
+// Listed on their own, or inside what holds them (openings in walls, flights in stairs).
+const SUMMARISED = new Set([
+    'wall',
+    'door',
+    'window',
+    'zone',
+    'slab',
+    'ceiling',
+    'item',
+    'floor-opening',
+    'stair',
+    'stair-segment',
+    'roof',
+    'roof-segment',
+]);
+/** Everything on a level, compactly: what to act on, with ids. Polygons stay in get_zones. */
+function levelSummary(nodes, level) {
+    const content = nodesOnLevel(nodes, level.id);
+    const { role, metadataRole, referenceLevelId } = levelRole(nodes, level);
+    return {
+        levelId: level.id,
+        levelName: level.name,
+        floorIndex: level.level,
+        role,
+        metadataRole,
+        isOccupiedStory: role === 'occupied',
+        isSupportLevel: role !== 'occupied',
+        referenceLevelId,
+        counts: contentCounts(content),
+        walls: ofType(content, 'wall').map((wall) => wallSummary(nodes, wall)),
+        zones: ofType(content, 'zone').map((zone) => ({
+            id: zone.id,
+            name: zone.name,
+            holes: zone.holes ?? [],
+            ...zoneSize(zone),
+            floor_choices: roomFloorChoices(nodes, zone.id),
+        })),
+        slabs: ofType(content, 'slab').map((slab) => ({
+            id: slab.id,
+            elevation: slab.elevation,
+            holeCount: slab.holes?.length ?? 0,
+        })),
+        ceilings: ofType(content, 'ceiling').map((ceiling) => ({
+            id: ceiling.id,
+            height: ceiling.height,
+            itemCount: ceiling.children.filter((id) => nodes[id]?.type === 'item').length,
+        })),
+        items: ofType(content, 'item').map(itemSummary),
+        openings: ofType(content, 'floor-opening').map((opening) => ({
+            id: opening.id,
+            polygon: opening.polygon,
+            hostZoneId: opening.hostZoneId ?? null,
+            source: opening.source,
+            drawnOn: opening.drawnOn,
+            cutsPrimary: opening.cutsPrimary,
+            cutsAdjacent: opening.cutsAdjacent,
+        })),
+        stairs: ofType(content, 'stair').map((stair) => ({
+            id: stair.id,
+            name: stair.name,
+            position: stair.position,
+        })),
+        roofs: ofType(content, 'roof').map((roof) => ({
+            id: roof.id,
+            name: roof.name,
+            segmentCount: roof.children.length,
+        })),
+        other: content
+            .filter((node) => !SUMMARISED.has(node.type))
+            .map((node) => ({ id: node.id, type: node.type, name: node.name })),
+    };
+}
+/** `get_level_summary`. */
+export const getLevelSummary = (nodes, input, context) => ({
+    result: levelSummary(nodes, targetLevel(nodes, input, context)),
+});
+/** `get_walls`. */
+export const getWalls = (nodes, input, context) => {
+    const level = targetLevel(nodes, input, context);
+    const walls = ofType(nodesOnLevel(nodes, level.id), 'wall');
+    return { result: { levelId: level.id, walls: walls.map((wall) => wallSummary(nodes, wall)) } };
+};
+/** `get_zones`. */
+export const getZones = (nodes, input, context) => {
+    const level = targetLevel(nodes, input, context);
+    const zones = ofType(nodesOnLevel(nodes, level.id), 'zone');
+    return { result: { levelId: level.id, zones: zones.map((zone) => zoneSummary(nodes, zone)) } };
+};

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

@@ -0,0 +1,11 @@
+import type { LevelNode } from '../schema/index.js';
+import type { AgentContext, SceneNodes } from './types.js';
+export type LevelTargetInput = {
+    levelId?: string;
+    level?: string;
+};
+/** A level named by id, or a refusal saying what the id is instead. */
+export declare function requireLevel(nodes: SceneNodes, levelId: string): LevelNode;
+/** The level a read targets: the one named, else the viewed floor, else the lowest storey. */
+export declare function targetLevel(nodes: SceneNodes, { levelId, level }: LevelTargetInput, context: AgentContext): LevelNode;
+//# sourceMappingURL=level-target.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"level-target.d.ts","sourceRoot":"","sources":["../../src/agent-operations/level-target.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEvD,MAAM,MAAM,gBAAgB,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEnE,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAY1E;AAED,8FAA8F;AAC9F,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,gBAAgB,EACpC,OAAO,EAAE,YAAY,GACpB,SAAS,CAaX"}

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

@@ -0,0 +1,29 @@
+import { refuse } from '../agent-tools/refusal.js';
+import { levelRole, levelsOf } from './scene-queries.js';
+/** A level named by id, or a refusal saying what the id is instead. */
+export function requireLevel(nodes, levelId) {
+    const node = nodes[levelId];
+    if (!node)
+        refuse('level_not_found', `Level not found: ${levelId}. Use an id list_levels returned.`, {
+            levelId,
+        });
+    if (node.type !== 'level')
+        refuse('not_a_level', `Node ${levelId} is a ${node.type}, not a level.`, {
+            levelId,
+            type: node.type,
+        });
+    return node;
+}
+/** The level a read targets: the one named, else the viewed floor, else the lowest storey. */
+export function targetLevel(nodes, { levelId, level }, context) {
+    if (levelId && level && levelId !== level)
+        refuse('conflicting_level', `levelId (${levelId}) and level (${level}) disagree; they are the same field, pass one.`, { levelId, level });
+    const named = levelId ?? level ?? context.activeLevelId;
+    if (named)
+        return requireLevel(nodes, named);
+    const levels = levelsOf(nodes);
+    const lowest = levels.find((entry) => levelRole(nodes, entry).role === 'occupied') ?? levels[0];
+    if (!lowest)
+        refuse('no_levels', 'The scene has no level yet.');
+    return lowest;
+}

package/dist/agent-operations/list-levels.d.ts

@@ -0,0 +1,4 @@
+import type { AgentOperation } from './types.js';
+/** `list_levels`: every level of every building, in floor order, with its role. */
+export declare const listLevels: AgentOperation;
+//# sourceMappingURL=list-levels.d.ts.map

package/dist/agent-operations/list-levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-levels.d.ts","sourceRoot":"","sources":["../../src/agent-operations/list-levels.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,mFAAmF;AACnF,eAAO,MAAM,UAAU,EAAE,cA4BxB,CAAA"}

package/dist/agent-operations/list-levels.js

@@ -0,0 +1,31 @@
+import { levelRole, levelsOf } from './scene-queries.js';
+/** `list_levels`: every level of every building, in floor order, with its role. */
+export const listLevels = (nodes, _input, context) => {
+    const levels = levelsOf(nodes).map((level) => {
+        const { role, metadataRole, referenceLevelId } = levelRole(nodes, level);
+        return {
+            id: level.id,
+            name: level.name,
+            floorIndex: level.level,
+            parentId: level.parentId,
+            role,
+            metadataRole,
+            isOccupiedStory: role === 'occupied',
+            isSupportLevel: role !== 'occupied',
+            referenceLevelId,
+            childCount: Array.isArray(level.children) ? level.children.length : 0,
+            isActive: level.id === context.activeLevelId,
+        };
+    });
+    const occupiedStoryCount = levels.filter((level) => level.isOccupiedStory).length;
+    return {
+        result: {
+            activeLevelId: context.activeLevelId,
+            levelCount: levels.length,
+            occupiedStoryCount,
+            supportLevelCount: levels.length - occupiedStoryCount,
+            roofLevelIds: levels.filter((level) => level.role === 'roof').map((level) => level.id),
+            levels,
+        },
+    };
+};