@pascal-app/mcp 0.2.0

package/dist/tools/photo-to-scene/photo-to-scene.js

@@ -0,0 +1,323 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { AnyNode, BuildingNode, LevelNode, SiteNode, WallNode, ZoneNode, } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { appendLiveSceneEvent } from '../live-sync';
+/**
+ * Input shape for the `photo_to_scene` orchestrator. `image` matches the
+ * contract documented on `analyze_floorplan_image` — base64 or http(s) URL.
+ */
+export const photoToSceneInput = {
+    image: z.string().describe('Base64 or https URL of the floor-plan photo'),
+    scaleHint: z.string().optional().describe('e.g. "1 cm = 1 m" or "approx 80 m²"'),
+    name: z.string().default('Scene from photo'),
+    save: z.boolean().default(true),
+    defaultWallThickness: z.number().default(0.2),
+    defaultWallHeight: z.number().default(2.6),
+};
+export const photoToSceneOutput = {
+    sceneId: z.string().optional(),
+    url: z.string().optional(),
+    walls: z.number(),
+    rooms: z.number(),
+    confidence: z.number(),
+    notes: z.string().optional(),
+    graph: z.any().optional(),
+};
+/**
+ * Shape of the vision JSON we consume. Kept in-sync with
+ * `analyze_floorplan_image`'s output schema (walls / rooms /
+ * approximateDimensions / confidence).
+ */
+const VisionResponseSchema = z.object({
+    walls: z.array(z.object({
+        start: z.tuple([z.number(), z.number()]),
+        end: z.tuple([z.number(), z.number()]),
+        thickness: z.number().optional(),
+    })),
+    rooms: z.array(z.object({
+        name: z.string(),
+        polygon: z.array(z.tuple([z.number(), z.number()])),
+        approximateAreaSqM: z.number().optional(),
+    })),
+    approximateDimensions: z.object({
+        widthM: z.number(),
+        depthM: z.number(),
+    }),
+    confidence: z.number().min(0).max(1),
+});
+/**
+ * System prompt mirrors `analyze_floorplan_image` — the contract between
+ * orchestrator and host is identical, so we keep the prompt verbatim to
+ * guarantee wire-compatible responses.
+ */
+const SYSTEM_PROMPT = `You are a vision assistant that extracts structured floor-plan data from an image.
+Your ONLY job: return a JSON object that exactly matches this schema — no prose, no markdown fences.
+
+{
+  "walls": [{ "start": [x, z], "end": [x, z], "thickness": number? }, ...],
+  "rooms": [{ "name": string, "polygon": [[x,z], ...], "approximateAreaSqM": number? }, ...],
+  "approximateDimensions": { "widthM": number, "depthM": number },
+  "confidence": number 0..1
+}
+
+Coordinates are in metres. Origin can be the floor plan's centre or bottom-left — be consistent.
+If the image is unclear, lower the confidence score but still produce your best attempt.
+DO NOT wrap the JSON in markdown. DO NOT explain. Just output the raw JSON.`;
+const DATA_URI_RE = /^data:(image\/[a-z0-9.+-]+);base64,(.+)$/i;
+/**
+ * Resolve the `image` input into a sampling-ready image block. Follows the
+ * same fetch/data-uri/raw-base64 rules as the vision tool so the user gets
+ * consistent behaviour whether they call `photo_to_scene` or
+ * `analyze_floorplan_image` directly.
+ */
+async function resolveImageBlock(image) {
+    if (/^https?:\/\//i.test(image)) {
+        // SSRF-safe fetch (see packages/mcp/src/lib/safe-fetch.ts).
+        const { safeFetch } = await import('../../lib/safe-fetch');
+        const res = await safeFetch(image, { accept: 'image/*' });
+        const data = res.buffer.toString('base64');
+        const mimeType = res.contentType ?? 'image/jpeg';
+        return { type: 'image', data, mimeType };
+    }
+    const dataUriMatch = image.match(DATA_URI_RE);
+    if (dataUriMatch) {
+        return {
+            type: 'image',
+            mimeType: dataUriMatch[1],
+            data: dataUriMatch[2],
+        };
+    }
+    return { type: 'image', mimeType: 'image/jpeg', data: image };
+}
+/** Collect all text content blocks returned by the sampling host into one string. */
+function extractText(content) {
+    const blocks = Array.isArray(content) ? content : [content];
+    const texts = [];
+    for (const block of blocks) {
+        if (block && typeof block === 'object' && block.type === 'text') {
+            const t = block.text;
+            if (typeof t === 'string')
+                texts.push(t);
+        }
+    }
+    return texts.join('\n').trim();
+}
+/**
+ * Call the host's sampling capability to analyse a floor-plan photo. Throws
+ * `sampling_unavailable` when the host has not advertised the capability and
+ * `sampling_response_unparseable` / `sampling_response_invalid` when the
+ * reply cannot be mapped onto `VisionResponseSchema`.
+ */
+async function callVisionSampling(server, image, scaleHint) {
+    const caps = server.server.getClientCapabilities();
+    if (!caps?.sampling) {
+        throw new McpError(ErrorCode.InvalidRequest, 'sampling_unavailable');
+    }
+    const imageBlock = await resolveImageBlock(image);
+    const instruction = scaleHint
+        ? `Analyze this floor plan. Scale hint: ${scaleHint}. Return ONLY the JSON described by the system prompt.`
+        : 'Analyze this floor plan. Return ONLY the JSON described by the system prompt.';
+    const response = await server.server.createMessage({
+        systemPrompt: SYSTEM_PROMPT,
+        temperature: 0,
+        maxTokens: 2000,
+        messages: [
+            {
+                role: 'user',
+                content: [imageBlock, { type: 'text', text: instruction }],
+            },
+        ],
+    });
+    const text = extractText(response.content);
+    if (!text) {
+        throw new McpError(ErrorCode.InternalError, 'sampling_response_unparseable', {
+            reason: 'no text content returned by host',
+        });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        throw new McpError(ErrorCode.InternalError, 'sampling_response_unparseable', {
+            raw: text,
+            reason: err instanceof Error ? err.message : String(err),
+        });
+    }
+    const validation = VisionResponseSchema.safeParse(parsed);
+    if (!validation.success) {
+        throw new McpError(ErrorCode.InternalError, 'sampling_response_invalid', {
+            raw: text,
+            errors: validation.error.issues,
+        });
+    }
+    return validation.data;
+}
+/**
+ * Build a SceneGraph (flat `nodes` dict + `rootNodeIds`) from the vision
+ * response. Uses the schema factories for every node so IDs, defaults, and
+ * parent linkage match what the core store would produce. Each node is
+ * revalidated via `AnyNode.safeParse`; failures are dropped with a warning.
+ */
+function buildSceneGraphFromVision(vision, defaultWallThickness, defaultWallHeight) {
+    const warnings = [];
+    // Build the skeleton: site → building → level.
+    const building = BuildingNode.parse({});
+    const level = LevelNode.parse({ level: 0 });
+    const site = SiteNode.parse({ children: [building] });
+    // Link parent ids so downstream traversal works.
+    const siteId = site.id;
+    const buildingId = building.id;
+    const levelId = level.id;
+    const linkedBuilding = {
+        ...building,
+        parentId: siteId,
+    };
+    const linkedLevel = {
+        ...level,
+        parentId: buildingId,
+    };
+    linkedBuilding.children = [levelId];
+    // Collect level children (ids of walls/zones we create below).
+    const levelChildren = [];
+    const nodes = {};
+    // Validate + add site, building, level in that order.
+    const siteValidated = AnyNode.safeParse(site);
+    if (!siteValidated.success) {
+        warnings.push(`site node failed schema validation: ${siteValidated.error.message}`);
+    }
+    nodes[siteId] = (siteValidated.success ? siteValidated.data : site);
+    const buildingValidated = AnyNode.safeParse(linkedBuilding);
+    if (!buildingValidated.success) {
+        warnings.push(`building node failed schema validation: ${buildingValidated.error.message}`);
+    }
+    nodes[buildingId] = (buildingValidated.success ? buildingValidated.data : linkedBuilding);
+    // Walls.
+    let wallsAdded = 0;
+    for (let i = 0; i < vision.walls.length; i++) {
+        const w = vision.walls[i];
+        try {
+            const wall = WallNode.parse({
+                start: w.start,
+                end: w.end,
+                thickness: w.thickness ?? defaultWallThickness,
+                height: defaultWallHeight,
+            });
+            const linkedWall = {
+                ...wall,
+                parentId: levelId,
+            };
+            const validated = AnyNode.safeParse(linkedWall);
+            if (!validated.success) {
+                warnings.push(`wall[${i}] dropped: ${validated.error.message}`);
+                continue;
+            }
+            nodes[wall.id] = validated.data;
+            levelChildren.push(wall.id);
+            wallsAdded++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            warnings.push(`wall[${i}] dropped: ${msg}`);
+        }
+    }
+    // Rooms → zones.
+    let roomsAdded = 0;
+    for (let i = 0; i < vision.rooms.length; i++) {
+        const r = vision.rooms[i];
+        try {
+            const zone = ZoneNode.parse({
+                name: r.name,
+                polygon: r.polygon,
+            });
+            const linkedZone = {
+                ...zone,
+                parentId: levelId,
+            };
+            const validated = AnyNode.safeParse(linkedZone);
+            if (!validated.success) {
+                warnings.push(`room[${i}] dropped: ${validated.error.message}`);
+                continue;
+            }
+            nodes[zone.id] = validated.data;
+            levelChildren.push(zone.id);
+            roomsAdded++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            warnings.push(`room[${i}] dropped: ${msg}`);
+        }
+    }
+    // Finalise the level's children array now that walls/zones are in the dict.
+    ;
+    linkedLevel.children = levelChildren;
+    const levelValidated = AnyNode.safeParse(linkedLevel);
+    if (!levelValidated.success) {
+        warnings.push(`level node failed schema validation: ${levelValidated.error.message}`);
+    }
+    nodes[levelId] = (levelValidated.success ? levelValidated.data : linkedLevel);
+    return {
+        nodes,
+        rootNodeIds: [siteId],
+        walls: wallsAdded,
+        rooms: roomsAdded,
+        warnings,
+        levelId,
+    };
+}
+export function registerPhotoToScene(server, bridge) {
+    server.registerTool('photo_to_scene', {
+        title: 'Photo to Pascal scene',
+        description: 'Orchestrator: analyse a floor-plan photo via MCP sampling, translate the structured vision result into a Pascal SceneGraph (site → building → level with walls and zones), optionally save it, and swap the bridge to the new scene. Requires host support for sampling.',
+        inputSchema: photoToSceneInput,
+        outputSchema: photoToSceneOutput,
+    }, async ({ image, scaleHint, name, save, defaultWallThickness, defaultWallHeight }) => {
+        // 1. Vision.
+        const vision = await callVisionSampling(server, image, scaleHint);
+        // 2. Build scene graph.
+        const built = buildSceneGraphFromVision(vision, defaultWallThickness, defaultWallHeight);
+        const graph = {
+            nodes: built.nodes,
+            rootNodeIds: built.rootNodeIds,
+            collections: {},
+        };
+        // 5. Swap the bridge to the new scene so follow-up MCP calls operate on it.
+        bridge.setScene(graph.nodes, graph.rootNodeIds);
+        const notes = built.warnings.length > 0 ? built.warnings.join('; ') : undefined;
+        // 4. Save or return inline.
+        if (save) {
+            const meta = await bridge.saveScene({
+                name,
+                graph,
+            });
+            bridge.setActiveScene(meta);
+            await appendLiveSceneEvent(bridge, meta.id, meta.version, 'photo_to_scene', graph);
+            const payload = {
+                sceneId: meta.id,
+                url: `/scene/${meta.id}`,
+                walls: built.walls,
+                rooms: built.rooms,
+                confidence: vision.confidence,
+            };
+            if (notes)
+                payload.notes = notes;
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        const payload = {
+            walls: built.walls,
+            rooms: built.rooms,
+            confidence: vision.confidence,
+            graph,
+        };
+        bridge.clearActiveScene();
+        if (notes)
+            payload.notes = notes;
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/place-item.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 placeItemInput: {
+    catalogItemId: z.ZodString;
+    targetNodeId: z.ZodString;
+    position: z.ZodArray<z.ZodNumber>;
+    rotation: z.ZodOptional<z.ZodNumber>;
+};
+export declare const placeItemOutput: {
+    itemId: z.ZodString;
+    status: z.ZodOptional<z.ZodString>;
+};
+export declare function registerPlaceItem(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=place-item.d.ts.map

package/dist/tools/place-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-item.d.ts","sourceRoot":"","sources":["../../src/tools/place-item.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;AAOpD,eAAO,MAAM,cAAc;;;;;CAK1B,CAAA;AAED,eAAO,MAAM,eAAe;;;CAG3B,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsFlF"}

package/dist/tools/place-item.js

@@ -0,0 +1,84 @@
+import { ItemNode } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { findCatalogItem } from './asset-catalog';
+import { ErrorCode, throwMcpError } from './errors';
+import { projectWorldPointToWallLocalX, wallLength } from './geometry';
+import { publishLiveSceneSnapshot } from './live-sync';
+import { NodeIdSchema, Vec3Schema } from './schemas';
+export const placeItemInput = {
+    catalogItemId: z.string().min(1),
+    targetNodeId: NodeIdSchema,
+    position: Vec3Schema,
+    rotation: z.number().optional(),
+};
+export const placeItemOutput = {
+    itemId: z.string(),
+    status: z.string().optional(),
+};
+export function registerPlaceItem(server, bridge) {
+    server.registerTool('place_item', {
+        title: 'Place item',
+        description: 'Place a catalog item into the scene. Target a level/slab/zone for floor items, a wall for wall-attached items, or a ceiling for ceiling-attached items. Do not target the site node directly.',
+        inputSchema: placeItemInput,
+        outputSchema: placeItemOutput,
+    }, async ({ catalogItemId, targetNodeId, position, rotation }) => {
+        const target = bridge.getNode(targetNodeId);
+        if (!target) {
+            throwMcpError(ErrorCode.InvalidParams, `Target node not found: ${targetNodeId}`);
+        }
+        const targetType = target.type;
+        if (targetType !== 'level' &&
+            targetType !== 'slab' &&
+            targetType !== 'zone' &&
+            targetType !== 'wall' &&
+            targetType !== 'ceiling') {
+            throwMcpError(ErrorCode.InvalidRequest, `Cannot place item on ${targetType}; target must be a level, slab, zone, wall, or ceiling. Site-level placement is not supported yet because site.children is reserved for buildings.`);
+        }
+        const catalogAsset = findCatalogItem(catalogItemId);
+        const baseAsset = catalogAsset ?? {
+            id: catalogItemId,
+            name: catalogItemId,
+            category: 'unknown',
+            thumbnail: '',
+            src: 'asset://placeholder',
+            dimensions: [0.5, 0.5, 0.5],
+            offset: [0, 0, 0],
+            rotation: [0, 0, 0],
+            scale: [1, 1, 1],
+        };
+        const requestedPosition = position;
+        const parentId = targetType === 'slab' || targetType === 'zone'
+            ? bridge.resolveLevelId(targetNodeId)
+            : targetNodeId;
+        if (!parentId) {
+            throwMcpError(ErrorCode.InvalidParams, `Could not resolve a level parent for target ${targetNodeId}`);
+        }
+        const wallExtras = {};
+        let itemPosition = requestedPosition;
+        if (targetType === 'wall') {
+            const localX = projectWorldPointToWallLocalX(target, requestedPosition);
+            const length = wallLength(target);
+            itemPosition = [localX, requestedPosition[1], 0];
+            Object.assign(wallExtras, {
+                wallId: targetNodeId,
+                wallT: length === 0 ? 0 : localX / length,
+            });
+        }
+        const item = ItemNode.parse({
+            position: itemPosition,
+            rotation: [0, rotation ?? 0, 0],
+            asset: baseAsset,
+            ...wallExtras,
+        });
+        const id = bridge.createNode(item, parentId);
+        await publishLiveSceneSnapshot(bridge, 'place_item');
+        const payload = {
+            itemId: id,
+            status: catalogAsset ? 'ok' : 'catalog_unavailable',
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/redo.d.ts

@@ -0,0 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const redoInput: {
+    steps: z.ZodOptional<z.ZodNumber>;
+};
+export declare const redoOutput: {
+    redone: z.ZodNumber;
+};
+export declare function registerRedo(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=redo.d.ts.map

package/dist/tools/redo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redo.d.ts","sourceRoot":"","sources":["../../src/tools/redo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAGpD,eAAO,MAAM,SAAS;;CAErB,CAAA;AAED,eAAO,MAAM,UAAU;;CAEtB,CAAA;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAoB7E"}

package/dist/tools/redo.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { publishLiveSceneSnapshot } from './live-sync';
+export const redoInput = {
+    steps: z.number().int().positive().optional(),
+};
+export const redoOutput = {
+    redone: z.number(),
+};
+export function registerRedo(server, bridge) {
+    server.registerTool('redo', {
+        title: 'Redo',
+        description: 'Redo the next N previously-undone steps (default 1). Returns the number of steps actually redone.',
+        inputSchema: redoInput,
+        outputSchema: redoOutput,
+    }, async ({ steps }) => {
+        const redone = bridge.redo(steps ?? 1);
+        if (redone > 0)
+            await publishLiveSceneSnapshot(bridge, 'redo');
+        const payload = { redone };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

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

@@ -0,0 +1,97 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const searchAssetsInput: {
+    query: z.ZodString;
+    category: z.ZodOptional<z.ZodString>;
+};
+export declare const searchAssetsOutput: {
+    results: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    total: z.ZodNumber;
+};
+export declare const createRoomInput: {
+    levelId: z.ZodString;
+    name: z.ZodString;
+    polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+    color: z.ZodOptional<z.ZodString>;
+    wallHeight: z.ZodOptional<z.ZodNumber>;
+    wallThickness: z.ZodOptional<z.ZodNumber>;
+};
+export declare const createRoomOutput: {
+    zoneId: z.ZodString;
+    slabId: z.ZodString;
+    ceilingId: z.ZodString;
+    wallIds: z.ZodArray<z.ZodString>;
+    areaSqMeters: z.ZodNumber;
+};
+export declare const addDoorInput: {
+    wallId: z.ZodString;
+    t: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    hingesSide: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    swingDirection: z.ZodOptional<z.ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+};
+export declare const addDoorOutput: {
+    doorId: z.ZodString;
+    localX: z.ZodNumber;
+    t: z.ZodNumber;
+    position: z.ZodNumber;
+    wallLength: z.ZodNumber;
+    clamped: z.ZodBoolean;
+    coordinateSystem: z.ZodLiteral<"wall-local-meters">;
+};
+export declare const addWindowInput: {
+    wallId: z.ZodString;
+    t: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    sillHeight: z.ZodOptional<z.ZodNumber>;
+};
+export declare const addWindowOutput: {
+    windowId: z.ZodString;
+    localX: z.ZodNumber;
+    t: z.ZodNumber;
+    position: z.ZodNumber;
+    wallLength: z.ZodNumber;
+    clamped: z.ZodBoolean;
+    coordinateSystem: z.ZodLiteral<"wall-local-meters">;
+    sillHeight: z.ZodNumber;
+};
+export declare const furnishRoomInput: {
+    levelId: z.ZodOptional<z.ZodString>;
+    zoneId: z.ZodOptional<z.ZodString>;
+    roomType: z.ZodEnum<{
+        bedroom: "bedroom";
+        storage: "storage";
+        living: "living";
+        dining: "dining";
+        kitchen: "kitchen";
+        bathroom: "bathroom";
+        laundry: "laundry";
+        entry: "entry";
+        hallway: "hallway";
+    }>;
+    polygon: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+    doorWallIndex: z.ZodOptional<z.ZodNumber>;
+};
+export declare const furnishRoomOutput: {
+    placed: z.ZodNumber;
+    itemIds: z.ZodArray<z.ZodString>;
+    skipped: z.ZodArray<z.ZodString>;
+};
+export declare function registerSearchAssets(server: McpServer): void;
+export declare function registerCreateRoom(server: McpServer, bridge: SceneOperations): void;
+export declare function registerAddDoor(server: McpServer, bridge: SceneOperations): void;
+export declare function registerAddWindow(server: McpServer, bridge: SceneOperations): void;
+export declare function registerFurnishRoom(server: McpServer, bridge: SceneOperations): void;
+export declare function registerRoomTools(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=room-tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"room-tools.d.ts","sourceRoot":"","sources":["../../src/tools/room-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAWxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AA0BpD,eAAO,MAAM,iBAAiB;;;CAG7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;CAG9B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;CAO3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;CAQxB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;CAQzB,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;CAO1B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;CAS3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAM5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;CAI7B,CAAA;AA+PD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAsB5D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAqDnF;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA2ChF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA0ClF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsEpF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAMlF"}