@wonderlandengine/mcp-plugin 1.0.3

package/README.md

@@ -0,0 +1,55 @@
+# Wonderland Editor MCP Plugin
+
+## Overview
+
+The Wonderland Editor MCP Plugin facilitates interaction with the Model Context Protocol (MCP) within the Wonderland Engine, enhancing your development workflows with AI assistants.
+
+## Requirements
+
+To use this plugin, you need a nightly version or version 1.4.0+ of Wonderland Engine.
+
+## Configuration
+
+### Project
+
+First, install the plugin into your project via the "Views > Plugins > Project" view.
+
+### AI Agent Client
+
+Once the project is loaded and plugin execution is enabled, the MCP server runs via SSE transport on
+`http://localhost:3020/mcp`.
+
+If you can't use SSE, because your client doesn't support it, you can wrap it like this:
+
+```sh
+# Wrap the mcp server via STDIO
+npx -y supergateway --sse "http://localhost:3020/mcp"
+```
+
+#### Continue
+
+On **Windows**:
+
+```yml
+- name: Wonderland Editor
+  command: cmd
+  args:
+    - /c
+    - npx
+    - -y
+    - supergateway
+    - --streamableHttp
+    - http://localhost:3020/sse
+```
+
+Other systems:
+
+```yml
+- name: Wonderland Editor
+  command: npx
+  args:
+    - -y
+    - supergateway
+    - --streamableHttp
+    - http://localhost:3020/mcp
+```

package/build/index.d.mts

@@ -0,0 +1,11 @@
+import { EditorPlugin } from "@wonderlandengine/editor-api";
+import { WorkQueue } from "./utils/work-queue.js";
+export default class Index extends EditorPlugin {
+    queue: WorkQueue;
+    commandsCount: number;
+    status: string;
+    constructor();
+    unload(): void;
+    draw(): void;
+    update(): void;
+}

package/build/index.mjs

@@ -0,0 +1,47 @@
+import { EditorPlugin, ui, tools } from "@wonderlandengine/editor-api";
+import { main, shutdown } from "./server.js";
+import { WorkQueue } from "./utils/work-queue.js";
+const PORT = 3020;
+const CONFIG_EXAMPLE = `    "wonderland-editor-mcp": {
+      "url": "http://localhost:${PORT}/mcp"
+    }
+`;
+/* This is an example of a Wonderland Editor plugin */
+export default class Index extends EditorPlugin {
+    queue;
+    commandsCount = 0;
+    status = "running on port " + PORT;
+    constructor() {
+        super();
+        this.name = "MCP Server";
+        this.queue = new WorkQueue();
+        main({ port: PORT, queue: this.queue }).catch((error) => {
+            this.status = "[error]" + error.toString();
+        });
+    }
+    unload() {
+        /* Shutdown server and allow rebinding the port when reloading */
+        shutdown();
+    }
+    draw() {
+        ui.text(`Status: ${this.status}`);
+        ui.text(`Commands run: ${this.commandsCount}.`);
+        ui.separator();
+        ui.text("Copy the following config into your config file\n" +
+            "(any client that supports MCP via Streamable HTTP transport):");
+        ui.text('{\n  "mcpServers": {');
+        ui.inputTextMultiline("instruction", CONFIG_EXAMPLE);
+        ui.text("  }\n}\n");
+        /* Backwards compatibility for Wonderland Editor < 1.4.6 */
+        this.update();
+    }
+    update() {
+        /* Consume all functions in the queue */
+        if (!this.queue.empty) {
+            while (this.queue.pop())
+                ++this.commandsCount;
+            /* Defer packaging to after the change handlers consumed the changes */
+            setTimeout(() => tools.packageProject(), 0);
+        }
+    }
+}

package/build/mcp-server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WorkQueue } from "./utils/work-queue.js";
+export declare const server: McpServer;
+export declare function setQueue(q: WorkQueue): void;

package/build/mcp-server.js

@@ -0,0 +1,440 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { data, tools } from "@wonderlandengine/editor-api";
+import { computeMeshBoundsSchema, computeObjectBoundsSchema, deleteObjectsSchema, importFilesSchema, importSceneFilesSchema, modifyObjectsSchema, modifyResourcesSchema, modifySettingsSchema, queryComponentTypesSchema, queryResourcesSchema, querySettingsSchema, } from "./schemas.js";
+import { assignComponentProperties, assignNested, filterObjectProperties, } from "./utils/pojo.js";
+import { computeTreeBounds, stringifyWithDefaults, } from "./utils/editor-api.js";
+import path from "node:path";
+// JS component property caches (per object-component index and per object+type fallback)
+const jsComponentProps = new Map();
+const jsComponentPropsByObjectType = new Map();
+export const server = new McpServer({
+    name: "Wonderland Editor",
+    version: "0.3.0",
+});
+let queue = null;
+export function setQueue(q) {
+    queue = q;
+}
+server.registerTool("query_resources", {
+    title: "Query Resources",
+    description: "List resources of a certain type, filtering by property, if needed.",
+    inputSchema: queryResourcesSchema,
+}, async ({ resourceType, ids, includeFilter, excludeFilter, paths }) => {
+    try {
+        // @ts-ignore
+        const allResources = data[resourceType];
+        let resources = ids && ids.length > 0
+            ? ids
+                .filter((id) => allResources.exists(id))
+                .map((id) => ({
+                id,
+                ...allResources[id],
+            }))
+            : Object.entries(allResources).map(([id, res]) => ({
+                id,
+                ...res,
+            }));
+        if (includeFilter && "name" in includeFilter) {
+            resources = resources.filter((res) => {
+                return res.name.indexOf(includeFilter.name) >= 0;
+            });
+            delete includeFilter.name;
+        }
+        if (includeFilter) {
+            const keys = Object.keys(includeFilter);
+            resources = resources.filter((res) => {
+                for (const key of keys) {
+                    if (res[key] != includeFilter[key])
+                        return false;
+                }
+                return true;
+            });
+        }
+        if (excludeFilter && "name" in excludeFilter) {
+            resources = resources.filter((res) => {
+                return res.name.indexOf(excludeFilter.name) >= 0;
+            });
+            delete excludeFilter.name;
+        }
+        if (excludeFilter) {
+            const keys = Object.keys(excludeFilter);
+            resources = resources.filter((res) => {
+                for (const key of keys) {
+                    if (res[key] == excludeFilter[key])
+                        return false;
+                }
+                return true;
+            });
+        }
+        if (paths && paths.length > 0) {
+            resources = resources.map(filterObjectProperties.bind(null, paths));
+        }
+        const content = resources.map((res) => ({
+            type: "text",
+            text: JSON.stringify(res),
+        }));
+        return { content };
+    }
+    catch (error) {
+        const msg = (error && (error.errors || error.message)) ?? "Unknown error";
+        console.error("query_resources error:", error);
+        throw new Error("Invalid arguments: " +
+            (typeof msg === "string" ? msg : JSON.stringify(msg)));
+    }
+});
+server.registerTool("query_settings", {
+    title: "Query Settings",
+    description: "Retrieve the current project settings. Specify paths like 'rendering', 'physx', 'editor', 'runtime' to retrieve only specific settings.",
+    inputSchema: querySettingsSchema,
+}, async ({ paths }) => {
+    try {
+        const settings = JSON.parse(stringifyWithDefaults(data.settings));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(filterObjectProperties(paths, settings)),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Validation errors:", error, error?.errors ?? "");
+        throw new Error("Invalid arguments: " + JSON.stringify(error.errors));
+    }
+});
+server.registerTool("modify_settings", {
+    title: "Modify Settings",
+    description: "Modify the project settings.",
+    inputSchema: modifySettingsSchema,
+}, async ({ changeSettings, resetPaths }) => {
+    try {
+        let errors = [];
+        await queue.push(async () => {
+            resetPaths?.forEach((key) => {
+                const split = key.split(".");
+                try {
+                    let setting = data.settings;
+                    for (const k of split.slice(0, -1)) {
+                        setting = setting[k];
+                        if (setting === undefined || setting === null)
+                            return; // nothing to delete
+                    }
+                    delete setting[split[split.length - 1]];
+                }
+                catch {
+                    errors.push(`Could not reset setting at path ${key} - not found.`);
+                }
+            });
+            if (changeSettings) {
+                assignNested(data.settings, changeSettings);
+            }
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Done.",
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const msg = (error && (error.errors || error.message)) ?? "Unknown error";
+        console.error("Validation errors:", error, error?.errors ?? "");
+        throw new Error("Invalid arguments: " +
+            (typeof msg === "string" ? msg : JSON.stringify(msg)));
+    }
+});
+if ('getComponentTypes' in tools)
+    server.registerTool("query_component_types", {
+        title: "Query Component Types",
+        description: "Retrieve the current registered component types and their property definitions.",
+        inputSchema: queryComponentTypesSchema,
+    }, async ({ names }) => {
+        try {
+            const settings = JSON.parse(stringifyWithDefaults(data.settings));
+            const componentTypes = tools.getComponentTypes();
+            let filteredComponentTypes = componentTypes;
+            if (names && names.length > 0) {
+                filteredComponentTypes = componentTypes.filter(ct => names.includes(ct.name));
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(filteredComponentTypes),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            console.error("Validation errors:", error, error?.errors ?? "");
+            throw new Error("Invalid arguments: " + JSON.stringify(error.errors));
+        }
+    });
+server.registerTool("delete_objects", {
+    title: "Delete Objects",
+    description: "Delete objects.",
+    inputSchema: deleteObjectsSchema,
+}, async ({ objectIds }) => {
+    try {
+        await queue.push(async () => {
+            objectIds.map((objectId) => {
+                delete data.objects[objectId];
+            });
+        });
+        return {
+            content: [{ type: "text", text: "Done." }],
+        };
+    }
+    catch (error) {
+        const msg = (error && (error.errors || error.message)) ?? "Unknown error";
+        console.error("Validation errors:", error, error?.errors ?? "");
+        throw new Error("Invalid arguments: " +
+            (typeof msg === "string" ? msg : JSON.stringify(msg)));
+    }
+});
+server.registerTool("modify_objects", {
+    title: "Modify Objects",
+    description: "Create or modify objects in the Wonderland Engine project. " +
+        "Properties not specified in modifications are kept as-is. " +
+        "If an id is not used, the object will be created.",
+    inputSchema: modifyObjectsSchema,
+}, async ({ modifications }) => {
+    try {
+        await queue.push(async () => {
+            modifications.map(({ parentId, position, rotation, scaling, id, name, addComponents, modifyComponents, removeComponents, }) => {
+                const o = id
+                    ? data.objects[id]
+                    : data.objects.add();
+                if (!o)
+                    throw new Error(`Object with id ${id} not found.`);
+                if (name)
+                    o.name = name;
+                if (parentId)
+                    o.parent = parentId;
+                if (position)
+                    o.translation = position;
+                if (rotation)
+                    o.rotation = rotation;
+                if (scaling)
+                    o.scaling = scaling;
+                if (modifyComponents) {
+                    modifyComponents.forEach(({ index, properties }) => {
+                        const comp = o.components[index];
+                        if (comp.type == null)
+                            return;
+                        if (!properties)
+                            return;
+                        // @ts-ignore
+                        const props = comp[comp.type];
+                        assignComponentProperties(comp.type, props, properties, o, index);
+                        for (const key of Object.keys(properties)) {
+                            try {
+                                // @ts-ignore
+                                comp[o.components[index].type][key] = properties[key];
+                            }
+                            catch (e) {
+                                console.error("Could not assign property", key, "to", comp.type, "component at index", index, "of object", o.name, "\n", e);
+                            }
+                        }
+                    });
+                }
+                if (removeComponents) {
+                    removeComponents
+                        .sort()
+                        .reverse()
+                        .forEach((i) => delete o.components[i]);
+                }
+                if (addComponents) {
+                    addComponents.forEach((c) => {
+                        const index = o.components?.length ?? 0;
+                        o.components[index].type = c.type;
+                        // @ts-ignore
+                        const comp = o.components[index][c.type];
+                        if (c.properties)
+                            assignComponentProperties(c.type, comp, c.properties, o, index);
+                    });
+                }
+            });
+        });
+        return { content: [{ type: "text", text: "Done." }] };
+    }
+    catch (error) {
+        const msg = (error && (error.errors || error.message)) ?? "Unknown error";
+        console.error("modify_objects error:", error);
+        throw new Error("Invalid arguments: " +
+            (typeof msg === "string" ? msg : JSON.stringify(msg)));
+    }
+});
+server.registerTool("modify_resources", {
+    title: "Modify Resources",
+    description: "Create or modify resources in the Wonderland Engine project. " +
+        "Cannot be used to modify objects. Use modify_objects to modify " +
+        "objects. Properties not specified in changeProperties or resetProperties are kept as-is.",
+    inputSchema: modifyResourcesSchema,
+}, async ({ modifications }) => {
+    try {
+        await queue.push(async () => {
+            modifications.map(({ id, resourceType, changeProperties, resetProperties }) => {
+                // @ts-ignore
+                const res = id ? data[resourceType][id] : data[resourceType].add();
+                if (resetProperties) {
+                    resetProperties.forEach((key) => {
+                        delete res[key];
+                    });
+                }
+                if (changeProperties) {
+                    assignNested(res, changeProperties);
+                }
+            });
+        });
+        return { content: [{ type: "text", text: "Done." }] };
+    }
+    catch (error) {
+        const msg = (error && (error.errors || error.message)) ?? "Unknown error";
+        console.error("Validation errors:", error, error?.errors ?? "");
+        throw new Error("Invalid arguments: " +
+            (typeof msg === "string" ? msg : JSON.stringify(msg)));
+    }
+});
+server.registerTool("import_scenes", {
+    title: "Import Scenes",
+    description: "Import scene files (e.g. GLB, FBX, OBJ) by path. Try to batch calls to this function.",
+    inputSchema: importSceneFilesSchema,
+}, async ({ imports }) => {
+    try {
+        const results = [];
+        await queue.push(async () => {
+            // For each import, create a new container object (named after the file basename),
+            // import the scene under it, then report the immediate children with their tree bounds.
+            for (const entry of imports) {
+                const scenePath = entry?.path;
+                const allObjects = data.objects;
+                const baseName = path.basename(scenePath);
+                // @ts-ignore
+                const containerObject = data.objects.add();
+                containerObject.name = baseName;
+                // Snapshot existing object IDs to detect new ones created by this import
+                const beforeIds = new Set(Object.keys(allObjects));
+                // Import under the created container
+                await tools.loadScene(scenePath, {
+                    parent: containerObject.resourceKey,
+                });
+                // Compute set of new object IDs
+                const newIds = new Set();
+                for (const id of Object.keys(allObjects))
+                    if (!beforeIds.has(id))
+                        newIds.add(id);
+                // Ensure all newly created root objects are parented to the container
+                // Some importers may ignore the parent option. If a new object has no parent
+                // or its parent is not another new object, treat it as a root and reparent it.
+                for (const id of newIds) {
+                    const p = allObjects[id]?.parent;
+                    const parentInNewSet = p != null && newIds.has(String(p));
+                    if (p == null || !parentInNewSet) {
+                        allObjects[id].parent = containerObject.resourceKey;
+                    }
+                }
+                // Imported roots are the newly created objects that are direct children of the container
+                const importedRootIds = [];
+                for (const id of newIds) {
+                    const p = allObjects[id]?.parent;
+                    if (p != null &&
+                        String(p) === String(containerObject.resourceKey)) {
+                        importedRootIds.push(id);
+                    }
+                }
+                for (const oid of importedRootIds) {
+                    const { bounds: b, count } = computeTreeBounds(oid, data.objects);
+                    results.push({
+                        id: oid,
+                        rootId: oid,
+                        containerId: containerObject.resourceKey,
+                        bounds: b && { min: [b[0], b[1], b[2]], max: [b[3], b[4], b[5]] },
+                        count,
+                    });
+                }
+            }
+        });
+        return {
+            content: results.map((r) => ({
+                type: "text",
+                text: JSON.stringify(r),
+            })),
+        };
+    }
+    catch (error) {
+        const msg = (error && (error.errors || error.message)) ?? "Unknown error";
+        console.error("[import_scenes] Error:", error);
+        throw new Error("Invalid arguments: " +
+            (typeof msg === "string" ? msg : JSON.stringify(msg)));
+    }
+});
+server.registerTool("import_files", {
+    title: "Import Files",
+    description: "Import files (e.g. images) by path.",
+    inputSchema: importFilesSchema,
+}, async ({ imports }) => {
+    try {
+        await queue.push(async () => {
+            imports.map((path) => tools.loadFile(path));
+        });
+        return { content: [{ type: "text", text: "Done." }] };
+    }
+    catch (error) {
+        const msg = (error && (error.errors || error.message)) ?? "Unknown error";
+        console.error("Validation errors:", error, error?.errors ?? "");
+        throw new Error("Invalid arguments: " +
+            (typeof msg === "string" ? msg : JSON.stringify(msg)));
+    }
+});
+server.registerTool("compute_mesh_bounds", {
+    title: "Compute Mesh Bounds",
+    description: "Compute the bounds of the given mesh resources.",
+    inputSchema: computeMeshBoundsSchema,
+}, async ({ meshIds }) => {
+    try {
+        const bounds = meshIds.map((meshId) => {
+            const out = new Float32Array(6);
+            tools.computeMeshBounds(meshId, out);
+            return { min: out.subarray(0, 3), max: out.subarray(3, 6) };
+        });
+        return {
+            content: bounds.map((b) => ({ type: "text", text: JSON.stringify(b) })),
+        };
+    }
+    catch (error) {
+        const msg = (error && (error.errors || error.message)) ?? "Unknown error";
+        console.error("Validation errors:", error, error?.errors ?? "");
+        throw new Error("Invalid arguments: " +
+            (typeof msg === "string" ? msg : JSON.stringify(msg)));
+    }
+});
+server.registerTool("compute_object_bounds", {
+    title: "Compute Object Bounds",
+    description: "Compute aggregated subtree bounds for the given object IDs (including children).",
+    inputSchema: computeObjectBoundsSchema,
+}, async ({ objectIds }) => {
+    try {
+        const out = objectIds.map((oid) => {
+            const { bounds: b, count } = computeTreeBounds(oid, data.objects);
+            if (b) {
+                const minOut = [b[0], b[1], b[2]];
+                const maxOut = [b[3], b[4], b[5]];
+                return { id: oid, count, bounds: { min: minOut, max: maxOut } };
+            }
+            return { id: oid, count, bounds: null };
+        });
+        return {
+            content: out.map((e) => ({ type: "text", text: JSON.stringify(e) })),
+        };
+    }
+    catch (error) {
+        const msg = (error && (error.errors || error.message)) ?? "Unknown error";
+        console.error("Validation errors:", error, error?.errors ?? "");
+        throw new Error("Invalid arguments: " +
+            (typeof msg === "string" ? msg : JSON.stringify(msg)));
+    }
+});

package/build/schemas.d.ts

@@ -0,0 +1,121 @@
+import { z } from "zod";
+export declare const ResourceTypes: readonly ["objects", "textures", "meshes", "materials", "animations", "skins", "images", "shaders", "pipelines", "fonts", "morphTargets", "particleEffects"];
+export declare const queryResourcesSchema: {
+    resourceType: z.ZodEnum<["objects", "textures", "meshes", "materials", "animations", "skins", "images", "shaders", "pipelines", "fonts", "morphTargets", "particleEffects"]>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    includeFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    excludeFilter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+};
+export declare const querySettingsSchema: {
+    paths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+};
+export declare const modifySettingsSchema: {
+    changeSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    resetPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+};
+export declare const queryComponentTypesSchema: {
+    names: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+};
+export declare const deleteObjectsSchema: {
+    objectIds: z.ZodArray<z.ZodString, "many">;
+};
+export declare const modifyObjectsSchema: {
+    modifications: z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        position: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        rotation: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        scaling: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        addComponents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            properties?: Record<string, any> | undefined;
+        }, {
+            type: string;
+            properties?: Record<string, any> | undefined;
+        }>, "many">>;
+        modifyComponents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            index: z.ZodNumber;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            index: number;
+            properties?: Record<string, any> | undefined;
+        }, {
+            index: number;
+            properties?: Record<string, any> | undefined;
+        }>, "many">>;
+        removeComponents: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | undefined;
+        id?: string | undefined;
+        parentId?: string | null | undefined;
+        position?: number[] | undefined;
+        rotation?: number[] | undefined;
+        scaling?: number[] | undefined;
+        addComponents?: {
+            type: string;
+            properties?: Record<string, any> | undefined;
+        }[] | undefined;
+        modifyComponents?: {
+            index: number;
+            properties?: Record<string, any> | undefined;
+        }[] | undefined;
+        removeComponents?: number[] | undefined;
+    }, {
+        name?: string | undefined;
+        id?: string | undefined;
+        parentId?: string | null | undefined;
+        position?: number[] | undefined;
+        rotation?: number[] | undefined;
+        scaling?: number[] | undefined;
+        addComponents?: {
+            type: string;
+            properties?: Record<string, any> | undefined;
+        }[] | undefined;
+        modifyComponents?: {
+            index: number;
+            properties?: Record<string, any> | undefined;
+        }[] | undefined;
+        removeComponents?: number[] | undefined;
+    }>, "many">;
+};
+export declare const modifyResourcesSchema: {
+    modifications: z.ZodArray<z.ZodObject<{
+        resourceType: z.ZodEnum<["objects", "textures", "meshes", "materials", "animations", "skins", "images", "shaders", "pipelines", "fonts", "morphTargets", "particleEffects"]>;
+        id: z.ZodOptional<z.ZodString>;
+        changeProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        resetProperties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        resourceType: "objects" | "textures" | "meshes" | "materials" | "animations" | "skins" | "images" | "shaders" | "pipelines" | "fonts" | "morphTargets" | "particleEffects";
+        id?: string | undefined;
+        changeProperties?: Record<string, any> | undefined;
+        resetProperties?: string[] | undefined;
+    }, {
+        resourceType: "objects" | "textures" | "meshes" | "materials" | "animations" | "skins" | "images" | "shaders" | "pipelines" | "fonts" | "morphTargets" | "particleEffects";
+        id?: string | undefined;
+        changeProperties?: Record<string, any> | undefined;
+        resetProperties?: string[] | undefined;
+    }>, "many">;
+};
+export declare const importSceneFilesSchema: {
+    imports: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>, "many">;
+};
+export declare const importFilesSchema: {
+    imports: z.ZodArray<z.ZodString, "many">;
+};
+export declare const computeMeshBoundsSchema: {
+    meshIds: z.ZodArray<z.ZodString, "many">;
+};
+export declare const computeObjectBoundsSchema: {
+    objectIds: z.ZodArray<z.ZodString, "many">;
+};