@skenora/tooling 0.1.2

package/dist/mcp.js

@@ -0,0 +1,817 @@
+import { createHash } from "node:crypto";
+import { checkSceneInput } from "@skenora/scene-plan";
+import { createDoctorReport } from "./doctor.js";
+import { getInstalledSkenoraExample, getInstalledSkenoraExampleSource, listInstalledSkenoraExamples, searchInstalledSkenoraExamples, } from "./examples.js";
+import { getToolingResource, listToolingResources, searchToolingResources, } from "./resources.js";
+export const SKENORA_MCP_PROTOCOL_VERSION = "2026-07-28";
+export const SKENORA_MCP_LEGACY_PROTOCOL_VERSION = "2025-11-25";
+const DEFAULT_SERVER_INFO = Object.freeze({
+    name: "skenora-readonly",
+    version: "0.1.2",
+});
+const MODERN_PROTOCOL_VERSIONS = Object.freeze([SKENORA_MCP_PROTOCOL_VERSION]);
+const PUBLIC_CACHE = Object.freeze({
+    ttlMs: 3_600_000,
+    cacheScope: "public",
+});
+const PRIVATE_CACHE = Object.freeze({
+    ttlMs: 3_600_000,
+    cacheScope: "private",
+});
+const ASSET_KINDS = Object.freeze([
+    "model",
+    "texture",
+    "environment",
+    "audio",
+    "data",
+]);
+export function createSkenoraMcpServer(options = {}) {
+    if (options.scenePlans &&
+        typeof options.scenePlans.authorize !== "function") {
+        throw new Error("ScenePlan MCP authoring requires an authorize callback");
+    }
+    const serverInfo = Object.freeze({
+        ...(options.scenePlans
+            ? { name: "skenora-authoring", version: "0.1.2" }
+            : DEFAULT_SERVER_INFO),
+        ...options.serverInfo,
+    });
+    const tools = Object.freeze([
+        ...READ_ONLY_TOOLS,
+        ...(options.scenePlans ? SCENE_PLAN_TOOLS : []),
+    ]);
+    return Object.freeze({
+        serverInfo,
+        authoring: options.scenePlans !== undefined,
+        async handle(input, context = { transport: "in-process" }) {
+            if (!isMcpRequest(input)) {
+                return createSkenoraMcpErrorResponse(requestId(input), -32600, "Invalid Request");
+            }
+            if (input.id === undefined)
+                return null;
+            if (isModernContext(context)) {
+                const issue = validateSkenoraMcpModernRequest(input);
+                if (issue) {
+                    return createSkenoraMcpErrorResponse(input.id, issue.code, issue.message, issue.data);
+                }
+            }
+            else if (context.protocolVersion === SKENORA_MCP_LEGACY_PROTOCOL_VERSION &&
+                getSkenoraMcpRequestProtocolVersion(input) !== undefined) {
+                return createSkenoraMcpErrorResponse(input.id, -32022, "This MCP connection is pinned to the legacy protocol era", { supportedVersions: [SKENORA_MCP_LEGACY_PROTOCOL_VERSION] });
+            }
+            try {
+                const result = await handleRequest(input, context, serverInfo, tools, options.scenePlans);
+                return { jsonrpc: "2.0", id: input.id, result };
+            }
+            catch (error) {
+                return createSkenoraMcpErrorResponse(input.id, error instanceof SkenoraMcpError ? error.code : -32603, error instanceof Error ? error.message : "Internal error", error instanceof SkenoraMcpError ? error.data : undefined);
+            }
+        },
+    });
+}
+export function createSkenoraMcpErrorResponse(id, code, message, data) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: Object.freeze({
+            code,
+            message,
+            ...(data === undefined ? {} : { data }),
+        }),
+    };
+}
+export function getSkenoraMcpRequestProtocolVersion(input) {
+    if (!isRecord(input) || !isRecord(input.params))
+        return undefined;
+    const meta = input.params._meta;
+    if (!isRecord(meta))
+        return undefined;
+    const version = meta["io.modelcontextprotocol/protocolVersion"];
+    return typeof version === "string" ? version : undefined;
+}
+export function validateSkenoraMcpModernRequest(input) {
+    if (!isRecord(input) || typeof input.method !== "string")
+        return null;
+    if (!isRecord(input.params) || !isRecord(input.params._meta)) {
+        return protocolIssue(-32602, "Modern MCP requests require params._meta");
+    }
+    const meta = input.params._meta;
+    const protocolVersion = meta["io.modelcontextprotocol/protocolVersion"];
+    if (typeof protocolVersion !== "string") {
+        return protocolIssue(-32602, "Modern MCP requests require a protocol version in params._meta");
+    }
+    if (protocolVersion !== SKENORA_MCP_PROTOCOL_VERSION) {
+        return protocolIssue(-32022, `Unsupported MCP protocol version: ${protocolVersion}`, { supportedVersions: MODERN_PROTOCOL_VERSIONS });
+    }
+    const clientCapabilities = meta["io.modelcontextprotocol/clientCapabilities"];
+    if (!isRecord(clientCapabilities)) {
+        return protocolIssue(-32602, "Modern MCP requests require client capabilities in params._meta");
+    }
+    const clientInfo = meta["io.modelcontextprotocol/clientInfo"];
+    if (clientInfo !== undefined &&
+        (!isRecord(clientInfo) ||
+            typeof clientInfo.name !== "string" ||
+            !clientInfo.name ||
+            typeof clientInfo.version !== "string" ||
+            !clientInfo.version)) {
+        return protocolIssue(-32602, "Invalid MCP clientInfo metadata");
+    }
+    return null;
+}
+export function createSkenoraMcpPlanHash(input) {
+    const normalized = parseJsonString(input);
+    const canonical = JSON.stringify(canonicalizeJson(normalized));
+    if (canonical === undefined) {
+        throw new Error("MCP plans must be JSON-compatible values");
+    }
+    return `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
+}
+async function handleRequest(request, context, serverInfo, tools, scenePlans) {
+    const { method, params } = request;
+    const modern = isModernContext(context);
+    if (method === "initialize" && modern) {
+        throw new SkenoraMcpError(-32601, "Method not found: initialize");
+    }
+    if (method === "server/discover" && !modern) {
+        throw new SkenoraMcpError(-32601, "Method not found: server/discover");
+    }
+    switch (method) {
+        case "server/discover":
+            return complete({
+                ...PUBLIC_CACHE,
+                supportedVersions: MODERN_PROTOCOL_VERSIONS,
+                capabilities: { resources: {}, tools: {} },
+                instructions: scenePlans
+                    ? "Skenora docs, examples, pure scene checks, and authorized ScenePlan authoring. Every scene call requires an explicit editorHandle."
+                    : "Read-only Skenora docs, examples, schemas, pure scene checks, and doctor reports.",
+            }, serverInfo, context);
+        case "initialize":
+            return {
+                protocolVersion: negotiateLegacyVersion(params?.protocolVersion),
+                capabilities: { resources: {}, tools: {} },
+                serverInfo,
+                instructions: scenePlans
+                    ? "Authorized Skenora ScenePlan authoring plus read-only developer resources."
+                    : "Read-only Skenora docs, examples, schemas, pure scene checks, and doctor reports.",
+            };
+        case "ping":
+            if (modern) {
+                throw new SkenoraMcpError(-32601, "Method not found: ping");
+            }
+            return {};
+        case "resources/list": {
+            const entries = await listToolingResources();
+            return complete({
+                ...PUBLIC_CACHE,
+                resources: entries.map((entry) => ({
+                    uri: resourceUri(entry.id),
+                    name: entry.id,
+                    title: entry.title,
+                    mimeType: entry.mediaType,
+                    description: `${entry.kind} v${entry.version}`,
+                })),
+            }, serverInfo, context);
+        }
+        case "resources/read": {
+            const id = parseResourceUri(requireString(params?.uri, "uri"));
+            const resource = await getToolingResource(id);
+            return complete({
+                ...PUBLIC_CACHE,
+                contents: [
+                    {
+                        uri: resourceUri(id),
+                        mimeType: resource.entry.mediaType,
+                        text: resource.text,
+                    },
+                ],
+            }, serverInfo, context);
+        }
+        case "tools/list":
+            return complete({
+                ...(scenePlans ? PRIVATE_CACHE : PUBLIC_CACHE),
+                tools,
+            }, serverInfo, context);
+        case "tools/call":
+            return callTool(requireString(params?.name, "name"), params?.arguments, context, serverInfo, tools, scenePlans);
+        default:
+            throw new SkenoraMcpError(-32601, `Method not found: ${method}`);
+    }
+}
+async function callTool(name, input, context, serverInfo, tools, scenePlans) {
+    if (!tools.some((tool) => tool.name === name)) {
+        throw new SkenoraMcpError(-32602, `Unknown tool: ${name}`);
+    }
+    try {
+        const result = await executeTool(name, input, context, scenePlans);
+        return complete({
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
+            isError: false,
+        }, serverInfo, context);
+    }
+    catch (error) {
+        return complete({
+            content: [
+                {
+                    type: "text",
+                    text: error instanceof Error ? error.message : "Tool call failed",
+                },
+            ],
+            isError: true,
+        }, serverInfo, context);
+    }
+}
+async function executeTool(name, rawInput, context, scenePlans) {
+    const input = optionalRecord(rawInput, "arguments");
+    switch (name) {
+        case "skenora_check_scene":
+            return checkSceneInput(input.input, {
+                ...(input.inputKind === undefined
+                    ? {}
+                    : {
+                        inputKind: requireEnum(input.inputKind, "inputKind", [
+                            "auto",
+                            "scene",
+                            "blueprint",
+                            "patch",
+                        ]),
+                    }),
+                compile: input.compile === undefined
+                    ? true
+                    : requireBoolean(input.compile, "compile"),
+            });
+        case "skenora_search_resources":
+            return searchToolingResources(requireString(input.query, "query"), {
+                ...(input.kind === undefined
+                    ? {}
+                    : {
+                        kind: requireEnum(input.kind, "kind", [
+                            "documentation",
+                            "example",
+                            "llms",
+                            "schema",
+                        ]),
+                    }),
+                ...(input.limit === undefined
+                    ? {}
+                    : { limit: requireInteger(input.limit, "limit", 1, 100) }),
+            });
+        case "skenora_get_resource": {
+            const resource = await getToolingResource(requireString(input.id, "id"));
+            return { ...resource.entry, text: resource.text };
+        }
+        case "skenora_list_examples":
+            return listInstalledSkenoraExamples(exampleOptions(input));
+        case "skenora_search_examples":
+            return searchInstalledSkenoraExamples(requireString(input.query, "query"), exampleOptions(input));
+        case "skenora_get_example":
+            return getInstalledSkenoraExample(requireString(input.id, "id"));
+        case "skenora_get_example_source":
+            return getInstalledSkenoraExampleSource(requireString(input.id, "id"), requireString(input.path, "path"));
+        case "skenora_doctor":
+            return createDoctorReport(input.probe);
+        case "skenora_inspect_scene": {
+            const options = compact({
+                cursor: optionalString(input.cursor, "cursor"),
+                limit: input.limit === undefined
+                    ? undefined
+                    : requireInteger(input.limit, "limit", 1, 500),
+            });
+            const access = await scenePlanAccess(scenePlans, name, "read", input, context);
+            return access.gateway.inspectScene(options);
+        }
+        case "skenora_search_scene_resources": {
+            const query = compact({
+                query: optionalString(input.query, "query"),
+                kind: input.kind === undefined
+                    ? undefined
+                    : requireEnum(input.kind, "kind", ASSET_KINDS),
+                tags: optionalStringArray(input.tags, "tags"),
+                providerTypes: optionalStringArray(input.providerTypes, "providerTypes"),
+                limit: input.limit === undefined
+                    ? undefined
+                    : requireInteger(input.limit, "limit", 1, 100),
+                cursor: optionalString(input.cursor, "cursor"),
+            });
+            const access = await scenePlanAccess(scenePlans, name, "read", input, context);
+            return access.gateway.searchResources(query);
+        }
+        case "skenora_validate_plan": {
+            requirePresent(input.plan, "plan");
+            const allowVariables = optionalBoolean(input.allowVariables, "allowVariables");
+            const access = await scenePlanAccess(scenePlans, name, "read", input, context);
+            return access.gateway.validatePlan(input.plan, {
+                allowVariables: allowVariables ?? false,
+            });
+        }
+        case "skenora_apply_plan": {
+            requirePresent(input.plan, "plan");
+            const expectedRevisionToken = revisionToken(input.expectedRevisionToken);
+            const idempotencyKey = requireToken(input.idempotencyKey, "idempotencyKey");
+            const operationId = optionalToken(input.operationId, "operationId");
+            const label = optionalString(input.label, "label");
+            const allowVariables = optionalBoolean(input.allowVariables, "allowVariables");
+            const writeIntent = Object.freeze({
+                planHash: createSkenoraMcpPlanHash(input.plan),
+                expectedRevisionToken,
+                idempotencyKey,
+                ...(operationId === undefined ? {} : { operationId }),
+                ...(label === undefined ? {} : { label }),
+                allowVariables: allowVariables ?? false,
+                modelLoadPolicy: "strict",
+            });
+            const access = await scenePlanAccess(scenePlans, name, "write", input, context, writeIntent);
+            const operationNamespace = createOperationNamespace(context, access.editorHandle);
+            return access.gateway.applyPlan(input.plan, {
+                expectedRevisionToken,
+                idempotencyKey,
+                modelLoadPolicy: "strict",
+                ...(operationId === undefined ? {} : { operationId }),
+                ...(label === undefined ? {} : { label }),
+                allowVariables: allowVariables ?? false,
+                operationNamespace,
+                ...(context.signal === undefined ? {} : { signal: context.signal }),
+            });
+        }
+        case "skenora_wait_operation": {
+            const operationId = requireToken(input.operationId, "operationId");
+            const access = await scenePlanAccess(scenePlans, name, "read", input, context);
+            const operation = access.gateway.waitOperation(operationId, {
+                operationNamespace: createOperationNamespace(context, access.editorHandle),
+            });
+            if (!operation) {
+                throw new Error(`Unknown ScenePlan operation: ${operationId}`);
+            }
+            return operation;
+        }
+        default:
+            throw new SkenoraMcpError(-32602, `Unknown tool: ${name}`);
+    }
+}
+async function scenePlanAccess(host, toolName, access, input, context, writeIntent) {
+    if (!host)
+        throw new Error("ScenePlan authoring is not configured");
+    if (context.signal?.aborted) {
+        throw new DOMException("The MCP request was cancelled", "AbortError");
+    }
+    if (access === "write" && writeIntent === undefined) {
+        throw new Error("ScenePlan writes require a bound write intent");
+    }
+    const editorHandle = requireToken(input.editorHandle, "editorHandle");
+    const approvalToken = optionalToken(input.approvalToken, "approvalToken");
+    try {
+        await host.authorize({
+            toolName,
+            access,
+            editorHandle,
+            ...(approvalToken === undefined ? {} : { approvalToken }),
+            ...(writeIntent === undefined ? {} : { writeIntent }),
+        }, context);
+    }
+    catch {
+        throw new Error("ScenePlan access denied");
+    }
+    if (context.signal?.aborted) {
+        throw new DOMException("The MCP request was cancelled", "AbortError");
+    }
+    let gateway;
+    try {
+        gateway = await host.resolve(editorHandle, context);
+    }
+    catch {
+        throw new Error("ScenePlan editor is unavailable");
+    }
+    if (!gateway)
+        throw new Error("Unknown or unavailable editorHandle");
+    return { editorHandle, gateway };
+}
+const READ_ONLY_TOOLS = Object.freeze([
+    {
+        name: "skenora_check_scene",
+        title: "Check Skenora scene input",
+        description: "Purely validate a native SceneDocument, SceneBlueprint, or ScenePatch. Does not mutate runtime or files.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["input"],
+            properties: {
+                input: {},
+                inputKind: { enum: ["auto", "scene", "blueprint", "patch"] },
+                compile: { type: "boolean" },
+            },
+        },
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "skenora_search_resources",
+        title: "Search installed Skenora resources",
+        description: "Search offline documentation, examples, schemas, and llms files.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["query"],
+            properties: {
+                query: { type: "string" },
+                kind: { enum: ["documentation", "example", "llms", "schema"] },
+                limit: { type: "integer", minimum: 1, maximum: 100 },
+            },
+        },
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "skenora_get_resource",
+        title: "Read an installed Skenora resource",
+        description: "Read one versioned offline resource by manifest ID.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id"],
+            properties: { id: { type: "string" } },
+        },
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "skenora_list_examples",
+        title: "List installed Skenora examples",
+        description: "List immutable, package-versioned public examples and their declared evidence without writing files.",
+        inputSchema: exampleSearchSchema(false),
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "skenora_search_examples",
+        title: "Search installed Skenora examples",
+        description: "Search immutable example manifests and text sources in the installed offline catalog.",
+        inputSchema: exampleSearchSchema(true),
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "skenora_get_example",
+        title: "Read an installed Skenora example",
+        description: "Read one detached example manifest and its verified source inventory.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id"],
+            properties: { id: { type: "string" } },
+        },
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "skenora_get_example_source",
+        title: "Read installed Skenora example source",
+        description: "Read one integrity-checked example source as UTF-8 text or base64. Never writes files.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "path"],
+            properties: { id: { type: "string" }, path: { type: "string" } },
+        },
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "skenora_doctor",
+        title: "Create Skenora doctor report",
+        description: "Report environment status. Healthy requires an unmodified browser Runtime probe with render/readback evidence.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: { probe: { type: "object" } },
+        },
+        annotations: { readOnlyHint: true },
+    },
+]);
+const SCENE_PLAN_TOOLS = Object.freeze([
+    {
+        name: "skenora_inspect_scene",
+        title: "Inspect an active Skenora editor",
+        description: "Return a compact scene summary, a paginated model-safe scene outline, opaque revision token, declared capabilities, and observed availability for one authorized editor handle.",
+        inputSchema: editorHandleSchema({
+            cursor: { type: "string" },
+            limit: { type: "integer", minimum: 1, maximum: 500 },
+        }),
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "skenora_search_scene_resources",
+        title: "Search resources for an active Skenora editor",
+        description: "Search the editor host's authorized resource providers and return model-visible descriptors without raw locators or credentials.",
+        inputSchema: editorHandleSchema({
+            query: { type: "string" },
+            kind: { enum: ASSET_KINDS },
+            tags: { type: "array", items: { type: "string" } },
+            providerTypes: { type: "array", items: { type: "string" } },
+            limit: { type: "integer", minimum: 1, maximum: 100 },
+            cursor: { type: "string" },
+        }),
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "skenora_validate_plan",
+        title: "Validate a Skenora SceneBlueprint or ScenePatch",
+        description: "Validate and compile a plan against the active editor revision, capabilities, limits, and discovered logical resources without mutation.",
+        inputSchema: editorHandleSchema({
+            plan: {},
+            allowVariables: { type: "boolean" },
+        }, ["plan"]),
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "skenora_apply_plan",
+        title: "Apply a Skenora SceneBlueprint or ScenePatch",
+        description: "Apply one authorized semantic plan with an opaque revision token, strict Runtime projection, and an idempotency key. The host may require approvalToken.",
+        inputSchema: editorHandleSchema({
+            plan: {},
+            expectedRevisionToken: revisionTokenSchema(),
+            idempotencyKey: { type: "string", minLength: 1 },
+            operationId: { type: "string", minLength: 1 },
+            label: { type: "string", minLength: 1 },
+            approvalToken: { type: "string", minLength: 1 },
+            allowVariables: { type: "boolean" },
+        }, ["plan", "expectedRevisionToken", "idempotencyKey"]),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+        },
+    },
+    {
+        name: "skenora_wait_operation",
+        title: "Wait for a Skenora ScenePlan operation",
+        description: "Wait for the terminal result of an operation owned by the selected editor handle.",
+        inputSchema: editorHandleSchema({ operationId: { type: "string", minLength: 1 } }, ["operationId"]),
+        annotations: { readOnlyHint: true },
+    },
+]);
+function editorHandleSchema(properties = {}, required = []) {
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: ["editorHandle", ...required],
+        properties: {
+            editorHandle: { type: "string", minLength: 1 },
+            ...properties,
+        },
+    };
+}
+function revisionTokenSchema() {
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: ["sceneId", "sessionEpoch", "revision", "documentHash"],
+        properties: {
+            sceneId: { type: "string", minLength: 1 },
+            sessionEpoch: { type: "string", minLength: 1 },
+            revision: { type: "integer", minimum: 0 },
+            documentHash: { type: "string", minLength: 1 },
+        },
+    };
+}
+function exampleSearchSchema(requireQuery) {
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: requireQuery ? ["query"] : [],
+        properties: {
+            ...(requireQuery ? { query: { type: "string" } } : {}),
+            mode: { enum: ["blueprint", "recipe", "renderer-lab"] },
+            tier: {
+                enum: [
+                    "foundation",
+                    "bounded-effects",
+                    "materials",
+                    "render-graph",
+                    "compute",
+                    "advanced-simulation",
+                ],
+            },
+            tag: { type: "string" },
+            limit: { type: "integer", minimum: 1, maximum: 100 },
+        },
+    };
+}
+function exampleOptions(input) {
+    return {
+        ...(input.mode === undefined
+            ? {}
+            : {
+                mode: requireEnum(input.mode, "mode", [
+                    "blueprint",
+                    "recipe",
+                    "renderer-lab",
+                ]),
+            }),
+        ...(input.tier === undefined
+            ? {}
+            : {
+                tier: requireEnum(input.tier, "tier", [
+                    "foundation",
+                    "bounded-effects",
+                    "materials",
+                    "render-graph",
+                    "compute",
+                    "advanced-simulation",
+                ]),
+            }),
+        ...(input.tag === undefined
+            ? {}
+            : { tag: requireString(input.tag, "tag") }),
+        ...(input.limit === undefined
+            ? {}
+            : { limit: requireInteger(input.limit, "limit", 1, 100) }),
+    };
+}
+function complete(result, serverInfo, context) {
+    if (!isModernContext(context)) {
+        const legacy = { ...result };
+        delete legacy.ttlMs;
+        delete legacy.cacheScope;
+        return legacy;
+    }
+    return {
+        resultType: "complete",
+        ...result,
+        _meta: { "io.modelcontextprotocol/serverInfo": serverInfo },
+    };
+}
+function isModernContext(context) {
+    return context.protocolVersion === SKENORA_MCP_PROTOCOL_VERSION;
+}
+function protocolIssue(code, message, data) {
+    return Object.freeze({
+        code,
+        message,
+        ...(data === undefined ? {} : { data }),
+    });
+}
+function parseJsonString(input) {
+    if (typeof input !== "string")
+        return input;
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return input;
+    }
+}
+function canonicalizeJson(value, ancestors = new Set()) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error("MCP plans must contain finite JSON numbers");
+        }
+        return Object.is(value, -0) ? 0 : value;
+    }
+    if (typeof value !== "object") {
+        throw new Error("MCP plans must be JSON-compatible values");
+    }
+    if (ancestors.has(value)) {
+        throw new Error("MCP plans must not contain circular references");
+    }
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) {
+            return value.map((item) => canonicalizeJson(item, ancestors));
+        }
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, child]) => [key, canonicalizeJson(child, ancestors)]));
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function createOperationNamespace(context, editorHandle) {
+    const subject = context.principal?.subject ?? `${context.transport}:local`;
+    return `mcp:${createHash("sha256")
+        .update(JSON.stringify([subject, editorHandle]))
+        .digest("hex")}`;
+}
+function negotiateLegacyVersion(requested) {
+    return requested === SKENORA_MCP_LEGACY_PROTOCOL_VERSION
+        ? requested
+        : SKENORA_MCP_LEGACY_PROTOCOL_VERSION;
+}
+function resourceUri(id) {
+    return `skenora://resources/${encodeURIComponent(id)}`;
+}
+function parseResourceUri(uri) {
+    const prefix = "skenora://resources/";
+    if (!uri.startsWith(prefix)) {
+        throw new SkenoraMcpError(-32602, "Invalid resource URI");
+    }
+    return decodeURIComponent(uri.slice(prefix.length));
+}
+function revisionToken(input) {
+    const value = requireRecord(input, "expectedRevisionToken");
+    return Object.freeze({
+        sceneId: requireToken(value.sceneId, "expectedRevisionToken.sceneId"),
+        sessionEpoch: requireToken(value.sessionEpoch, "expectedRevisionToken.sessionEpoch"),
+        revision: requireInteger(value.revision, "expectedRevisionToken.revision", 0, Number.MAX_SAFE_INTEGER),
+        documentHash: requireToken(value.documentHash, "expectedRevisionToken.documentHash"),
+    });
+}
+function optionalRecord(value, name) {
+    return value === undefined ? {} : requireRecord(value, name);
+}
+function requireRecord(value, name) {
+    if (!isRecord(value))
+        throw new Error(`${name} must be an object`);
+    return value;
+}
+function requireString(value, name) {
+    if (typeof value !== "string" || !value) {
+        throw new SkenoraMcpError(-32602, `${name} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalString(value, name) {
+    return value === undefined ? undefined : requireString(value, name);
+}
+function requireToken(value, name) {
+    const token = requireString(value, name);
+    if (token !== token.trim()) {
+        throw new Error(`${name} must not contain surrounding whitespace`);
+    }
+    return token;
+}
+function optionalToken(value, name) {
+    return value === undefined ? undefined : requireToken(value, name);
+}
+function requireBoolean(value, name) {
+    if (typeof value !== "boolean")
+        throw new Error(`${name} must be a boolean`);
+    return value;
+}
+function optionalBoolean(value, name) {
+    return value === undefined ? undefined : requireBoolean(value, name);
+}
+function requireInteger(value, name, minimum, maximum) {
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < minimum ||
+        value > maximum) {
+        throw new Error(`${name} must be an integer in ${minimum}..${maximum}`);
+    }
+    return value;
+}
+function requireEnum(value, name, allowed) {
+    if (typeof value !== "string" || !allowed.includes(value)) {
+        throw new Error(`${name} must be one of: ${allowed.join(", ")}`);
+    }
+    return value;
+}
+function optionalStringArray(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) ||
+        !value.every((item) => typeof item === "string")) {
+        throw new Error(`${name} must be an array of strings`);
+    }
+    return Object.freeze([...value]);
+}
+function requirePresent(value, name) {
+    if (value === undefined)
+        throw new Error(`${name} is required`);
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== undefined));
+}
+function isMcpRequest(value) {
+    if (!isRecord(value) ||
+        value.jsonrpc !== "2.0" ||
+        typeof value.method !== "string") {
+        return false;
+    }
+    if (value.id !== undefined &&
+        value.id !== null &&
+        typeof value.id !== "string" &&
+        typeof value.id !== "number") {
+        return false;
+    }
+    return value.params === undefined || isRecord(value.params);
+}
+function requestId(value) {
+    if (!isRecord(value))
+        return null;
+    const id = value.id;
+    return typeof id === "string" || typeof id === "number" || id === null
+        ? id
+        : null;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+class SkenoraMcpError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+//# sourceMappingURL=mcp.js.map