@pascal-app/mcp 0.2.0

package/dist/tools/check-collisions.d.ts

@@ -0,0 +1,15 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const checkCollisionsInput: {
+    levelId: z.ZodOptional<z.ZodString>;
+};
+export declare const checkCollisionsOutput: {
+    collisions: z.ZodArray<z.ZodObject<{
+        aId: z.ZodString;
+        bId: z.ZodString;
+        kind: z.ZodString;
+    }, z.core.$strip>>;
+};
+export declare function registerCheckCollisions(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=check-collisions.d.ts.map

package/dist/tools/check-collisions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-collisions.d.ts","sourceRoot":"","sources":["../../src/tools/check-collisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD,eAAO,MAAM,oBAAoB;;CAEhC,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;CAQjC,CAAA;AAqBD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsCxF"}

package/dist/tools/check-collisions.js

@@ -0,0 +1,61 @@
+import { getScaledDimensions } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { NodeIdSchema } from './schemas';
+export const checkCollisionsInput = {
+    levelId: NodeIdSchema.optional(),
+};
+export const checkCollisionsOutput = {
+    collisions: z.array(z.object({
+        aId: z.string(),
+        bId: z.string(),
+        kind: z.string(),
+    })),
+};
+function itemAabb(item) {
+    const [x, , z] = item.position;
+    const [w, , d] = getScaledDimensions(item);
+    const halfW = w / 2;
+    const halfD = d / 2;
+    return {
+        minX: x - halfW,
+        maxX: x + halfW,
+        minZ: z - halfD,
+        maxZ: z + halfD,
+    };
+}
+function aabbOverlap(a, b) {
+    return a.minX < b.maxX && a.maxX > b.minX && a.minZ < b.maxZ && a.maxZ > b.minZ;
+}
+export function registerCheckCollisions(server, bridge) {
+    server.registerTool('check_collisions', {
+        title: 'Check collisions',
+        description: 'Detect overlapping item footprints via an axis-aligned 2D bounding-box test. Optionally scoped to a single level.',
+        inputSchema: checkCollisionsInput,
+        outputSchema: checkCollisionsOutput,
+    }, async ({ levelId }) => {
+        const filter = { type: 'item' };
+        if (levelId)
+            filter.levelId = levelId;
+        const items = bridge.findNodes(filter);
+        const boxes = items.map((i) => ({ item: i, aabb: itemAabb(i) }));
+        const collisions = [];
+        for (let i = 0; i < boxes.length; i++) {
+            for (let j = i + 1; j < boxes.length; j++) {
+                const a = boxes[i];
+                const b = boxes[j];
+                if (aabbOverlap(a.aabb, b.aabb)) {
+                    collisions.push({
+                        aId: a.item.id,
+                        bId: b.item.id,
+                        kind: 'item-aabb',
+                    });
+                }
+            }
+        }
+        const payload = { collisions };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/construction-tools.d.ts

@@ -0,0 +1,93 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const createStoryShellInput: {
+    levelId: z.ZodString;
+    footprint: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+    wallHeight: z.ZodDefault<z.ZodNumber>;
+    wallThickness: z.ZodDefault<z.ZodNumber>;
+    createSlab: z.ZodDefault<z.ZodBoolean>;
+    createCeiling: z.ZodDefault<z.ZodBoolean>;
+    slabElevation: z.ZodDefault<z.ZodNumber>;
+    ceilingHeight: z.ZodOptional<z.ZodNumber>;
+    namePrefix: z.ZodOptional<z.ZodString>;
+    wallMaterialPreset: z.ZodOptional<z.ZodString>;
+    slabMaterialPreset: z.ZodOptional<z.ZodString>;
+    ceilingMaterialPreset: z.ZodOptional<z.ZodString>;
+};
+export declare const createStoryShellOutput: {
+    levelId: z.ZodString;
+    wallIds: z.ZodArray<z.ZodString>;
+    slabId: z.ZodNullable<z.ZodString>;
+    ceilingId: z.ZodNullable<z.ZodString>;
+    createdIds: z.ZodArray<z.ZodString>;
+};
+export declare const createRoofInput: {
+    levelId: z.ZodString;
+    roofLevelId: z.ZodOptional<z.ZodString>;
+    useDedicatedRoofLevel: z.ZodDefault<z.ZodBoolean>;
+    roofLevelLabel: z.ZodDefault<z.ZodString>;
+    roofLevelElevation: z.ZodOptional<z.ZodNumber>;
+    roofLevelHeight: z.ZodOptional<z.ZodNumber>;
+    center: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    width: z.ZodNumber;
+    depth: z.ZodNumber;
+    roofType: z.ZodDefault<z.ZodEnum<{
+        flat: "flat";
+        hip: "hip";
+        gable: "gable";
+        shed: "shed";
+        gambrel: "gambrel";
+        dutch: "dutch";
+        mansard: "mansard";
+    }>>;
+    roofHeight: z.ZodDefault<z.ZodNumber>;
+    wallHeight: z.ZodDefault<z.ZodNumber>;
+    wallThickness: z.ZodDefault<z.ZodNumber>;
+    overhang: z.ZodDefault<z.ZodNumber>;
+    materialPreset: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+};
+export declare const createRoofOutput: {
+    referenceLevelId: z.ZodString;
+    roofLevelId: z.ZodString;
+    createdRoofLevelId: z.ZodNullable<z.ZodString>;
+    roofId: z.ZodString;
+    roofSegmentId: z.ZodString;
+};
+export declare const createStairBetweenLevelsInput: {
+    fromLevelId: z.ZodString;
+    toLevelId: z.ZodString;
+    position: z.ZodArray<z.ZodNumber>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    width: z.ZodDefault<z.ZodNumber>;
+    runLength: z.ZodDefault<z.ZodNumber>;
+    totalRise: z.ZodDefault<z.ZodNumber>;
+    stepCount: z.ZodDefault<z.ZodNumber>;
+    railingMode: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        left: "left";
+        right: "right";
+        both: "both";
+    }>>;
+    destinationSlabId: z.ZodOptional<z.ZodString>;
+    sourceCeilingId: z.ZodOptional<z.ZodString>;
+    createDestinationSlabOpening: z.ZodDefault<z.ZodBoolean>;
+    createSourceCeilingOpening: z.ZodDefault<z.ZodBoolean>;
+    openingWidth: z.ZodOptional<z.ZodNumber>;
+    openingLength: z.ZodOptional<z.ZodNumber>;
+    openingOffset: z.ZodDefault<z.ZodNumber>;
+    openingCenter: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    openingRotation: z.ZodOptional<z.ZodNumber>;
+    materialPreset: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+};
+export declare const createStairBetweenLevelsOutput: {
+    stairId: z.ZodString;
+    stairSegmentId: z.ZodString;
+    destinationSlabId: z.ZodNullable<z.ZodString>;
+    sourceCeilingId: z.ZodNullable<z.ZodString>;
+    openingPolygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+};
+export declare function registerConstructionTools(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=construction-tools.d.ts.map

package/dist/tools/construction-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construction-tools.d.ts","sourceRoot":"","sources":["../../src/tools/construction-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAYxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;CAajC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;CAMlC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAiB3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;CAqBzC,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;;CAM1C,CAAA;AA4GD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA8S1F"}

package/dist/tools/construction-tools.js

@@ -0,0 +1,369 @@
+import { CeilingNode, LevelNode, RoofNode, RoofSegmentNode, SlabNode, StairNode, StairSegmentNode, WallNode, } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { publishLiveSceneSnapshot } from './live-sync';
+import { NodeIdSchema, Vec2Schema, Vec3Schema } from './schemas';
+const ROOF_TYPES = ['hip', 'gable', 'shed', 'gambrel', 'dutch', 'mansard', 'flat'];
+const RAILING_MODES = ['none', 'left', 'right', 'both'];
+export const createStoryShellInput = {
+    levelId: NodeIdSchema,
+    footprint: z.array(Vec2Schema).min(3),
+    wallHeight: z.number().positive().default(2.8),
+    wallThickness: z.number().positive().default(0.16),
+    createSlab: z.boolean().default(true),
+    createCeiling: z.boolean().default(true),
+    slabElevation: z.number().default(0.1),
+    ceilingHeight: z.number().positive().optional(),
+    namePrefix: z.string().optional(),
+    wallMaterialPreset: z.string().optional(),
+    slabMaterialPreset: z.string().optional(),
+    ceilingMaterialPreset: z.string().optional(),
+};
+export const createStoryShellOutput = {
+    levelId: z.string(),
+    wallIds: z.array(z.string()),
+    slabId: z.string().nullable(),
+    ceilingId: z.string().nullable(),
+    createdIds: z.array(z.string()),
+};
+export const createRoofInput = {
+    levelId: NodeIdSchema,
+    roofLevelId: NodeIdSchema.optional(),
+    useDedicatedRoofLevel: z.boolean().default(true),
+    roofLevelLabel: z.string().default('Roof'),
+    roofLevelElevation: z.number().optional(),
+    roofLevelHeight: z.number().positive().optional(),
+    center: Vec3Schema.optional(),
+    width: z.number().positive(),
+    depth: z.number().positive(),
+    roofType: z.enum(ROOF_TYPES).default('hip'),
+    roofHeight: z.number().positive().default(1.8),
+    wallHeight: z.number().min(0).default(0.35),
+    wallThickness: z.number().positive().default(0.16),
+    overhang: z.number().min(0).default(0.45),
+    materialPreset: z.string().optional(),
+    name: z.string().optional(),
+};
+export const createRoofOutput = {
+    referenceLevelId: z.string(),
+    roofLevelId: z.string(),
+    createdRoofLevelId: z.string().nullable(),
+    roofId: z.string(),
+    roofSegmentId: z.string(),
+};
+export const createStairBetweenLevelsInput = {
+    fromLevelId: NodeIdSchema,
+    toLevelId: NodeIdSchema,
+    position: Vec3Schema,
+    rotation: z.number().default(0),
+    width: z.number().positive().default(1),
+    runLength: z.number().positive().default(3),
+    totalRise: z.number().positive().default(2.8),
+    stepCount: z.number().int().positive().default(14),
+    railingMode: z.enum(RAILING_MODES).default('both'),
+    destinationSlabId: NodeIdSchema.optional(),
+    sourceCeilingId: NodeIdSchema.optional(),
+    createDestinationSlabOpening: z.boolean().default(true),
+    createSourceCeilingOpening: z.boolean().default(true),
+    openingWidth: z.number().positive().optional(),
+    openingLength: z.number().positive().optional(),
+    openingOffset: z.number().min(0).default(0.15),
+    openingCenter: Vec2Schema.optional(),
+    openingRotation: z.number().optional(),
+    materialPreset: z.string().optional(),
+    name: z.string().optional(),
+};
+export const createStairBetweenLevelsOutput = {
+    stairId: z.string(),
+    stairSegmentId: z.string(),
+    destinationSlabId: z.string().nullable(),
+    sourceCeilingId: z.string().nullable(),
+    openingPolygon: z.array(Vec2Schema),
+};
+function textResult(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload) }],
+        structuredContent: payload,
+    };
+}
+function assertNode(bridge, id, type) {
+    const node = bridge.getNode(id);
+    if (!node)
+        throw new Error(`${type} not found: ${id}`);
+    if (node.type !== type)
+        throw new Error(`Node ${id} is a ${node.type}, expected ${type}`);
+    return node;
+}
+function getBuildingIdForLevel(bridge, levelId) {
+    const building = bridge.getAncestry(levelId).find((node) => node.type === 'building');
+    if (!building) {
+        throw new Error(`Building ancestor not found for level: ${levelId}`);
+    }
+    return building.id;
+}
+function isRoofLevel(level) {
+    return (level.type === 'level' &&
+        typeof level.metadata === 'object' &&
+        level.metadata !== null &&
+        'role' in level.metadata &&
+        level.metadata.role === 'roof');
+}
+function nextLevelIndex(bridge, buildingId, referenceLevel) {
+    const existing = bridge
+        .getChildren(buildingId)
+        .filter((node) => node.type === 'level')
+        .map((level) => level.level);
+    const referenceIndex = referenceLevel.type === 'level' ? referenceLevel.level : 0;
+    const candidate = referenceIndex + 1;
+    return existing.includes(candidate) ? Math.max(candidate, ...existing) + 1 : candidate;
+}
+function nodesOnLevel(bridge, levelId) {
+    return Object.values(bridge.getNodes()).filter((node) => node.id !== levelId && bridge.resolveLevelId(node.id) === levelId);
+}
+function firstNodeOnLevel(bridge, levelId, type) {
+    return nodesOnLevel(bridge, levelId).find((node) => node.type === type) ?? null;
+}
+function rotatePoint(x, z, rotation) {
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    return [x * cos + z * sin, -x * sin + z * cos];
+}
+function rectangularOpening(args) {
+    const width = args.width + args.offset * 2;
+    const length = args.length + args.offset * 2;
+    const center = args.center ?? [
+        args.position[0],
+        args.position[2] + args.length / 2,
+    ];
+    const rotation = args.openingRotation ?? args.rotation;
+    const halfW = width / 2;
+    const halfL = length / 2;
+    const local = [
+        [-halfW, -halfL],
+        [halfW, -halfL],
+        [halfW, halfL],
+        [-halfW, halfL],
+    ];
+    return local.map(([x, z]) => {
+        const [rx, rz] = rotatePoint(x, z, rotation);
+        return [center[0] + rx, center[1] + rz];
+    });
+}
+function withHole(surface, hole) {
+    return {
+        holes: [...(surface.holes ?? []), hole],
+        holeMetadata: [...(surface.holeMetadata ?? []), { source: 'manual' }],
+    };
+}
+export function registerConstructionTools(server, bridge) {
+    server.registerTool('create_story_shell', {
+        title: 'Create story shell',
+        description: 'Create one level-owned building shell from a footprint: perimeter walls plus optional slab and ceiling. Use once per story; do not make first-floor walls span multiple stories.',
+        inputSchema: createStoryShellInput,
+        outputSchema: createStoryShellOutput,
+    }, async ({ levelId, footprint, wallHeight, wallThickness, createSlab, createCeiling, slabElevation, ceilingHeight, namePrefix, wallMaterialPreset, slabMaterialPreset, ceilingMaterialPreset, }) => {
+        const level = assertNode(bridge, levelId, 'level');
+        if (isRoofLevel(level)) {
+            throw new Error(`Cannot create a story shell on roof support level ${levelId}; create or choose an occupied story level instead`);
+        }
+        const points = footprint;
+        const wallIds = [];
+        const patches = [];
+        for (let i = 0; i < points.length; i++) {
+            const wall = WallNode.parse({
+                name: namePrefix ? `${namePrefix} Wall ${i + 1}` : undefined,
+                start: points[i],
+                end: points[(i + 1) % points.length],
+                thickness: wallThickness,
+                height: wallHeight,
+                frontSide: 'exterior',
+                backSide: 'interior',
+                ...(wallMaterialPreset ? { materialPreset: wallMaterialPreset } : {}),
+                metadata: { role: 'exterior', storyShell: true },
+            });
+            wallIds.push(wall.id);
+            patches.push({ op: 'create', node: wall, parentId: levelId });
+        }
+        let slabId = null;
+        if (createSlab) {
+            const slab = SlabNode.parse({
+                name: namePrefix ? `${namePrefix} Slab` : undefined,
+                polygon: points,
+                elevation: slabElevation,
+                ...(slabMaterialPreset ? { materialPreset: slabMaterialPreset } : {}),
+                metadata: { role: 'story-slab' },
+            });
+            slabId = slab.id;
+            patches.push({ op: 'create', node: slab, parentId: levelId });
+        }
+        let ceilingId = null;
+        if (createCeiling) {
+            const ceiling = CeilingNode.parse({
+                name: namePrefix ? `${namePrefix} Ceiling` : undefined,
+                polygon: points,
+                height: ceilingHeight ?? wallHeight,
+                ...(ceilingMaterialPreset ? { materialPreset: ceilingMaterialPreset } : {}),
+                metadata: { role: 'story-ceiling' },
+            });
+            ceilingId = ceiling.id;
+            patches.push({ op: 'create', node: ceiling, parentId: levelId });
+        }
+        const result = bridge.applyPatch(patches);
+        await publishLiveSceneSnapshot(bridge, 'create_story_shell');
+        return textResult({
+            levelId,
+            wallIds,
+            slabId,
+            ceilingId,
+            createdIds: result.createdIds,
+        });
+    });
+    server.registerTool('create_roof', {
+        title: 'Create roof',
+        description: 'Create a roof container with one roof segment. By default creates a dedicated roof level above the reference level so exploded/solo level views can isolate the roof.',
+        inputSchema: createRoofInput,
+        outputSchema: createRoofOutput,
+    }, async ({ levelId, roofLevelId, useDedicatedRoofLevel, roofLevelLabel, roofLevelElevation, roofLevelHeight, center, width, depth, roofType, roofHeight, wallHeight, wallThickness, overhang, materialPreset, name, }) => {
+        const referenceLevel = assertNode(bridge, levelId, 'level');
+        const patches = [];
+        let targetRoofLevelId = levelId;
+        let createdRoofLevelId = null;
+        if (roofLevelId !== undefined) {
+            const roofLevel = assertNode(bridge, roofLevelId, 'level');
+            if (!isRoofLevel(roofLevel)) {
+                throw new Error(`roofLevelId ${roofLevelId} must reference a dedicated roof level with metadata.role = "roof"; omit roofLevelId to create one automatically`);
+            }
+            targetRoofLevelId = roofLevelId;
+        }
+        else if (useDedicatedRoofLevel && !isRoofLevel(referenceLevel)) {
+            const buildingId = getBuildingIdForLevel(bridge, levelId);
+            const roofLevel = LevelNode.parse({
+                name: roofLevelLabel,
+                level: roofLevelElevation ?? nextLevelIndex(bridge, buildingId, referenceLevel),
+                children: [],
+                metadata: {
+                    role: 'roof',
+                    label: roofLevelLabel,
+                    referenceLevelId: levelId,
+                    height: roofLevelHeight ?? Math.max(wallHeight + roofHeight, 0.2),
+                },
+            });
+            targetRoofLevelId = roofLevel.id;
+            createdRoofLevelId = roofLevel.id;
+            patches.push({ op: 'create', node: roofLevel, parentId: buildingId });
+        }
+        const segment = RoofSegmentNode.parse({
+            roofType,
+            width,
+            depth,
+            wallHeight,
+            roofHeight,
+            wallThickness,
+            overhang,
+            ...(materialPreset ? { materialPreset } : {}),
+        });
+        const roof = RoofNode.parse({
+            name: name ?? 'Roof',
+            position: center ?? [0, 0, 0],
+            children: [segment.id],
+            ...(materialPreset ? { materialPreset } : {}),
+            metadata: {
+                referenceLevelId: levelId,
+                roofLevelId: targetRoofLevelId,
+            },
+        });
+        bridge.applyPatch([
+            ...patches,
+            { op: 'create', node: roof, parentId: targetRoofLevelId },
+            { op: 'create', node: segment, parentId: roof.id },
+        ]);
+        await publishLiveSceneSnapshot(bridge, 'create_roof');
+        return textResult({
+            referenceLevelId: levelId,
+            roofLevelId: targetRoofLevelId,
+            createdRoofLevelId,
+            roofId: roof.id,
+            roofSegmentId: segment.id,
+        });
+    });
+    server.registerTool('create_stair_between_levels', {
+        title: 'Create stair between levels',
+        description: 'Create a straight stair and a single rectangular manual opening in the destination slab/source ceiling. This disables stair auto-opening mode to avoid duplicate or irregular holes.',
+        inputSchema: createStairBetweenLevelsInput,
+        outputSchema: createStairBetweenLevelsOutput,
+    }, async ({ fromLevelId, toLevelId, position, rotation, width, runLength, totalRise, stepCount, railingMode, destinationSlabId, sourceCeilingId, createDestinationSlabOpening, createSourceCeilingOpening, openingWidth, openingLength, openingOffset, openingCenter, openingRotation, materialPreset, name, }) => {
+        const fromLevel = assertNode(bridge, fromLevelId, 'level');
+        const toLevel = assertNode(bridge, toLevelId, 'level');
+        if (isRoofLevel(fromLevel) || isRoofLevel(toLevel)) {
+            throw new Error('Roof support levels are not occupied stories; create a separate occupied attic/story level if a stair-accessible attic is required');
+        }
+        const segment = StairSegmentNode.parse({
+            segmentType: 'stair',
+            width,
+            length: runLength,
+            height: totalRise,
+            stepCount,
+            ...(materialPreset ? { materialPreset } : {}),
+        });
+        const stair = StairNode.parse({
+            name: name ?? 'Stair',
+            position: position,
+            rotation,
+            stairType: 'straight',
+            fromLevelId,
+            toLevelId,
+            slabOpeningMode: 'none',
+            openingOffset,
+            width,
+            totalRise,
+            stepCount,
+            railingMode,
+            children: [segment.id],
+            ...(materialPreset ? { materialPreset } : {}),
+            metadata: {
+                openingManaged: 'manual-rectangular',
+            },
+        });
+        const openingPolygon = rectangularOpening({
+            position: position,
+            rotation,
+            width: openingWidth ?? width,
+            length: openingLength ?? runLength,
+            offset: openingOffset,
+            center: openingCenter,
+            openingRotation,
+        });
+        const patches = [
+            { op: 'create', node: stair, parentId: fromLevelId },
+            { op: 'create', node: segment, parentId: stair.id },
+        ];
+        const destinationSlab = destinationSlabId !== undefined
+            ? assertNode(bridge, destinationSlabId, 'slab')
+            : firstNodeOnLevel(bridge, toLevelId, 'slab');
+        if (createDestinationSlabOpening && destinationSlab?.type === 'slab') {
+            patches.push({
+                op: 'update',
+                id: destinationSlab.id,
+                data: withHole(destinationSlab, openingPolygon),
+            });
+        }
+        const sourceCeiling = sourceCeilingId !== undefined
+            ? assertNode(bridge, sourceCeilingId, 'ceiling')
+            : firstNodeOnLevel(bridge, fromLevelId, 'ceiling');
+        if (createSourceCeilingOpening && sourceCeiling?.type === 'ceiling') {
+            patches.push({
+                op: 'update',
+                id: sourceCeiling.id,
+                data: withHole(sourceCeiling, openingPolygon),
+            });
+        }
+        bridge.applyPatch(patches);
+        await publishLiveSceneSnapshot(bridge, 'create_stair_between_levels');
+        return textResult({
+            stairId: stair.id,
+            stairSegmentId: segment.id,
+            destinationSlabId: destinationSlab?.id ?? null,
+            sourceCeilingId: sourceCeiling?.id ?? null,
+            openingPolygon,
+        });
+    });
+}

package/dist/tools/create-level.d.ts

@@ -0,0 +1,14 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const createLevelInput: {
+    buildingId: z.ZodString;
+    elevation: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodOptional<z.ZodString>;
+};
+export declare const createLevelOutput: {
+    levelId: z.ZodString;
+};
+export declare function registerCreateLevel(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=create-level.d.ts.map

package/dist/tools/create-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-level.d.ts","sourceRoot":"","sources":["../../src/tools/create-level.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,eAAO,MAAM,gBAAgB;;;;;CAK5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;CAE7B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA0CpF"}

package/dist/tools/create-level.js

@@ -0,0 +1,48 @@
+import { LevelNode } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from './errors';
+import { publishLiveSceneSnapshot } from './live-sync';
+import { NodeIdSchema } from './schemas';
+export const createLevelInput = {
+    buildingId: NodeIdSchema,
+    elevation: z.number().optional(),
+    height: z.number().optional(),
+    label: z.string().optional(),
+};
+export const createLevelOutput = {
+    levelId: z.string(),
+};
+export function registerCreateLevel(server, bridge) {
+    server.registerTool('create_level', {
+        title: 'Create level',
+        description: 'Create a new level node attached to the given building. height and label are stored in metadata.',
+        inputSchema: createLevelInput,
+        outputSchema: createLevelOutput,
+    }, async ({ buildingId, elevation, height, label }) => {
+        const parent = bridge.getNode(buildingId);
+        if (!parent) {
+            throwMcpError(ErrorCode.InvalidParams, `Building not found: ${buildingId}`);
+        }
+        if (parent.type !== 'building') {
+            throwMcpError(ErrorCode.InvalidParams, `Node ${buildingId} is a ${parent.type}, expected building`);
+        }
+        const metadata = {};
+        if (height !== undefined)
+            metadata.height = height;
+        if (label !== undefined)
+            metadata.label = label;
+        const levelNode = LevelNode.parse({
+            level: elevation ?? 0,
+            children: [],
+            ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+            ...(label !== undefined ? { name: label } : {}),
+        });
+        const id = bridge.createNode(levelNode, buildingId);
+        await publishLiveSceneSnapshot(bridge, 'create_level');
+        const payload = { levelId: id };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/create-wall.d.ts

@@ -0,0 +1,15 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const createWallInput: {
+    levelId: z.ZodString;
+    start: z.ZodArray<z.ZodNumber>;
+    end: z.ZodArray<z.ZodNumber>;
+    thickness: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+};
+export declare const createWallOutput: {
+    wallId: z.ZodString;
+};
+export declare function registerCreateWall(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=create-wall.d.ts.map

package/dist/tools/create-wall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-wall.d.ts","sourceRoot":"","sources":["../../src/tools/create-wall.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,eAAO,MAAM,eAAe;;;;;;CAM3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgDnF"}