@downdraft/engine 0.1.1 → 0.2.0

package/dist/mcp/src/engine-context.js

@@ -0,0 +1,99 @@
+import { AssetManager as AssetManagerClass, AudioListener, AudioSource, BlendMode, Camera as CameraClass, CheckpointManager as CheckpointManagerClass, createAudioListener, createAudioSource, createDirectionalLight as createDirLight, createPointLight as createPtLight, CullMode, DebugDrawQueue as DebugDrawQueueClass, entityEqual, GameWorld as GameWorldClass, getComponentId, getComponentName, isAlive, LightType as LightTypeEnum, LODGenerator as LODGeneratorClass, Material as MaterialClass, MaterialHotReloader as MaterialHotReloaderClass, MaterialLibrary as MaterialLibraryClass, MeshBuilder as MeshBuilderClass, ROOT_ENTITY, SaveSystem as SaveSystemClass, Scene as SceneClass, ScriptingSystem as ScriptingSystemClass, TelemetryCollector as TelemetryCollectorClass, TelemetryReporter as TelemetryReporterClass, World as WorldClass } from "@downdraft/engine";
+export class EngineContext {
+    world;
+    ecsWorld;
+    scene;
+    camera;
+    hierarchy;
+    assetManager;
+    materialLibrary;
+    checkpointManager;
+    telemetryCollector;
+    telemetryReporter;
+    debugDraw;
+    scriptingSystem;
+    saveSystem;
+    lights = [];
+    meshes = new Map();
+    entityMeshes = new Map();
+    entityMaterials = new Map();
+    physicsRealms = new Map();
+    bodyHandles = new Map();
+    raycastQuery = null;
+    debugVisualizeMode = "none";
+    audioEngine = null;
+    animationPlayers = new Map();
+    materialHotReloader;
+    lodConfigs = new Map();
+    lodGenerator;
+    audioSources = new Map();
+    audioListeners = new Map();
+    cameraFollowEntity = null;
+    constructor(opts = {}) {
+        const ecsWorld = new WorldClass();
+        this.ecsWorld = ecsWorld;
+        this.scene = new SceneClass(opts.sceneName ?? "main", ecsWorld);
+        this.world = new GameWorldClass(this.scene);
+        this.camera = new CameraClass();
+        this.hierarchy = this.world.hierarchy;
+        this.assetManager = new AssetManagerClass();
+        this.materialLibrary = new MaterialLibraryClass();
+        this.checkpointManager = new CheckpointManagerClass();
+        this.telemetryCollector = new TelemetryCollectorClass(opts.enableTelemetry ?? true);
+        this.telemetryReporter = new TelemetryReporterClass(this.telemetryCollector);
+        this.debugDraw = new DebugDrawQueueClass();
+        this.scriptingSystem = new ScriptingSystemClass(ecsWorld);
+        this.saveSystem = new SaveSystemClass();
+        this.materialHotReloader = new MaterialHotReloaderClass();
+        this.lodGenerator = new LODGeneratorClass();
+    }
+    static fromGame(opts) {
+        const ctx = new EngineContext({
+            sceneName: opts.scene.name,
+            enableTelemetry: opts.enableTelemetry,
+        });
+        ctx.ecsWorld = opts.ecsWorld;
+        ctx.scene = opts.scene;
+        ctx.world = opts.gameWorld;
+        ctx.camera = opts.camera;
+        ctx.hierarchy = opts.gameWorld.hierarchy;
+        return ctx;
+    }
+    getEntityKey(e) {
+        return `${e.index}.${e.generation}`;
+    }
+    parseEntityKey(key) {
+        const parts = key.split(".");
+        if (parts.length !== 2)
+            return null;
+        const index = parseInt(parts[0], 10);
+        const generation = parseInt(parts[1], 10);
+        if (isNaN(index) || isNaN(generation))
+            return null;
+        return { index, generation };
+    }
+    isEntityAlive(e) {
+        return isAlive(this.ecsWorld.entities, e);
+    }
+    getAllAliveEntities() {
+        const result = [];
+        for (let i = 0; i < this.ecsWorld.entities.length; i++) {
+            const meta = this.ecsWorld.entities[i];
+            if (meta.alive) {
+                result.push({ index: i, generation: meta.generation });
+            }
+        }
+        return result;
+    }
+    getComponentNameById(id) {
+        return getComponentName(id);
+    }
+    getComponentIdByName(name) {
+        return getComponentId(name);
+    }
+    step(dt) {
+        this.world.step(dt);
+        this.telemetryCollector.recordFrame(dt * 1000);
+    }
+}
+export { AudioListener, AudioSource, BlendMode, createAudioListener, createAudioSource, createDirLight as createDirectionalLight, createPtLight as createPointLight, CullMode, entityEqual, LightTypeEnum as LightType, LODGeneratorClass as LODGenerator, MaterialClass as Material, MaterialHotReloaderClass as MaterialHotReloader, MeshBuilderClass as MeshBuilder, ROOT_ENTITY };

package/dist/mcp/src/http-transport.js

@@ -0,0 +1,423 @@
+// ============================================================================
+// MCP HTTP Transport — HTTP server that bridges JSON-RPC requests to MCPServer
+// Supports direct mode (has MCPServer instance) or proxy mode (forwards via callback)
+// ============================================================================
+import { randomBytes } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { stat as statFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { sep as pathSep, resolve as resolvePath } from "node:path";
+/** Loopback hostnames accepted in Host/Origin headers. Everything else is
+ *  rejected — the endpoint binds 127.0.0.1 and is meant for local tools only. */
+const LOOPBACK_HOST_RE = /^(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/;
+export class McpHttpTransport {
+    server = null;
+    port;
+    /** Actual bound port (set after start()). Equals `port` when explicitly
+     *  configured; differs when `port` was 0 (ephemeral OS-assigned port). */
+    boundPort = null;
+    mode;
+    mcpServer;
+    proxyHandler;
+    initialized = false;
+    sessionId = null;
+    sseResponse = null;
+    /** Optional root directory for the GET /mcp/artifact/<path> download endpoint. */
+    artifactDir = null;
+    /** Bearer token for optional authentication. Always generated so it can be
+     *  advertised to trusted local clients (e.g. via the PID `.token` file). */
+    authToken;
+    /** When true, every request (except /mcp/health) must carry the token.
+     *  Default false — Origin+Host checks already block browser clients, and
+     *  external stdio bridges that only read the PID port file don't yet send
+     *  a token. Enable via config `mcp.requireAuth` or `MCP_AUTH=1`. */
+    requireAuth;
+    constructor(opts) {
+        this.port = opts.port ?? 0;
+        if (opts.mcpServer) {
+            this.mode = "direct";
+            this.mcpServer = opts.mcpServer;
+            this.proxyHandler = null;
+        }
+        else if (opts.proxyHandler) {
+            this.mode = "proxy";
+            this.mcpServer = null;
+            this.proxyHandler = opts.proxyHandler;
+        }
+        else {
+            throw new Error("McpHttpTransport requires either mcpServer or proxyHandler");
+        }
+        this.artifactDir = opts.artifactDir ?? null;
+        this.authToken = opts.authToken ?? randomBytes(24).toString("hex");
+        this.requireAuth =
+            opts.requireAuth ??
+                (typeof process !== "undefined" && process.env?.MCP_AUTH === "1");
+    }
+    start() {
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => this.handleRequest(req, res));
+            this.server.on("error", (err) => {
+                this.server = null;
+                reject(err);
+            });
+            // Bind to loopback only — the MCP transport is for local clients
+            // (Devin's stdio bridge, the e2e harness). Binding 0.0.0.0 would
+            // expose the JSON-RPC endpoint to the local network.
+            this.server.listen(this.port, "127.0.0.1", () => {
+                const addr = this.server.address();
+                this.boundPort = addr && typeof addr === "object" ? addr.port : this.port;
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => resolve());
+                this.server = null;
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /**
+     * The actual bound port. After `start()` this is the OS-assigned port
+     * when `port` was 0 (ephemeral); before `start()` (or after `stop()`)
+     * it falls back to the configured `port`.
+     */
+    getPort() {
+        return this.boundPort ?? this.port;
+    }
+    /** The bearer token required when `requireAuth` is enabled. Written to the
+     *  PID `.token` file so trusted local clients can discover it. */
+    getAuthToken() {
+        return this.authToken;
+    }
+    /**
+     * Local-client gate. The endpoint binds 127.0.0.1 but browsers treat
+     * loopback as trustworthy — without these checks any webpage could drive
+     * the JSON-RPC surface (which includes code-eval and heap-snapshot tools):
+     *
+     *  - `Host` must be loopback → defeats DNS-rebinding to 127.0.0.1.
+     *  - `Origin`, when present (browsers always send it on POST), must be
+     *    loopback → defeats fetch() from arbitrary web pages. Node fetch and
+     *    curl send no Origin, so CLI clients are unaffected.
+     *  - `requireAuth` additionally demands the bearer token.
+     *
+     * No CORS headers are ever emitted, so even if an Origin check regressed,
+     * browser JS could not read responses.
+     */
+    checkLocalClient(req, res) {
+        const host = req.headers.host ?? "";
+        if (!LOOPBACK_HOST_RE.test(host)) {
+            this.sendJSON(res, 403, { error: "Forbidden: non-loopback Host" });
+            return false;
+        }
+        const origin = req.headers.origin;
+        if (origin !== undefined) {
+            let originHost = "";
+            try {
+                originHost = new URL(origin).host;
+            }
+            catch {
+                /* invalid origin → reject below */
+            }
+            if (!LOOPBACK_HOST_RE.test(originHost)) {
+                this.sendJSON(res, 403, { error: "Forbidden: non-loopback Origin" });
+                return false;
+            }
+        }
+        if (this.requireAuth) {
+            const bearer = /^Bearer (.+)$/.exec(req.headers.authorization ?? "")?.[1];
+            const token = req.headers["x-downdraft-token"] ?? bearer;
+            if (token !== this.authToken) {
+                this.sendJSON(res, 401, { error: "Unauthorized" });
+                return false;
+            }
+        }
+        return true;
+    }
+    sendJSON(res, status, data) {
+        res.writeHead(status, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(data));
+    }
+    /**
+     * Stream a file from the artifact directory. Supports HTTP Range requests
+     * for large trace files. Rejects paths that escape artifactDir.
+     */
+    async handleArtifactDownload(req, res) {
+        if (!this.artifactDir) {
+            this.sendJSON(res, 503, { error: "Artifact download not configured (no artifactDir)" });
+            return;
+        }
+        // Decode the relative path from the URL (after /mcp/artifact/).
+        const prefix = "/mcp/artifact/";
+        const rawRel = decodeURIComponent(req.url.slice(prefix.length));
+        // Strip any query string.
+        const relPath = rawRel.split("?")[0];
+        // Resolve against artifactDir and verify the result stays inside it.
+        const resolved = resolvePath(this.artifactDir, relPath);
+        const root = resolvePath(this.artifactDir) + pathSep;
+        if (!resolved.startsWith(root)) {
+            this.sendJSON(res, 403, { error: "Path traversal rejected" });
+            return;
+        }
+        let fileSize;
+        try {
+            const s = await statFile(resolved);
+            if (!s.isFile()) {
+                this.sendJSON(res, 404, { error: "Not a file" });
+                return;
+            }
+            fileSize = s.size;
+        }
+        catch {
+            this.sendJSON(res, 404, { error: "File not found" });
+            return;
+        }
+        // Content-Type by extension.
+        const lower = resolved.toLowerCase();
+        let contentType = "application/octet-stream";
+        if (lower.endsWith(".json"))
+            contentType = "application/json";
+        else if (lower.endsWith(".heapsnapshot"))
+            contentType = "application/octet-stream";
+        // Range support.
+        const rangeHeader = req.headers.range;
+        if (rangeHeader) {
+            const match = /^bytes=(\d+)-(\d*)$/.exec(rangeHeader);
+            if (match) {
+                const start = parseInt(match[1], 10);
+                const end = match[2] ? parseInt(match[2], 10) : fileSize - 1;
+                if (start >= fileSize || end >= fileSize || start > end) {
+                    res.writeHead(416, {
+                        "Content-Range": `bytes */${fileSize}`,
+                        "Content-Type": contentType,
+                    });
+                    res.end();
+                    return;
+                }
+                res.writeHead(206, {
+                    "Content-Type": contentType,
+                    "Content-Range": `bytes ${start}-${end}/${fileSize}`,
+                    "Content-Length": end - start + 1,
+                    "Accept-Ranges": "bytes",
+                });
+                createReadStream(resolved, { start, end }).pipe(res);
+                return;
+            }
+        }
+        res.writeHead(200, {
+            "Content-Type": contentType,
+            "Content-Length": fileSize,
+            "Accept-Ranges": "bytes",
+        });
+        createReadStream(resolved).pipe(res);
+    }
+    async handleRequest(req, res) {
+        if (req.method === "OPTIONS") {
+            // No CORS headers — preflight gets a bare 204 and browser fetches fail.
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // GET /mcp/health — readiness probe for the e2e harness; intentionally
+        // exempt from the local-client gate (it leaks only port/mode booleans).
+        // Everything else requires a loopback Host/Origin (+ token if enabled).
+        if (req.method === "GET" && req.url === "/mcp/health") {
+            this.sendJSON(res, 200, {
+                status: "ok",
+                mode: this.mode,
+                port: this.getPort(),
+                initialized: this.initialized,
+            });
+            return;
+        }
+        if (!this.checkLocalClient(req, res))
+            return;
+        // GET /mcp/artifact/<path> — stream a generated trace/heap-snapshot file.
+        // <path> is relative to the configured artifactDir. Path traversal is
+        // rejected: the resolved path must start with artifactDir + sep.
+        if (req.method === "GET" && req.url?.startsWith("/mcp/artifact/")) {
+            await this.handleArtifactDownload(req, res);
+            return;
+        }
+        // GET /mcp/tools
+        if (req.method === "GET" && req.url === "/mcp/tools") {
+            try {
+                const tools = await this.handleJsonRpc("tools/list", {});
+                this.sendJSON(res, 200, tools);
+            }
+            catch (e) {
+                this.sendJSON(res, 500, { error: e.message });
+            }
+            return;
+        }
+        // GET /mcp or / — SSE stream (MCP HTTP+SSE transport)
+        // The client opens an SSE connection; we send an `endpoint` event
+        // telling it to POST JSON-RPC messages back to /mcp.
+        if (req.method === "GET" && (req.url === "/mcp" || req.url === "/" || req.url === "/mcp/")) {
+            if (!this.sessionId)
+                this.sessionId = `mcp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Mcp-Session-Id": this.sessionId,
+            });
+            // Tell the client where to POST requests
+            res.write(`event: endpoint\ndata: /mcp\n\n`);
+            // Keep the connection open — the client will POST requests separately
+            // and we'll stream responses back on this connection.
+            // Store the response so we can write to it later.
+            this.sseResponse = res;
+            req.on("close", () => {
+                if (this.sseResponse === res)
+                    this.sseResponse = null;
+            });
+            return;
+        }
+        // POST /mcp or POST / (root) — MCP Streamable HTTP transport
+        // The MCP client POSTs JSON-RPC messages to the configured URL.
+        // We accept both /mcp and / so the URL can be either
+        // "http://localhost:PORT" or "http://localhost:PORT/mcp".
+        if (req.method === "POST" && (req.url === "/mcp" || req.url === "/" || req.url === "/mcp/")) {
+            // MCP Streamable HTTP: return session ID header on initialize
+            if (!this.sessionId)
+                this.sessionId = `mcp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+            res.setHeader("Mcp-Session-Id", this.sessionId);
+            let body = "";
+            req.on("data", (chunk) => { body += chunk; });
+            req.on("end", async () => {
+                let msg;
+                try {
+                    msg = JSON.parse(body);
+                }
+                catch (e) {
+                    this.sendJSON(res, 400, {
+                        jsonrpc: "2.0",
+                        id: 0,
+                        error: { code: -32700, message: `Parse error: ${e.message}` },
+                    });
+                    return;
+                }
+                try {
+                    const result = await this.handleJsonRpc(msg.method, msg.params ?? {});
+                    const response = { jsonrpc: "2.0", id: msg.id ?? 0, result };
+                    // If there's an open SSE stream (HTTP+SSE transport), write the
+                    // response to it and respond to the POST with 202 Accepted.
+                    // Check writableEnded to avoid writing to a closed stream.
+                    if (this.sseResponse && !this.sseResponse.writableEnded && !this.sseResponse.destroyed) {
+                        this.sseResponse.write(`event: message\ndata: ${JSON.stringify(response)}\n\n`);
+                        res.writeHead(202);
+                        res.end();
+                        return;
+                    }
+                    // Streamable HTTP: check Accept header for SSE format
+                    const accept = req.headers.accept ?? "";
+                    if (accept.includes("text/event-stream")) {
+                        res.writeHead(200, {
+                            "Content-Type": "text/event-stream",
+                            "Cache-Control": "no-cache",
+                            "Connection": "keep-alive",
+                        });
+                        res.write(`event: message\ndata: ${JSON.stringify(response)}\n\n`);
+                        res.end();
+                    }
+                    else {
+                        this.sendJSON(res, 200, response);
+                    }
+                }
+                catch (e) {
+                    // Method/handler failure — return a JSON-RPC error (not HTTP 400)
+                    // so clients see the real tool error instead of a transport error.
+                    this.sendJSON(res, 200, {
+                        jsonrpc: "2.0",
+                        id: msg.id ?? 0,
+                        error: { code: -32603, message: e.message },
+                    });
+                }
+            });
+            return;
+        }
+        // DELETE /mcp or / — end session (MCP Streamable HTTP)
+        if (req.method === "DELETE" && (req.url === "/mcp" || req.url === "/" || req.url === "/mcp/")) {
+            this.initialized = false;
+            this.sessionId = null;
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        this.sendJSON(res, 404, { error: "Not found" });
+    }
+    async handleJsonRpc(method, params) {
+        if (method === "initialize") {
+            this.initialized = true;
+            return {
+                protocolVersion: "2024-11-05",
+                capabilities: { tools: {}, resources: {}, prompts: {} },
+                serverInfo: { name: "downdraft-mcp", version: "0.1.0" },
+            };
+        }
+        if (!this.initialized) {
+            throw new Error("Server not initialized");
+        }
+        if (this.mode === "direct" && this.mcpServer) {
+            return this.handleDirect(method, params);
+        }
+        else if (this.mode === "proxy" && this.proxyHandler) {
+            return this.proxyHandler({ method, params });
+        }
+        throw new Error("No handler available");
+    }
+    async handleDirect(method, params) {
+        const server = this.mcpServer;
+        switch (method) {
+            case "tools/list":
+                return {
+                    tools: server.listTools().map((t) => ({
+                        name: t.name,
+                        description: t.description,
+                        inputSchema: t.inputSchema,
+                    })),
+                };
+            case "tools/call": {
+                const name = params.name;
+                const args = params.arguments ?? {};
+                return await server.callTool(name, args);
+            }
+            case "resources/list":
+                return {
+                    resources: server.listResources().map((r) => ({
+                        uri: r.uri,
+                        name: r.name,
+                        description: r.description,
+                        mimeType: r.mimeType,
+                    })),
+                };
+            case "resources/read": {
+                const uri = params.uri;
+                return await server.readResource(uri);
+            }
+            case "prompts/list":
+                return {
+                    prompts: server.listPrompts().map((p) => ({
+                        name: p.name,
+                        description: p.description,
+                        arguments: p.arguments,
+                    })),
+                };
+            case "prompts/get": {
+                const name = params.name;
+                const args = params.arguments ?? {};
+                return await server.getPrompt(name, args);
+            }
+            case "shutdown":
+                this.initialized = false;
+                return {};
+            default:
+                throw new Error(`Method not found: ${method}`);
+        }
+    }
+}

package/dist/mcp/src/index.js

@@ -0,0 +1,5 @@
+export { discoverGameInstance, findFreePort, GameClient, launchGame, listGameInstances, McpClientError, mcpPortDir } from "./client.js";
+export { EngineContext } from "./engine-context.js";
+export { MCPServer } from "./server.js";
+export { errorResult, jsonResult, textResult } from "./types.js";
+export { UndoRedoManager } from "./undo-redo.js";

package/dist/mcp/src/prompts/add-entity.js

@@ -0,0 +1,39 @@
+export function createAddEntityPrompt() {
+    return [
+        {
+            def: {
+                name: "add-entity",
+                description: "Template for adding a new entity to the current scene",
+                arguments: [
+                    { name: "entityType", description: "Type of entity (cube, sphere, plane, custom)", required: true },
+                    { name: "position", description: "Position as 'x,y,z'" },
+                    { name: "material", description: "Material type (pbr, unlit, etc.)" },
+                ],
+            },
+            handler: (args) => {
+                const entityType = args.entityType ?? "cube";
+                const position = args.position ?? "0,0,0";
+                const material = args.material ?? "pbr";
+                return {
+                    messages: [
+                        {
+                            role: "user",
+                            content: {
+                                type: "text",
+                                text: `Add a ${entityType} entity to the scene at position (${position}) with a ${material} material.
+
+Steps:
+1. Generate a procedural ${entityType} mesh (generate_procedural_mesh)
+2. Spawn an entity with a Transform component at position (${position}) (spawn_entity)
+3. Assign the mesh to the entity (assign_mesh)
+4. Create a ${material} material (create_material)
+5. Assign the material to the entity (assign_material)
+6. Verify with get_entity_state`,
+                            },
+                        },
+                    ],
+                };
+            },
+        },
+    ];
+}

package/dist/mcp/src/prompts/create-scene.js

@@ -0,0 +1,41 @@
+export function createCreateScenePrompt() {
+    return [
+        {
+            def: {
+                name: "create-scene",
+                description: "Template for creating a new scene with entities, lighting, and camera",
+                arguments: [
+                    { name: "sceneName", description: "Name of the scene to create", required: true },
+                    { name: "description", description: "Description of what the scene should contain" },
+                ],
+            },
+            handler: (args) => {
+                const sceneName = args.sceneName ?? "my-scene";
+                const description = args.description ?? "a basic scene with lighting";
+                return {
+                    messages: [
+                        {
+                            role: "user",
+                            content: {
+                                type: "text",
+                                text: `Create a scene called "${sceneName}" that contains ${description}.
+
+Steps:
+1. Use create_scene to create a new scene named "${sceneName}"
+2. Generate procedural meshes as needed (generate_procedural_mesh)
+3. Spawn entities with Transform components (spawn_entity)
+4. Assign meshes to entities (assign_mesh)
+5. Create and assign materials (create_material, assign_material)
+6. Add lighting (add_light or set_sun_angle)
+7. Position the camera to frame the scene (set_camera)
+8. Create a checkpoint (create_checkpoint)
+
+Use the available MCP tools to accomplish each step.`,
+                            },
+                        },
+                    ],
+                };
+            },
+        },
+    ];
+}

package/dist/mcp/src/prompts/debug-frame.js

@@ -0,0 +1,36 @@
+export function createDebugFramePrompt() {
+    return [
+        {
+            def: {
+                name: "debug-frame",
+                description: "Template for debugging why a frame is slow or rendering incorrectly",
+                arguments: [
+                    { name: "symptom", description: "What's wrong (slow, black screen, flickering, etc.)", required: true },
+                ],
+            },
+            handler: (args) => {
+                const symptom = args.symptom ?? "the frame is slow";
+                return {
+                    messages: [
+                        {
+                            role: "user",
+                            content: {
+                                type: "text",
+                                text: `Debug why ${symptom}.
+
+Steps:
+1. Use profile_frame to get per-system timings and frame time
+2. Use get_performance_history to see frame time trends
+3. Use get_telemetry to check GC pauses, memory, and CPU per thread
+4. Use get_scene_tree to verify entity count is expected
+5. Use inspect_gpu to check buffer sizes and texture memory
+6. If a specific system is slow, use inspect_object to examine related entities
+7. Suggest optimizations based on findings`,
+                            },
+                        },
+                    ],
+                };
+            },
+        },
+    ];
+}

package/dist/mcp/src/prompts/index.js

@@ -0,0 +1,10 @@
+import { createCreateScenePrompt } from "./create-scene.js";
+import { createAddEntityPrompt } from "./add-entity.js";
+import { createDebugFramePrompt } from "./debug-frame.js";
+export function createPrompts() {
+    return [
+        ...createCreateScenePrompt(),
+        ...createAddEntityPrompt(),
+        ...createDebugFramePrompt(),
+    ];
+}