@pascal-app/mcp 0.2.0

package/dist/tools/scene-query.js

@@ -0,0 +1,645 @@
+import { z } from 'zod';
+import { distance2D, pointInPolygon, polygonArea, polygonContainsPolygon, wallLength, } from './geometry';
+import { NodeIdSchema } from './schemas';
+export const levelScopedInput = {
+    levelId: NodeIdSchema.optional(),
+};
+const jsonObject = z.record(z.string(), z.unknown());
+export const listLevelsOutput = {
+    activeSceneId: z.string().nullable(),
+    levelCount: z.number(),
+    occupiedStoryCount: z.number(),
+    supportLevelCount: z.number(),
+    roofLevelIds: z.array(z.string()),
+    levels: z.array(jsonObject),
+};
+export const getLevelSummaryOutput = {
+    levelId: z.string(),
+    levelName: z.string().optional(),
+    role: z.string(),
+    metadataRole: z.string().nullable(),
+    isOccupiedStory: z.boolean(),
+    isSupportLevel: z.boolean(),
+    referenceLevelId: z.string().nullable(),
+    counts: jsonObject,
+    walls: z.array(jsonObject),
+    zones: z.array(jsonObject),
+    items: z.array(jsonObject),
+    slabs: z.array(jsonObject),
+    ceilings: z.array(jsonObject),
+};
+export const getWallsOutput = {
+    levelId: z.string(),
+    walls: z.array(jsonObject),
+};
+export const getZonesOutput = {
+    levelId: z.string(),
+    zones: z.array(jsonObject),
+};
+export const verifySceneOutput = {
+    ok: z.boolean(),
+    valid: z.boolean(),
+    levelCount: z.number(),
+    occupiedStoryCount: z.number(),
+    supportLevelCount: z.number(),
+    roofLevelIds: z.array(z.string()),
+    activeSceneId: z.string().nullable(),
+    levels: z.array(jsonObject),
+    emptyLevelIds: z.array(z.string()),
+    issues: z.array(z.string()),
+    hasIssues: z.boolean(),
+};
+function textResult(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload) }],
+        structuredContent: payload,
+    };
+}
+function getLevels(bridge) {
+    return bridge.findNodes({ type: 'level' }).sort((a, b) => {
+        const aa = a.type === 'level' ? a.level : 0;
+        const bb = b.type === 'level' ? b.level : 0;
+        return aa - bb;
+    });
+}
+function getDefaultLevelId(bridge, requested) {
+    if (requested)
+        return requested;
+    const level = getLevels(bridge)[0];
+    return level?.id ?? null;
+}
+function nodesOnLevel(bridge, levelId) {
+    return Object.values(bridge.getNodes()).filter((node) => node.id !== levelId && bridge.resolveLevelId(node.id) === levelId);
+}
+function metadataRecord(node) {
+    return typeof node.metadata === 'object' && node.metadata !== null
+        ? node.metadata
+        : null;
+}
+function metadataString(node, key) {
+    const value = metadataRecord(node)?.[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function occupiedContentCount(counts) {
+    return (counts.walls +
+        counts.zones +
+        counts.doors +
+        counts.windows +
+        counts.items +
+        counts.slabs +
+        counts.ceilings +
+        counts.stairs);
+}
+function classifyLevel(level, counts) {
+    const metadataRole = metadataString(level, 'role');
+    if (metadataRole === 'roof')
+        return 'roof';
+    if (metadataRole === 'support')
+        return 'support';
+    if (counts.roofs > 0 && occupiedContentCount(counts) === 0)
+        return 'roof';
+    return 'occupied';
+}
+function openingSummaries(bridge, wallId) {
+    return bridge
+        .getChildren(wallId)
+        .filter((child) => child.type === 'door' || child.type === 'window')
+        .map((child) => ({
+        id: child.id,
+        type: child.type,
+        position: child.position,
+        width: child.width,
+        height: child.height,
+    }));
+}
+function wallSummary(bridge, wall) {
+    if (wall.type !== 'wall')
+        return null;
+    const length = distance2D(wall.start, wall.end);
+    return {
+        id: wall.id,
+        name: wall.name,
+        start: wall.start,
+        end: wall.end,
+        length: Math.round(length * 100) / 100,
+        height: wall.height,
+        thickness: wall.thickness,
+        openings: openingSummaries(bridge, wall.id),
+    };
+}
+function zoneSummary(zone) {
+    if (zone.type !== 'zone')
+        return null;
+    const xs = zone.polygon.map((p) => p[0]);
+    const zs = zone.polygon.map((p) => p[1]);
+    return {
+        id: zone.id,
+        name: zone.name,
+        color: zone.color,
+        polygon: zone.polygon,
+        areaSqMeters: Math.round(polygonArea(zone.polygon) * 100) / 100,
+        bounds: {
+            width: Math.round((Math.max(...xs) - Math.min(...xs)) * 100) / 100,
+            depth: Math.round((Math.max(...zs) - Math.min(...zs)) * 100) / 100,
+        },
+    };
+}
+function itemSummary(item) {
+    if (item.type !== 'item')
+        return null;
+    return {
+        id: item.id,
+        name: item.name ?? item.asset.name,
+        parentId: item.parentId,
+        position: item.position,
+        rotation: item.rotation,
+        asset: {
+            id: item.asset.id,
+            name: item.asset.name,
+            category: item.asset.category,
+            dimensions: item.asset.dimensions,
+            attachTo: item.asset.attachTo ?? null,
+        },
+    };
+}
+function rotateXZ(x, z, angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return [x * cos + z * sin, -x * sin + z * cos];
+}
+function toWorldPlanPoint(stair, localX, localZ) {
+    const [worldX, worldZ] = rotateXZ(localX, localZ, stair.rotation ?? 0);
+    return [stair.position[0] + worldX, stair.position[2] + worldZ];
+}
+function computeSegmentTransforms(segments) {
+    const transforms = [];
+    let currentX = 0;
+    let currentY = 0;
+    let currentZ = 0;
+    let currentRot = 0;
+    for (let index = 0; index < segments.length; index++) {
+        const segment = segments[index];
+        if (!segment)
+            continue;
+        if (index === 0) {
+            transforms.push({ position: [currentX, currentY, currentZ], rotation: currentRot });
+            continue;
+        }
+        const previous = segments[index - 1];
+        if (!previous)
+            continue;
+        let attachX = 0;
+        let attachZ = 0;
+        let rotationDelta = 0;
+        switch (segment.attachmentSide) {
+            case 'front':
+                attachZ = previous.length;
+                break;
+            case 'left':
+                attachX = previous.width / 2;
+                attachZ = previous.length / 2;
+                rotationDelta = Math.PI / 2;
+                break;
+            case 'right':
+                attachX = -previous.width / 2;
+                attachZ = previous.length / 2;
+                rotationDelta = -Math.PI / 2;
+                break;
+        }
+        const [deltaX, deltaZ] = rotateXZ(attachX, attachZ, currentRot);
+        currentX += deltaX;
+        currentY += previous.height;
+        currentZ += deltaZ;
+        currentRot += rotationDelta;
+        transforms.push({ position: [currentX, currentY, currentZ], rotation: currentRot });
+    }
+    return transforms;
+}
+function stairFootprintPolygons(bridge, stair) {
+    if (stair.stairType === 'curved' || stair.stairType === 'spiral') {
+        const radius = Math.max(0.05, stair.innerRadius ?? 0.9) + Math.max(stair.width ?? 1, 0.4);
+        return [
+            Array.from({ length: 24 }).map((_, index) => {
+                const angle = (index / 24) * Math.PI * 2;
+                return toWorldPlanPoint(stair, Math.cos(angle) * radius, Math.sin(angle) * radius);
+            }),
+        ];
+    }
+    const nodes = bridge.getNodes();
+    const segments = (stair.children ?? [])
+        .map((childId) => nodes[childId])
+        .filter((node) => node?.type === 'stair-segment');
+    const usableSegments = segments.length > 0
+        ? segments
+        : [
+            {
+                width: stair.width ?? 1,
+                length: 3,
+                height: stair.totalRise ?? 2.5,
+                stepCount: stair.stepCount ?? 10,
+                attachmentSide: 'front',
+            },
+        ];
+    const transforms = computeSegmentTransforms(usableSegments);
+    return usableSegments.map((segment, index) => {
+        const transform = transforms[index] ?? {
+            position: [0, 0, 0],
+            rotation: 0,
+        };
+        const halfWidth = segment.width / 2;
+        const corners = [
+            [-halfWidth, 0],
+            [halfWidth, 0],
+            [halfWidth, segment.length],
+            [-halfWidth, segment.length],
+        ];
+        return corners.map(([localX, localZ]) => {
+            const [rx, rz] = rotateXZ(localX, localZ, transform.rotation);
+            return toWorldPlanPoint(stair, transform.position[0] + rx, transform.position[2] + rz);
+        });
+    });
+}
+function wallSamplePoints(wall) {
+    return [0.25, 0.5, 0.75].map((t) => [
+        wall.start[0] + (wall.end[0] - wall.start[0]) * t,
+        wall.start[1] + (wall.end[1] - wall.start[1]) * t,
+    ]);
+}
+function getLevelNumber(levelId, nodes) {
+    if (!levelId)
+        return undefined;
+    const node = nodes[levelId];
+    return node?.type === 'level' ? node.level : undefined;
+}
+function targetLevelIdsForStair(bridge, stair) {
+    const nodes = bridge.getNodes();
+    const parentLevelId = bridge.resolveLevelId(stair.id);
+    const fromLevelId = (stair.fromLevelId ?? parentLevelId);
+    const toLevelId = (stair.toLevelId ?? fromLevelId);
+    const fromLevel = getLevelNumber(fromLevelId, nodes);
+    const toLevel = getLevelNumber(toLevelId, nodes);
+    if (fromLevel === undefined || toLevel === undefined) {
+        return toLevelId ? [toLevelId] : [];
+    }
+    const minLevel = Math.min(fromLevel, toLevel);
+    const maxLevel = Math.max(fromLevel, toLevel);
+    return getLevels(bridge)
+        .filter((level) => level.type === 'level' && level.level > minLevel && level.level <= maxLevel)
+        .map((level) => level.id);
+}
+function holeBelongsToStair(surface, holeIndex, stairId) {
+    const metadata = surface.holeMetadata?.[holeIndex];
+    return metadata?.source === 'stair' && metadata.stairId === stairId;
+}
+function parentListsChild(parent, childId) {
+    if (!('children' in parent && Array.isArray(parent.children)))
+        return false;
+    return parent.children.some((child) => {
+        if (typeof child === 'string')
+            return child === childId;
+        return (child !== null &&
+            typeof child === 'object' &&
+            'id' in child &&
+            child.id === childId);
+    });
+}
+function levelSummary(bridge, levelId) {
+    const level = bridge.getNode(levelId);
+    if (!level || level.type !== 'level') {
+        throw new Error(`Level not found: ${levelId}`);
+    }
+    const nodes = nodesOnLevel(bridge, levelId);
+    const walls = nodes
+        .map((n) => wallSummary(bridge, n))
+        .filter((n) => !!n);
+    const zones = nodes.map(zoneSummary).filter((n) => !!n);
+    const items = nodes.map(itemSummary).filter((n) => !!n);
+    const slabs = nodes
+        .filter((node) => node.type === 'slab')
+        .map((node) => ({
+        id: node.id,
+        polygon: node.polygon,
+        holes: node.holes ?? [],
+        holeMetadata: node.holeMetadata ?? [],
+        elevation: node.elevation,
+    }));
+    const ceilings = nodes
+        .filter((node) => node.type === 'ceiling')
+        .map((node) => ({
+        id: node.id,
+        polygon: node.polygon,
+        holes: node.holes ?? [],
+        holeMetadata: node.holeMetadata ?? [],
+        height: node.height,
+    }));
+    const doors = nodes.filter((node) => node.type === 'door');
+    const windows = nodes.filter((node) => node.type === 'window');
+    const roofs = nodes.filter((node) => node.type === 'roof');
+    const stairs = nodes.filter((node) => node.type === 'stair');
+    const counts = {
+        walls: walls.length,
+        zones: zones.length,
+        doors: doors.length,
+        windows: windows.length,
+        items: items.length,
+        slabs: slabs.length,
+        ceilings: ceilings.length,
+        roofs: roofs.length,
+        stairs: stairs.length,
+    };
+    const role = classifyLevel(level, counts);
+    const metadataRole = metadataString(level, 'role') ?? null;
+    const referenceLevelId = metadataString(level, 'referenceLevelId') ?? null;
+    return {
+        levelId,
+        levelName: level.name,
+        floorIndex: level.level,
+        role,
+        metadataRole,
+        isOccupiedStory: role === 'occupied',
+        isSupportLevel: role !== 'occupied',
+        referenceLevelId,
+        counts,
+        walls,
+        zones,
+        items,
+        slabs,
+        ceilings,
+    };
+}
+export function registerListLevels(server, bridge) {
+    server.registerTool('list_levels', {
+        title: 'List levels',
+        description: 'List all levels in the current scene with ids, names, floor indices, and child counts.',
+        inputSchema: {},
+        outputSchema: listLevelsOutput,
+    }, async () => {
+        const activeScene = bridge.getActiveScene();
+        const levels = getLevels(bridge).map((level) => {
+            const summary = levelSummary(bridge, level.id);
+            return {
+                id: level.id,
+                name: level.name,
+                floorIndex: level.type === 'level' ? level.level : 0,
+                parentId: level.parentId,
+                role: summary.role,
+                metadataRole: summary.metadataRole,
+                isOccupiedStory: summary.isOccupiedStory,
+                isSupportLevel: summary.isSupportLevel,
+                referenceLevelId: summary.referenceLevelId,
+                childCount: bridge.getChildren(level.id).length,
+            };
+        });
+        const occupiedStoryCount = levels.filter((level) => level.isOccupiedStory).length;
+        const roofLevelIds = levels
+            .filter((level) => level.role === 'roof')
+            .map((level) => level.id);
+        return textResult({
+            activeSceneId: activeScene?.id ?? null,
+            levelCount: levels.length,
+            occupiedStoryCount,
+            supportLevelCount: levels.length - occupiedStoryCount,
+            roofLevelIds,
+            levels,
+        });
+    });
+}
+export function registerGetLevelSummary(server, bridge) {
+    server.registerTool('get_level_summary', {
+        title: 'Get level summary',
+        description: 'Get a compact model-friendly summary of one level: counts plus walls, zones, slabs, ceilings, and items. Omit levelId to use the first level.',
+        inputSchema: levelScopedInput,
+        outputSchema: getLevelSummaryOutput,
+    }, async ({ levelId }) => {
+        const resolved = getDefaultLevelId(bridge, levelId);
+        if (!resolved)
+            throw new Error('No level exists in the scene');
+        return textResult(levelSummary(bridge, resolved));
+    });
+}
+export function registerGetWalls(server, bridge) {
+    server.registerTool('get_walls', {
+        title: 'Get walls',
+        description: 'Get walls on a level with start/end coordinates, length, height, thickness, and child doors/windows. Omit levelId to use the first level.',
+        inputSchema: levelScopedInput,
+        outputSchema: getWallsOutput,
+    }, async ({ levelId }) => {
+        const resolved = getDefaultLevelId(bridge, levelId);
+        if (!resolved)
+            throw new Error('No level exists in the scene');
+        return textResult({
+            levelId: resolved,
+            walls: levelSummary(bridge, resolved).walls,
+        });
+    });
+}
+export function registerGetZones(server, bridge) {
+    server.registerTool('get_zones', {
+        title: 'Get zones',
+        description: 'Get room/zone polygons on a level with names, colors, bounds, and approximate areas. Omit levelId to use the first level.',
+        inputSchema: levelScopedInput,
+        outputSchema: getZonesOutput,
+    }, async ({ levelId }) => {
+        const resolved = getDefaultLevelId(bridge, levelId);
+        if (!resolved)
+            throw new Error('No level exists in the scene');
+        return textResult({
+            levelId: resolved,
+            zones: levelSummary(bridge, resolved).zones,
+        });
+    });
+}
+export function registerVerifyScene(server, bridge) {
+    server.registerTool('verify_scene', {
+        title: 'Verify scene',
+        description: 'High-level self-check after complex edits. Returns validation status, per-level room/content counts, empty levels, and practical layout issues.',
+        inputSchema: {},
+        outputSchema: verifySceneOutput,
+    }, async () => {
+        const validation = bridge.validateScene();
+        const levels = getLevels(bridge).map((level) => {
+            const summary = levelSummary(bridge, level.id);
+            const totalContent = Object.values(summary.counts).reduce((sum, count) => sum + (typeof count === 'number' ? count : 0), 0);
+            return {
+                levelId: level.id,
+                levelName: level.name ?? `Level ${summary.floorIndex}`,
+                floorIndex: summary.floorIndex,
+                role: summary.role,
+                metadataRole: summary.metadataRole,
+                isOccupiedStory: summary.isOccupiedStory,
+                isSupportLevel: summary.isSupportLevel,
+                referenceLevelId: summary.referenceLevelId,
+                isEmpty: totalContent === 0,
+                content: summary.counts,
+            };
+        });
+        const issues = [];
+        const occupiedStoryCount = levels.filter((level) => level.isOccupiedStory).length;
+        const roofLevelIds = levels
+            .filter((level) => level.role === 'roof')
+            .map((level) => level.levelId);
+        const emptyLevelIds = levels.filter((level) => level.isEmpty).map((level) => level.levelId);
+        if (emptyLevelIds.length > 0) {
+            issues.push(`Empty level(s): ${emptyLevelIds.join(', ')}`);
+        }
+        for (const level of levels) {
+            const occupiedContent = occupiedContentCount(level.content);
+            if (level.role === 'roof') {
+                if (level.content.roofs === 0) {
+                    issues.push(`${level.levelName} is a roof support level but has no roof geometry; add or move roof geometry there rather than deleting the support level to satisfy story count`);
+                }
+                if (occupiedContent > 0) {
+                    issues.push(`${level.levelName} is a roof support level but contains occupied-story content; move rooms, walls, stairs, slabs, ceilings, and items to an occupied story and keep the roof level for roof geometry only`);
+                }
+                if (level.referenceLevelId) {
+                    const referenceLevel = bridge.getNode(level.referenceLevelId);
+                    if (referenceLevel?.type === 'level' && level.floorIndex <= referenceLevel.level) {
+                        issues.push(`${level.levelName} roof support level should be above its reference occupied level ${referenceLevel.name ?? referenceLevel.id}`);
+                    }
+                }
+                continue;
+            }
+            if (level.content.walls > 0 && level.content.zones === 0) {
+                issues.push(`${level.levelName} has walls but no zones/rooms`);
+            }
+            if (level.content.zones > 0 && level.content.slabs === 0) {
+                issues.push(`${level.levelName} has zones but no slabs/floors`);
+            }
+            if (level.content.zones > 0 && level.content.ceilings === 0) {
+                issues.push(`${level.levelName} has zones but no ceilings`);
+            }
+            if (level.content.walls > 0 && level.content.doors === 0) {
+                issues.push(`${level.levelName} has walls but no doors`);
+            }
+            if (level.content.roofs > 0 &&
+                (level.content.walls > 0 || level.content.zones > 0 || level.content.stairs > 0)) {
+                issues.push(`${level.levelName} mixes roof geometry with occupied-level content; place roofs on a dedicated roof level for solo/exploded level views`);
+            }
+        }
+        const hasMultipleOccupiedStories = occupiedStoryCount > 1;
+        if (hasMultipleOccupiedStories) {
+            for (const level of getLevels(bridge)) {
+                if (level.type !== 'level')
+                    continue;
+                const summary = levels.find((entry) => entry.levelId === level.id);
+                if (!summary?.isOccupiedStory)
+                    continue;
+                const expectedHeight = typeof level.metadata === 'object' &&
+                    level.metadata !== null &&
+                    'height' in level.metadata &&
+                    typeof level.metadata.height === 'number'
+                    ? level.metadata.height
+                    : 3.2;
+                for (const wall of nodesOnLevel(bridge, level.id).filter((node) => node.type === 'wall')) {
+                    const wallHeight = wall.height ?? 2.5;
+                    if (wallHeight > expectedHeight + 0.25) {
+                        issues.push(`Wall ${wall.name ?? wall.id} on ${level.name ?? level.id} is ${wallHeight}m high; multi-story exterior walls should be split into level-owned story walls`);
+                    }
+                }
+            }
+        }
+        for (const node of Object.values(bridge.getNodes())) {
+            if (node.type === 'door' || node.type === 'window') {
+                const parent = node.parentId ? bridge.getNode(node.parentId) : null;
+                if (!parent || parent.type !== 'wall') {
+                    issues.push(`${node.type} ${node.id} is not parented to a wall`);
+                    continue;
+                }
+                if (node.wallId !== parent.id) {
+                    issues.push(`${node.type} ${node.id} has wallId ${node.wallId ?? 'unset'} but is parented to wall ${parent.id}`);
+                }
+                if (!parentListsChild(parent, node.id)) {
+                    issues.push(`${node.type} ${node.id} is not listed in wall ${parent.id} children`);
+                }
+                const length = wallLength(parent);
+                const width = node.width ?? (node.type === 'door' ? 0.9 : 1.5);
+                const height = node.height ?? (node.type === 'door' ? 2.1 : 1.5);
+                const localX = node.position[0];
+                if (localX - width / 2 < -0.01 || localX + width / 2 > length + 0.01) {
+                    issues.push(`${node.type} ${node.id} extends outside wall ${parent.id}`);
+                }
+                const wallHeight = parent.height ?? 2.5;
+                const bottom = node.position[1] - height / 2;
+                const top = node.position[1] + height / 2;
+                if (bottom < -0.01 || top > wallHeight + 0.01) {
+                    issues.push(`${node.type} ${node.id} vertical bounds [${bottom.toFixed(2)}, ${top.toFixed(2)}] exceed wall ${parent.id} height ${wallHeight.toFixed(2)}m`);
+                }
+            }
+        }
+        for (const stair of Object.values(bridge.getNodes()).filter((node) => node.type === 'stair')) {
+            const sourceLevelId = bridge.resolveLevelId(stair.id);
+            if (sourceLevelId) {
+                const sourceLevel = bridge.getNode(sourceLevelId);
+                const footprints = stairFootprintPolygons(bridge, stair);
+                const sourceSlabs = nodesOnLevel(bridge, sourceLevelId).filter((node) => node.type === 'slab');
+                if (sourceSlabs.length > 0) {
+                    const outsideFootprints = footprints.filter((footprint) => !sourceSlabs.some((slab) => polygonContainsPolygon(slab.polygon, footprint)));
+                    if (outsideFootprints.length > 0) {
+                        issues.push(`Stair ${stair.name ?? stair.id} footprint extends outside source floor slab on ${sourceLevel?.name ?? sourceLevelId}`);
+                    }
+                }
+                const obstructingWalls = nodesOnLevel(bridge, sourceLevelId)
+                    .filter((node) => node.type === 'wall')
+                    .filter((wall) => footprints.some((footprint) => wallSamplePoints(wall).some((point) => pointInPolygon(point, footprint, false))));
+                for (const wall of obstructingWalls) {
+                    issues.push(`Wall ${wall.name ?? wall.id} obstructs stair ${stair.name ?? stair.id} on ${sourceLevel?.name ?? sourceLevelId}`);
+                }
+            }
+            if ((stair.slabOpeningMode ?? 'none') === 'destination') {
+                const targetLevelIds = targetLevelIdsForStair(bridge, stair);
+                if (targetLevelIds.length === 0) {
+                    issues.push(`Stair ${stair.name ?? stair.id} requests a slab opening but has no target level`);
+                }
+                for (const targetLevelId of targetLevelIds) {
+                    const targetLevel = bridge.getNode(targetLevelId);
+                    const targetSlabs = nodesOnLevel(bridge, targetLevelId).filter((node) => node.type === 'slab');
+                    if (targetSlabs.length === 0) {
+                        issues.push(`Stair ${stair.name ?? stair.id} targets ${targetLevel?.name ?? targetLevelId} but it has no slab`);
+                        continue;
+                    }
+                    const matchingHoles = targetSlabs.flatMap((slab) => (slab.holes ?? [])
+                        .map((hole, index) => ({ slab, hole, index }))
+                        .filter((entry) => holeBelongsToStair(entry.slab, entry.index, stair.id)));
+                    if (matchingHoles.length === 0) {
+                        issues.push(`Stair ${stair.name ?? stair.id} has no destination slab opening on ${targetLevel?.name ?? targetLevelId}`);
+                        continue;
+                    }
+                    for (const { slab, hole } of matchingHoles) {
+                        if (!polygonContainsPolygon(slab.polygon, hole)) {
+                            issues.push(`Stair ${stair.name ?? stair.id} opening extends outside slab ${slab.name ?? slab.id}`);
+                        }
+                    }
+                }
+            }
+        }
+        if (!validation.valid) {
+            for (const error of validation.errors.slice(0, 5)) {
+                issues.push(`Schema: ${error.nodeId}.${error.path} ${error.message}`);
+            }
+            if (validation.errors.length > 5) {
+                issues.push(`Schema: ${validation.errors.length - 5} additional validation errors`);
+            }
+        }
+        const payload = {
+            ok: true,
+            valid: validation.valid,
+            levelCount: levels.length,
+            occupiedStoryCount,
+            supportLevelCount: levels.length - occupiedStoryCount,
+            roofLevelIds,
+            activeSceneId: bridge.getActiveScene()?.id ?? null,
+            levels,
+            emptyLevelIds,
+            issues,
+            hasIssues: issues.length > 0,
+        };
+        return textResult(payload);
+    });
+}
+export function registerSceneQueryTools(server, bridge) {
+    registerListLevels(server, bridge);
+    registerGetLevelSummary(server, bridge);
+    registerGetWalls(server, bridge);
+    registerGetZones(server, bridge);
+    registerVerifyScene(server, bridge);
+}

package/dist/tools/schemas.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+/**
+ * Shared Zod schemas used by multiple MCP tools. Keep DRY — if a shape is
+ * referenced by more than one tool, define it here.
+ */
+/** A node identifier — non-empty string. The core uses `${prefix}_${nanoid}`. */
+export declare const NodeIdSchema: z.ZodString;
+/**
+ * 2D point as [x, z] (floor plane). Use array length constraints instead of
+ * `z.tuple()` so MCP hosts that only accept JSON Schema's common `items` shape
+ * can register the tools.
+ */
+export declare const Vec2Schema: z.ZodArray<z.ZodNumber>;
+/** 3D point as [x, y, z]. */
+export declare const Vec3Schema: z.ZodArray<z.ZodNumber>;
+/**
+ * A single patch operation. Union of create / update / delete.
+ *
+ * For `create`, the node object must include `type` so Zod can discriminate at
+ * the bridge layer — we accept a plain object here and let the bridge's Zod
+ * re-parse catch structural issues. For `update`, `data` is a partial merge.
+ */
+export declare const CreatePatchSchema: z.ZodObject<{
+    op: z.ZodLiteral<"create">;
+    node: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    parentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const UpdatePatchSchema: z.ZodObject<{
+    op: z.ZodLiteral<"update">;
+    id: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const DeletePatchSchema: z.ZodObject<{
+    op: z.ZodLiteral<"delete">;
+    id: z.ZodString;
+    cascade: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const PatchSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"create">;
+    node: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    parentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"update">;
+    id: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"delete">;
+    id: z.ZodString;
+    cascade: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>], "op">;
+export type Patch = z.infer<typeof PatchSchema>;
+//# sourceMappingURL=schemas.d.ts.map