@pascal-app/mcp 0.2.0

package/dist/tools/scene-lifecycle/get-project-status.d.ts

@@ -0,0 +1,31 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../../operations';
+export declare const getProjectStatusInput: {
+    id: z.ZodString;
+};
+export declare const getProjectStatusOutput: {
+    id: z.ZodString;
+    projectId: z.ZodString;
+    name: z.ZodString;
+    editorUrl: z.ZodString;
+    url: z.ZodString;
+    ownerId: z.ZodNullable<z.ZodString>;
+    thumbnailUrl: z.ZodNullable<z.ZodString>;
+    publishedVersion: z.ZodNullable<z.ZodNumber>;
+    latestVersion: z.ZodNullable<z.ZodNumber>;
+    draftVersion: z.ZodNullable<z.ZodNumber>;
+    browserVisibleVersion: z.ZodNullable<z.ZodNumber>;
+    version: z.ZodNumber;
+    isEmpty: z.ZodBoolean;
+    sizeBytes: z.ZodNumber;
+    nodeCount: z.ZodNumber;
+    graphHash: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    levelIds: z.ZodArray<z.ZodString>;
+    defaultLevelId: z.ZodNullable<z.ZodString>;
+    nextStep: z.ZodString;
+};
+export declare function registerGetProjectStatus(server: McpServer, operations: SceneOperations): void;
+//# sourceMappingURL=get-project-status.d.ts.map

package/dist/tools/scene-lifecycle/get-project-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-project-status.d.ts","sourceRoot":"","sources":["../../../src/tools/scene-lifecycle/get-project-status.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,kBAAkB,CAAA;AAIvD,eAAO,MAAM,qBAAqB;;CAEjC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;CAsBlC,CAAA;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CA2C7F"}

package/dist/tools/scene-lifecycle/get-project-status.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { ErrorCode, McpError, throwMcpError } from '../errors';
+import { currentLevelContext, projectStatusPayload } from './metadata';
+export const getProjectStatusInput = {
+    id: z.string().min(1).max(64),
+};
+export const getProjectStatusOutput = {
+    id: z.string(),
+    projectId: z.string(),
+    name: z.string(),
+    editorUrl: z.string(),
+    url: z.string(),
+    ownerId: z.string().nullable(),
+    thumbnailUrl: z.string().nullable(),
+    publishedVersion: z.number().nullable(),
+    latestVersion: z.number().nullable(),
+    draftVersion: z.number().nullable(),
+    browserVisibleVersion: z.number().nullable(),
+    version: z.number(),
+    isEmpty: z.boolean(),
+    sizeBytes: z.number(),
+    nodeCount: z.number(),
+    graphHash: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    levelIds: z.array(z.string()),
+    defaultLevelId: z.string().nullable(),
+    nextStep: z.string(),
+};
+export function registerGetProjectStatus(server, operations) {
+    server.registerTool('get_project_status', {
+        title: 'Get project status',
+        description: 'Authoritative status/debug call for a Pascal project: editor URL, browser-visible version, latest saved version, published version, node count, and graph hash.',
+        inputSchema: getProjectStatusInput,
+        outputSchema: getProjectStatusOutput,
+    }, async ({ id }) => {
+        try {
+            const status = await operations.getProjectStatus(id);
+            if (!status) {
+                throwMcpError(ErrorCode.InvalidParams, 'project_not_found', { id });
+            }
+            const activeScene = operations.getActiveScene();
+            if (activeScene?.id !== status.id) {
+                const scene = await operations.loadStoredScene(status.id);
+                if (scene) {
+                    operations.loadJSON(scene.graph);
+                    operations.setActiveScene(scene);
+                }
+            }
+            const nextStep = status.nodeCount > 0
+                ? 'Open editorUrl or continue editing, then save_scene again.'
+                : 'Project is empty. Build a scene with semantic tools or create_from_template, then save_scene.';
+            const payload = {
+                ...projectStatusPayload(status, nextStep),
+                ...currentLevelContext(operations),
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (err) {
+            if (err instanceof McpError)
+                throw err;
+            const msg = err instanceof Error ? err.message : String(err);
+            throwMcpError(ErrorCode.InternalError, msg);
+        }
+    });
+}

package/dist/tools/scene-lifecycle/index.d.ts

@@ -0,0 +1,17 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SceneOperations } from '../../operations';
+/**
+ * Register the scene-lifecycle MCP tools (`save_scene`, `load_scene`,
+ * `list_scenes`, `delete_scene`, `rename_scene`) against the given server.
+ * All tools operate against shared scene operations so MCP, REST, and future CLI
+ * entry points share the same storage boundary.
+ */
+export declare function registerSceneLifecycleTools(server: McpServer, operations: SceneOperations): void;
+export { createProjectInput, createProjectOutput, registerCreateProject } from './create-project';
+export { deleteSceneInput, deleteSceneOutput, registerDeleteScene } from './delete-scene';
+export { getProjectStatusInput, getProjectStatusOutput, registerGetProjectStatus, } from './get-project-status';
+export { listScenesInput, listScenesOutput, registerListScenes } from './list-scenes';
+export { loadSceneInput, loadSceneOutput, registerLoadScene } from './load-scene';
+export { registerRenameScene, renameSceneInput, renameSceneOutput } from './rename-scene';
+export { registerSaveScene, saveSceneInput, saveSceneOutput } from './save-scene';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/scene-lifecycle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/scene-lifecycle/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AASvD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CAQhG;AAED,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AACjG,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AACzF,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AACrF,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AACjF,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AACzF,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA"}

package/dist/tools/scene-lifecycle/index.js

@@ -0,0 +1,29 @@
+import { registerCreateProject } from './create-project';
+import { registerDeleteScene } from './delete-scene';
+import { registerGetProjectStatus } from './get-project-status';
+import { registerListScenes } from './list-scenes';
+import { registerLoadScene } from './load-scene';
+import { registerRenameScene } from './rename-scene';
+import { registerSaveScene } from './save-scene';
+/**
+ * Register the scene-lifecycle MCP tools (`save_scene`, `load_scene`,
+ * `list_scenes`, `delete_scene`, `rename_scene`) against the given server.
+ * All tools operate against shared scene operations so MCP, REST, and future CLI
+ * entry points share the same storage boundary.
+ */
+export function registerSceneLifecycleTools(server, operations) {
+    registerCreateProject(server, operations);
+    registerGetProjectStatus(server, operations);
+    registerSaveScene(server, operations);
+    registerLoadScene(server, operations);
+    registerListScenes(server, operations);
+    registerDeleteScene(server, operations);
+    registerRenameScene(server, operations);
+}
+export { createProjectInput, createProjectOutput, registerCreateProject } from './create-project';
+export { deleteSceneInput, deleteSceneOutput, registerDeleteScene } from './delete-scene';
+export { getProjectStatusInput, getProjectStatusOutput, registerGetProjectStatus, } from './get-project-status';
+export { listScenesInput, listScenesOutput, registerListScenes } from './list-scenes';
+export { loadSceneInput, loadSceneOutput, registerLoadScene } from './load-scene';
+export { registerRenameScene, renameSceneInput, renameSceneOutput } from './rename-scene';
+export { registerSaveScene, saveSceneInput, saveSceneOutput } from './save-scene';

package/dist/tools/scene-lifecycle/list-scenes.d.ts

@@ -0,0 +1,27 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../../operations';
+export declare const listScenesInput: {
+    projectId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+};
+export declare const listScenesOutput: {
+    scenes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        thumbnailUrl: z.ZodNullable<z.ZodString>;
+        version: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        ownerId: z.ZodNullable<z.ZodString>;
+        sizeBytes: z.ZodNumber;
+        nodeCount: z.ZodNumber;
+        editorUrl: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        published: z.ZodOptional<z.ZodBoolean>;
+        graphHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+};
+export declare function registerListScenes(server: McpServer, operations: SceneOperations): void;
+//# sourceMappingURL=list-scenes.d.ts.map

package/dist/tools/scene-lifecycle/list-scenes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-scenes.d.ts","sourceRoot":"","sources":["../../../src/tools/scene-lifecycle/list-scenes.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,kBAAkB,CAAA;AAKvD,eAAO,MAAM,eAAe;;;CAG3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAmB5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CA2BvF"}

package/dist/tools/scene-lifecycle/list-scenes.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from '../errors';
+const DEFAULT_LIMIT = 100;
+export const listScenesInput = {
+    projectId: z.string().optional(),
+    limit: z.number().int().positive().max(1000).optional(),
+};
+export const listScenesOutput = {
+    scenes: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        projectId: z.string().nullable(),
+        thumbnailUrl: z.string().nullable(),
+        version: z.number(),
+        createdAt: z.string(),
+        updatedAt: z.string(),
+        ownerId: z.string().nullable(),
+        sizeBytes: z.number(),
+        nodeCount: z.number(),
+        editorUrl: z.string().optional(),
+        url: z.string().optional(),
+        published: z.boolean().optional(),
+        graphHash: z.string().optional(),
+    })),
+};
+export function registerListScenes(server, operations) {
+    server.registerTool('list_scenes', {
+        title: 'List scenes',
+        description: 'List scenes in the SceneStore. Optionally filter by `projectId` and cap results with `limit` (default 100).',
+        inputSchema: listScenesInput,
+        outputSchema: listScenesOutput,
+    }, async ({ projectId, limit }) => {
+        try {
+            const scenes = await operations.listScenes({
+                ...(projectId !== undefined ? { projectId } : {}),
+                limit: limit ?? DEFAULT_LIMIT,
+            });
+            const payload = { scenes };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throwMcpError(ErrorCode.InternalError, msg);
+        }
+    });
+}

package/dist/tools/scene-lifecycle/load-scene.d.ts

@@ -0,0 +1,31 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../../operations';
+export declare const loadSceneInput: {
+    id: z.ZodString;
+};
+export declare const loadSceneOutput: {
+    id: z.ZodString;
+    name: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    thumbnailUrl: z.ZodNullable<z.ZodString>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    ownerId: z.ZodNullable<z.ZodString>;
+    sizeBytes: z.ZodNumber;
+    nodeCount: z.ZodNumber;
+    url: z.ZodString;
+    editorUrl: z.ZodString;
+    published: z.ZodBoolean;
+    isDraft: z.ZodBoolean;
+    saveMode: z.ZodEnum<{
+        draft: "draft";
+        checkpoint: "checkpoint";
+    }>;
+    graphHash: z.ZodOptional<z.ZodString>;
+    levelIds: z.ZodArray<z.ZodString>;
+    defaultLevelId: z.ZodNullable<z.ZodString>;
+};
+export declare function registerLoadScene(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=load-scene.d.ts.map

package/dist/tools/scene-lifecycle/load-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-scene.d.ts","sourceRoot":"","sources":["../../../src/tools/scene-lifecycle/load-scene.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,kBAAkB,CAAA;AAIvD,eAAO,MAAM,cAAc;;CAE1B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CAmB3B,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgClF"}

package/dist/tools/scene-lifecycle/load-scene.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from '../errors';
+import { currentLevelContext, sceneMetaPayload } from './metadata';
+export const loadSceneInput = {
+    id: z.string().min(1).max(64),
+};
+export const loadSceneOutput = {
+    id: z.string(),
+    name: z.string(),
+    projectId: z.string().nullable(),
+    thumbnailUrl: z.string().nullable(),
+    version: z.number(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    ownerId: z.string().nullable(),
+    sizeBytes: z.number(),
+    nodeCount: z.number(),
+    url: z.string(),
+    editorUrl: z.string(),
+    published: z.boolean(),
+    isDraft: z.boolean(),
+    saveMode: z.enum(['draft', 'checkpoint']),
+    graphHash: z.string().optional(),
+    levelIds: z.array(z.string()),
+    defaultLevelId: z.string().nullable(),
+};
+export function registerLoadScene(server, bridge) {
+    server.registerTool('load_scene', {
+        title: 'Load scene',
+        description: 'Load a scene from the SceneStore into the bridge. Returns the scene metadata. Throws `scene_not_found` if the id does not exist.',
+        inputSchema: loadSceneInput,
+        outputSchema: loadSceneOutput,
+    }, async ({ id }) => {
+        const result = await bridge.loadStoredScene(id);
+        if (!result) {
+            throwMcpError(ErrorCode.InvalidParams, 'scene_not_found', { id });
+        }
+        try {
+            bridge.loadJSON(result.graph);
+            bridge.setActiveScene(result);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throwMcpError(ErrorCode.InvalidRequest, `load_failed: ${msg}`, { id });
+        }
+        const payload = {
+            ...sceneMetaPayload(result, result.graph),
+            ...currentLevelContext(bridge),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/scene-lifecycle/metadata.d.ts

@@ -0,0 +1,49 @@
+import type { SceneGraph } from '@pascal-app/core/clone-scene-graph';
+import type { SceneOperations } from '../../operations';
+import type { ProjectStatus, SceneMeta } from '../../storage/types';
+export declare function computeGraphHash(graph: SceneGraph): string;
+export declare function editorUrlFor(meta: Pick<SceneMeta, 'id' | 'editorUrl' | 'url'>): string;
+export declare function sceneMetaPayload(meta: SceneMeta, graph?: SceneGraph): {
+    id: string;
+    name: string;
+    projectId: string | null;
+    thumbnailUrl: string | null;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    ownerId: string | null;
+    sizeBytes: number;
+    nodeCount: number;
+    editorUrl: string;
+    url: string;
+    published: boolean;
+    isDraft: boolean;
+    saveMode: import("../../storage").SceneSaveMode;
+    graphHash: string | undefined;
+};
+export declare function projectStatusPayload(status: ProjectStatus, nextStep?: string): {
+    nextStep?: string | undefined;
+    id: string;
+    projectId: string;
+    name: string;
+    editorUrl: string;
+    url: string;
+    ownerId: string | null;
+    thumbnailUrl: string | null;
+    publishedVersion: number | null;
+    latestVersion: number | null;
+    draftVersion: number | null;
+    browserVisibleVersion: number | null;
+    version: number;
+    isEmpty: boolean;
+    sizeBytes: number;
+    nodeCount: number;
+    graphHash: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function currentLevelContext(operations: SceneOperations): {
+    levelIds: string[];
+    defaultLevelId: string | null;
+};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/tools/scene-lifecycle/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../src/tools/scene-lifecycle/metadata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAA;AAEpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEnE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAO1D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,WAAW,GAAG,KAAK,CAAC,GAAG,MAAM,CAEtF;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,UAAU;;;;;;;;;;;;;;;;;EAoBnE;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;EAsB5E;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,eAAe;;;EAW9D"}

package/dist/tools/scene-lifecycle/metadata.js

@@ -0,0 +1,68 @@
+import { createHash } from 'node:crypto';
+export function computeGraphHash(graph) {
+    const normalized = JSON.stringify({
+        nodes: graph.nodes ?? {},
+        rootNodeIds: graph.rootNodeIds ?? [],
+        collections: graph.collections ?? {},
+    });
+    return createHash('sha256').update(normalized).digest('hex');
+}
+export function editorUrlFor(meta) {
+    return meta.editorUrl ?? meta.url ?? `/editor/${meta.id}`;
+}
+export function sceneMetaPayload(meta, graph) {
+    const editorUrl = editorUrlFor(meta);
+    return {
+        id: meta.id,
+        name: meta.name,
+        projectId: meta.projectId,
+        thumbnailUrl: meta.thumbnailUrl,
+        version: meta.version,
+        createdAt: meta.createdAt,
+        updatedAt: meta.updatedAt,
+        ownerId: meta.ownerId,
+        sizeBytes: meta.sizeBytes,
+        nodeCount: meta.nodeCount,
+        editorUrl,
+        url: editorUrl,
+        published: meta.published ?? true,
+        isDraft: meta.isDraft ?? false,
+        saveMode: meta.saveMode ?? (meta.isDraft ? 'draft' : 'checkpoint'),
+        graphHash: meta.graphHash ?? (graph ? computeGraphHash(graph) : undefined),
+    };
+}
+export function projectStatusPayload(status, nextStep) {
+    return {
+        id: status.id,
+        projectId: status.projectId,
+        name: status.name,
+        editorUrl: status.editorUrl,
+        url: status.url,
+        ownerId: status.ownerId,
+        thumbnailUrl: status.thumbnailUrl,
+        publishedVersion: status.publishedVersion,
+        latestVersion: status.latestVersion,
+        draftVersion: status.draftVersion,
+        browserVisibleVersion: status.browserVisibleVersion,
+        version: status.version,
+        isEmpty: status.isEmpty,
+        sizeBytes: status.sizeBytes,
+        nodeCount: status.nodeCount,
+        graphHash: status.graphHash,
+        createdAt: status.createdAt,
+        updatedAt: status.updatedAt,
+        ...(nextStep ? { nextStep } : {}),
+    };
+}
+export function currentLevelContext(operations) {
+    const levels = operations.findNodes({ type: 'level' }).sort((a, b) => {
+        const aa = a.type === 'level' ? a.level : 0;
+        const bb = b.type === 'level' ? b.level : 0;
+        return aa - bb;
+    });
+    const levelIds = levels.map((level) => level.id);
+    return {
+        levelIds,
+        defaultLevelId: levelIds[0] ?? null,
+    };
+}

package/dist/tools/scene-lifecycle/rename-scene.d.ts

@@ -0,0 +1,22 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../../operations';
+export declare const renameSceneInput: {
+    id: z.ZodString;
+    newName: z.ZodString;
+    expectedVersion: z.ZodOptional<z.ZodNumber>;
+};
+export declare const renameSceneOutput: {
+    id: z.ZodString;
+    name: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    thumbnailUrl: z.ZodNullable<z.ZodString>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    ownerId: z.ZodNullable<z.ZodString>;
+    sizeBytes: z.ZodNumber;
+    nodeCount: z.ZodNumber;
+};
+export declare function registerRenameScene(server: McpServer, operations: SceneOperations): void;
+//# sourceMappingURL=rename-scene.d.ts.map

package/dist/tools/scene-lifecycle/rename-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename-scene.d.ts","sourceRoot":"","sources":["../../../src/tools/scene-lifecycle/rename-scene.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,kBAAkB,CAAA;AAIvD,eAAO,MAAM,gBAAgB;;;;CAI5B,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;CAW7B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CA8CxF"}

package/dist/tools/scene-lifecycle/rename-scene.js

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { SceneNotFoundError, SceneVersionConflictError } from '../../storage/types';
+import { ErrorCode, throwMcpError } from '../errors';
+export const renameSceneInput = {
+    id: z.string().min(1).max(64),
+    newName: z.string().min(1).max(200),
+    expectedVersion: z.number().int().positive().optional(),
+};
+export const renameSceneOutput = {
+    id: z.string(),
+    name: z.string(),
+    projectId: z.string().nullable(),
+    thumbnailUrl: z.string().nullable(),
+    version: z.number(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    ownerId: z.string().nullable(),
+    sizeBytes: z.number(),
+    nodeCount: z.number(),
+};
+export function registerRenameScene(server, operations) {
+    server.registerTool('rename_scene', {
+        title: 'Rename scene',
+        description: 'Rename a scene in the SceneStore. Returns the updated SceneMeta. Optionally pass `expectedVersion` for optimistic concurrency.',
+        inputSchema: renameSceneInput,
+        outputSchema: renameSceneOutput,
+    }, async ({ id, newName, expectedVersion }) => {
+        try {
+            const meta = await operations.renameStoredScene(id, newName, {
+                ...(expectedVersion !== undefined ? { expectedVersion } : {}),
+            });
+            const payload = {
+                id: meta.id,
+                name: meta.name,
+                projectId: meta.projectId,
+                thumbnailUrl: meta.thumbnailUrl,
+                version: meta.version,
+                createdAt: meta.createdAt,
+                updatedAt: meta.updatedAt,
+                ownerId: meta.ownerId,
+                sizeBytes: meta.sizeBytes,
+                nodeCount: meta.nodeCount,
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (err) {
+            if (err instanceof SceneNotFoundError) {
+                throwMcpError(ErrorCode.InvalidParams, 'scene_not_found', { id });
+            }
+            if (err instanceof SceneVersionConflictError) {
+                throwMcpError(ErrorCode.InvalidRequest, 'version_conflict', {
+                    id,
+                    expectedVersion,
+                });
+            }
+            const msg = err instanceof Error ? err.message : String(err);
+            throwMcpError(ErrorCode.InternalError, msg);
+        }
+    });
+}

package/dist/tools/scene-lifecycle/save-scene.d.ts

@@ -0,0 +1,42 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../../operations';
+export declare const saveSceneInput: {
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    expectedVersion: z.ZodOptional<z.ZodNumber>;
+    saveMode: z.ZodDefault<z.ZodEnum<{
+        draft: "draft";
+        checkpoint: "checkpoint";
+    }>>;
+    publish: z.ZodOptional<z.ZodBoolean>;
+    thumbnail: z.ZodOptional<z.ZodString>;
+    includeCurrentScene: z.ZodDefault<z.ZodBoolean>;
+    graph: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export declare const saveSceneOutput: {
+    id: z.ZodString;
+    name: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    thumbnailUrl: z.ZodNullable<z.ZodString>;
+    version: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    ownerId: z.ZodNullable<z.ZodString>;
+    sizeBytes: z.ZodNumber;
+    nodeCount: z.ZodNumber;
+    url: z.ZodString;
+    editorUrl: z.ZodString;
+    published: z.ZodBoolean;
+    isDraft: z.ZodBoolean;
+    saveMode: z.ZodEnum<{
+        draft: "draft";
+        checkpoint: "checkpoint";
+    }>;
+    graphHash: z.ZodOptional<z.ZodString>;
+    levelIds: z.ZodArray<z.ZodString>;
+    defaultLevelId: z.ZodNullable<z.ZodString>;
+};
+export declare function registerSaveScene(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=save-scene.d.ts.map

package/dist/tools/scene-lifecycle/save-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save-scene.d.ts","sourceRoot":"","sources":["../../../src/tools/scene-lifecycle/save-scene.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,kBAAkB,CAAA;AAMvD,eAAO,MAAM,cAAc;;;;;;;;;;;;;CA0B1B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CAmB3B,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAiGlF"}