agentic-mermaid 0.3.1 → 0.3.2

package/dist/{chunk-FGO3J7RA.js → chunk-NE6JBHSE.js}

@@ -1,11 +1,11 @@
 import {
   projectKnownRenderErrorDiagnostic,
   projectRenderErrorDiagnostic
-} from "./chunk-JJ7JRYZV.js";
+} from "./chunk-IVN6KP3W.js";
 import {
   renderMermaidPNG,
   renderMermaidPNGWithReceipt
-} from "./chunk-MBIR6S3B.js";
+} from "./chunk-YWKCUBQN.js";
 import {
   analyzeMermaid,
   analyzeMermaidSource,
@@ -31,7 +31,7 @@ import {
   renderMermaidSVGWithReceipt,
   verifyMermaid,
   verifySummary
-} from "./chunk-BSVM3VMO.js";
+} from "./chunk-GX7UT56Q.js";
 import {
   BUILTIN_FAMILY_METADATA,
   PACKAGE_VERSION,
@@ -71,13 +71,11 @@ import {
   styleSpecTypeScriptDeclaration,
   validateJsonConfigAdmission,
   validateSerializableRenderOptions
-} from "./chunk-XVY324NY.js";
+} from "./chunk-3D4EHVQ4.js";
 
 // src/mcp/server.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { createServer } from "http";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join2 } from "path";
 import { URL } from "url";
 
 // src/mcp/sandbox.ts
@@ -1214,7 +1212,7 @@ function preserveExactJsonRpcIds(body) {
         cursor++;
         while (/\s/.test(body[cursor] ?? "")) cursor++;
         const number = body.slice(cursor).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/)?.[0];
-        if (number && !isSafelyRoundTrippableInteger(number)) {
+        if (number && isIntegerNumberToken(number) && !isSafelyRoundTrippableInteger(number)) {
           let sentinel = `__agentic_mermaid_exact_id_${replacements.length}__`;
           while (body.includes(sentinel)) sentinel += "_";
           replacements.push({ sentinel, raw: number, start: cursor, end: cursor + number.length });
@@ -1233,6 +1231,10 @@ function preserveExactJsonRpcIds(body) {
   }
   return { body: protectedBody, ids: replacements.map(({ sentinel, raw }) => ({ sentinel, raw })) };
 }
+function isIntegerNumberToken(token) {
+  const value = Number(token);
+  return Number.isFinite(value) && Number.isInteger(value);
+}
 function isSafelyRoundTrippableInteger(token) {
   if (!/^-?(?:0|[1-9]\d*)$/.test(token)) return false;
   if (token === "-0") return false;
@@ -1259,8 +1261,338 @@ function stringifyJsonRpc(payload, exactIds = []) {
 function reply(id, result) {
   return { jsonrpc: "2.0", id, result };
 }
-function rpcError(id, code, message) {
-  return { jsonrpc: "2.0", id, error: { code, message } };
+function rpcError(id, code, message, data) {
+  return { jsonrpc: "2.0", id, error: data === void 0 ? { code, message } : { code, message, data } };
+}
+function toolResult(id, payload, isError) {
+  return reply(id, { content: [{ type: "text", text: JSON.stringify(payload) }], isError });
+}
+
+// src/mcp/protocol-versions.ts
+var LEGACY_PROTOCOL_VERSIONS = ["2024-11-05", "2025-03-26", "2025-06-18", "2025-11-25"];
+var MODERN_PROTOCOL_VERSIONS = ["2026-07-28"];
+var META_PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion";
+var META_CLIENT_INFO = "io.modelcontextprotocol/clientInfo";
+var META_CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+var META_LOG_LEVEL = "io.modelcontextprotocol/logLevel";
+var META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+var HEADER_MISMATCH = -32020;
+var UNSUPPORTED_PROTOCOL_VERSION = -32022;
+var TOOL_ERROR_VALIDATION_SINCE = "2025-11-25";
+function isModernProtocolVersion(version) {
+  return typeof version === "string" && MODERN_PROTOCOL_VERSIONS.includes(version);
+}
+function isLegacyProtocolVersion(version) {
+  return typeof version === "string" && LEGACY_PROTOCOL_VERSIONS.includes(version);
+}
+function usesToolErrorForInvalidArguments(version) {
+  return typeof version === "string" && version >= TOOL_ERROR_VALIDATION_SINCE;
+}
+function paramsMeta(req) {
+  const params = req.params;
+  if (!params || typeof params !== "object" || Array.isArray(params)) return void 0;
+  const meta = params._meta;
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)) return void 0;
+  return meta;
+}
+function requestMetaProtocolVersion(req) {
+  const claim = requestMetaProtocolVersionClaim(req);
+  const value = claim.present ? claim.value : void 0;
+  return typeof value === "string" ? value : void 0;
+}
+function requestMetaProtocolVersionClaim(req) {
+  const meta = paramsMeta(req);
+  if (!meta || !Object.prototype.hasOwnProperty.call(meta, META_PROTOCOL_VERSION)) return { present: false };
+  return { present: true, value: meta[META_PROTOCOL_VERSION] };
+}
+function mcpImplementationProblems(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return [`${path} is required and must be an object with name and version`];
+  }
+  const problems = [];
+  const info = value;
+  if (typeof info.name !== "string") problems.push(`${path}.name is required and must be a string`);
+  if (typeof info.version !== "string") problems.push(`${path}.version is required and must be a string`);
+  for (const key of ["title", "description", "websiteUrl"]) {
+    if (info[key] !== void 0 && typeof info[key] !== "string") {
+      problems.push(`${path}.${key} must be a string when present`);
+    }
+  }
+  if (info.icons !== void 0) {
+    if (!Array.isArray(info.icons)) {
+      problems.push(`${path}.icons must be an array when present`);
+    } else {
+      for (const [index, icon] of info.icons.entries()) {
+        if (!icon || typeof icon !== "object" || Array.isArray(icon)) {
+          problems.push(`${path}.icons[${index}] must be an object`);
+          continue;
+        }
+        const record = icon;
+        if (typeof record.src !== "string") problems.push(`${path}.icons[${index}].src is required and must be a string`);
+        if (record.mimeType !== void 0 && typeof record.mimeType !== "string") problems.push(`${path}.icons[${index}].mimeType must be a string when present`);
+        if (record.sizes !== void 0 && (!Array.isArray(record.sizes) || record.sizes.some((size) => typeof size !== "string"))) {
+          problems.push(`${path}.icons[${index}].sizes must be an array of strings when present`);
+        }
+        if (record.theme !== void 0 && record.theme !== "light" && record.theme !== "dark") {
+          problems.push(`${path}.icons[${index}].theme must be light or dark when present`);
+        }
+      }
+    }
+  }
+  return problems;
+}
+function mcpClientCapabilitiesProblems(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return [`${path} is required and must be an object (an empty object declares no optional capabilities)`];
+  }
+  const problems = [];
+  const record = value;
+  const objectMember = (key) => {
+    const member = record[key];
+    if (member === void 0) return void 0;
+    if (typeof member !== "object" || member === null || Array.isArray(member)) {
+      problems.push(`${path}.${key} must be an object when present`);
+      return void 0;
+    }
+    return member;
+  };
+  const roots = objectMember("roots");
+  if (roots?.listChanged !== void 0 && typeof roots.listChanged !== "boolean") {
+    problems.push(`${path}.roots.listChanged must be a boolean when present`);
+  }
+  const sampling = objectMember("sampling");
+  for (const key of ["context", "tools"]) {
+    const member = sampling?.[key];
+    if (member !== void 0 && (typeof member !== "object" || member === null || Array.isArray(member))) {
+      problems.push(`${path}.sampling.${key} must be an object when present`);
+    }
+  }
+  const elicitation = objectMember("elicitation");
+  for (const key of ["form", "url"]) {
+    const member = elicitation?.[key];
+    if (member !== void 0 && (typeof member !== "object" || member === null || Array.isArray(member))) {
+      problems.push(`${path}.elicitation.${key} must be an object when present`);
+    }
+  }
+  for (const key of ["experimental", "extensions"]) {
+    const entries = objectMember(key);
+    if (!entries) continue;
+    for (const [name, member] of Object.entries(entries)) {
+      if (key === "extensions" && !/^[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?\/.+/.test(name)) {
+        problems.push(`${path}.extensions.${name} must use a namespaced key with a prefix`);
+      }
+      if (typeof member !== "object" || member === null || Array.isArray(member)) {
+        problems.push(`${path}.${key}.${name} must be an object`);
+      }
+    }
+  }
+  return problems;
+}
+function modernRequestMetaProblems(req) {
+  const meta = paramsMeta(req);
+  if (!meta) return [`params._meta is required and must carry ${META_PROTOCOL_VERSION} and ${META_CLIENT_CAPABILITIES}`];
+  const problems = [];
+  const clientInfo = meta[META_CLIENT_INFO];
+  if (clientInfo !== void 0) {
+    problems.push(...mcpImplementationProblems(clientInfo, `params._meta.${META_CLIENT_INFO}`));
+  }
+  const logLevel = meta[META_LOG_LEVEL];
+  if (logLevel !== void 0 && (typeof logLevel !== "string" || !["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"].includes(logLevel))) {
+    problems.push(`params._meta.${META_LOG_LEVEL} must be a valid logging level when present`);
+  }
+  const capabilities = meta[META_CLIENT_CAPABILITIES];
+  problems.push(...mcpClientCapabilitiesProblems(capabilities, `params._meta.${META_CLIENT_CAPABILITIES}`));
+  return problems;
+}
+
+// src/mcp/admission.ts
+var admittedMcpMessage = /* @__PURE__ */ Symbol("AdmittedMcpMessage");
+function admitMcpHeaderVersion(headerVersion, supportedVersions) {
+  if (headerVersion === null || supportedVersions.includes(headerVersion)) return null;
+  return {
+    ok: false,
+    kind: "unsupported-version",
+    response: rpcError(
+      null,
+      UNSUPPORTED_PROTOCOL_VERSION,
+      `Unsupported protocol version: ${headerVersion}`,
+      { supported: [...supportedVersions], requested: headerVersion }
+    )
+  };
+}
+function responseId(raw, validId) {
+  const value = raw.id;
+  return validId && value !== void 0 ? value : null;
+}
+function rejection(kind, notification, response, protocol, requestedEra) {
+  return {
+    ok: false,
+    kind,
+    response: notification ? null : response,
+    ...protocol ? { protocol } : {},
+    ...requestedEra ? { requestedEra } : {}
+  };
+}
+function acceptance(request, id, notification, protocol) {
+  const base = { request, id, protocol, [admittedMcpMessage]: true };
+  return notification ? { ok: true, message: { ...base, notification: true } } : { ok: true, message: { ...base, notification: false } };
+}
+function admitMcpMessage(rawMessage, options) {
+  const raw = rawMessage;
+  const hasId = Boolean(raw && Object.prototype.hasOwnProperty.call(raw, "id"));
+  const rawId = raw?.id;
+  const validId = rawId === void 0 || typeof rawId === "string" || typeof rawId === "number" && Number.isSafeInteger(rawId);
+  const validEnvelope = Boolean(raw && !Array.isArray(raw) && raw.jsonrpc === "2.0" && typeof raw.method === "string" && validId);
+  if (!validEnvelope) {
+    return { ok: false, kind: "invalid-request", response: rpcError(null, -32600, "invalid JSON-RPC request") };
+  }
+  const request = rawMessage;
+  const id = responseId(raw, validId);
+  const notification = !hasId;
+  const versionClaim = requestMetaProtocolVersionClaim(request);
+  const declaredVersion = requestMetaProtocolVersion(request);
+  const requestedEra = versionClaim.present ? "modern" : "legacy";
+  const supportedVersions = options.protocolEra === "legacy" ? options.supportedVersions.filter(isLegacyProtocolVersion) : options.protocolEra === "modern" ? options.supportedVersions.filter(isModernProtocolVersion) : [...options.supportedVersions];
+  const effectiveTransportVersion = options.negotiatedVersion ?? options.headerVersion ?? void 0;
+  const provisionalProtocol = isModernProtocolVersion(declaredVersion) ? { era: "modern", version: declaredVersion, supportedVersions } : { era: "legacy", version: declaredVersion ?? effectiveTransportVersion, supportedVersions };
+  const headerAdmission = admitMcpHeaderVersion(options.headerVersion ?? null, supportedVersions);
+  if (headerAdmission) {
+    return { ...headerAdmission, protocol: provisionalProtocol, requestedEra };
+  }
+  if (versionClaim.present && typeof versionClaim.value !== "string") {
+    return rejection(
+      "invalid-modern-metadata",
+      notification,
+      rpcError(id, -32602, `Invalid params: params._meta.${META_PROTOCOL_VERSION} is required and must be a string`),
+      void 0,
+      "modern"
+    );
+  }
+  if (options.negotiatedVersion != null && !supportedVersions.includes(options.negotiatedVersion)) {
+    return rejection(
+      "unsupported-version",
+      notification,
+      rpcError(
+        id,
+        UNSUPPORTED_PROTOCOL_VERSION,
+        `Unsupported protocol version: ${options.negotiatedVersion}`,
+        { supported: [...supportedVersions], requested: options.negotiatedVersion }
+      ),
+      provisionalProtocol,
+      requestedEra
+    );
+  }
+  if (declaredVersion !== void 0 && options.headerVersion != null && declaredVersion !== options.headerVersion) {
+    return rejection(
+      "header-mismatch",
+      notification,
+      rpcError(
+        id,
+        HEADER_MISMATCH,
+        `Header mismatch: MCP-Protocol-Version header value '${options.headerVersion}' does not match body value '${declaredVersion}'`
+      ),
+      provisionalProtocol,
+      requestedEra
+    );
+  }
+  if (options.protocolEra !== void 0 && requestedEra !== options.protocolEra) {
+    const requested = declaredVersion ?? effectiveTransportVersion ?? "unversioned";
+    return rejection(
+      "unsupported-version",
+      notification,
+      rpcError(
+        id,
+        UNSUPPORTED_PROTOCOL_VERSION,
+        `Unsupported protocol version: ${requested}`,
+        { supported: [...supportedVersions], requested }
+      ),
+      provisionalProtocol,
+      requestedEra
+    );
+  }
+  if (requestedEra === "modern" && isLegacyProtocolVersion(declaredVersion) && (!options.requireModernVersionHeader || options.headerVersion != null)) {
+    const modernSupportedVersions = supportedVersions.filter(isModernProtocolVersion);
+    return rejection(
+      "unsupported-version",
+      notification,
+      rpcError(
+        id,
+        UNSUPPORTED_PROTOCOL_VERSION,
+        `Unsupported protocol version: ${declaredVersion}`,
+        { supported: modernSupportedVersions, requested: declaredVersion }
+      ),
+      provisionalProtocol,
+      requestedEra
+    );
+  }
+  if (declaredVersion !== void 0 && !supportedVersions.includes(declaredVersion)) {
+    return rejection(
+      "unsupported-version",
+      notification,
+      rpcError(
+        id,
+        UNSUPPORTED_PROTOCOL_VERSION,
+        `Unsupported protocol version: ${declaredVersion}`,
+        { supported: [...supportedVersions], requested: declaredVersion }
+      ),
+      provisionalProtocol,
+      requestedEra
+    );
+  }
+  const era = options.protocolEra ?? (isModernProtocolVersion(options.headerVersion) || isModernProtocolVersion(options.negotiatedVersion) ? "modern" : requestedEra);
+  if (era === "modern") {
+    if (!isModernProtocolVersion(declaredVersion)) {
+      const problem = `params._meta.${META_PROTOCOL_VERSION} is required and must match the MCP-Protocol-Version header (${options.headerVersion})`;
+      return rejection(
+        "header-mismatch",
+        notification,
+        rpcError(id, HEADER_MISMATCH, `Header mismatch: ${problem}`),
+        provisionalProtocol,
+        requestedEra
+      );
+    }
+    const protocol2 = { era: "modern", version: declaredVersion, supportedVersions };
+    if (options.requireModernVersionHeader && options.headerVersion == null) {
+      return rejection(
+        "header-mismatch",
+        notification,
+        rpcError(
+          id,
+          HEADER_MISMATCH,
+          `Header mismatch: MCP-Protocol-Version header is required for protocol version ${declaredVersion}`
+        ),
+        protocol2,
+        requestedEra
+      );
+    }
+    const transportProblem = options.modernTransportProblem?.(request) ?? null;
+    if (transportProblem !== null) {
+      return rejection(
+        "header-mismatch",
+        notification,
+        rpcError(id, HEADER_MISMATCH, `Header mismatch: ${transportProblem}`),
+        protocol2,
+        requestedEra
+      );
+    }
+    const metaProblems = modernRequestMetaProblems(request);
+    if (metaProblems.length > 0) {
+      return rejection(
+        "invalid-modern-metadata",
+        notification,
+        rpcError(id, -32602, `Invalid params: ${metaProblems.join("; ")}`),
+        protocol2,
+        requestedEra
+      );
+    }
+    return acceptance(request, id, notification, protocol2);
+  }
+  const protocol = {
+    era: "legacy",
+    version: declaredVersion ?? effectiveTransportVersion,
+    supportedVersions
+  };
+  return acceptance(request, id, notification, protocol);
 }
 
 // src/mcp/tool-surface.ts
@@ -1269,6 +1601,7 @@ function withClosedMcpInputSchema(tool) {
 }
 var MCP_SERVER_NAME = "agentic-mermaid-mcp";
 var MCP_SERVER_VERSION = PACKAGE_VERSION;
+var SERVER_CAPABILITIES = { tools: {}, prompts: {}, resources: {} };
 var PURE_COMPUTE_ANNOTATIONS = {
   readOnlyHint: true,
   destructiveHint: false,
@@ -1476,32 +1809,66 @@ function validateMcpToolArguments(tool, value) {
   const problems = validateSchemaValue(value, tool.inputSchema, tool.inputSchema, [], /* @__PURE__ */ new Set()).map((problem) => `${formatSchemaPath(problem.path)} ${problem.message}`);
   return limitJsonConfigDiagnostics(problems, "arguments");
 }
-async function dispatchMcpRequest(req, context, surface) {
-  const raw = req;
-  const hasId = Boolean(raw && Object.prototype.hasOwnProperty.call(raw, "id"));
-  const rawId = raw?.id;
-  const validId = rawId === void 0 || rawId === null || typeof rawId === "string" || typeof rawId === "number" && Number.isFinite(rawId);
-  const valid = Boolean(raw && raw.jsonrpc === "2.0" && typeof raw.method === "string" && validId);
-  const id = validId && rawId !== void 0 ? rawId : null;
-  if (!valid) return rpcError(null, -32600, "invalid JSON-RPC request");
-  const notification = !hasId;
+function surfaceSupportedVersions(surface, options = {}) {
+  const surfaceVersions = surface.supportedVersions ?? (typeof surface.protocolVersion === "string" ? [surface.protocolVersion] : []);
+  if (!options.supportedVersions) return surfaceVersions;
+  return surfaceVersions.filter((version) => options.supportedVersions.includes(version));
+}
+function discoverResult(surface, supportedVersions) {
+  return {
+    supportedVersions: supportedVersions.filter(isModernProtocolVersion),
+    capabilities: SERVER_CAPABILITIES,
+    instructions: surface.instructions
+  };
+}
+function initializeParamsProblems(params) {
+  if (!plainJsonObject(params)) return ["params is required and must be an object"];
+  const problems = [];
+  if (typeof params.protocolVersion !== "string") {
+    problems.push("params.protocolVersion is required and must be a string");
+  }
+  problems.push(...mcpClientCapabilitiesProblems(params.capabilities, "params.capabilities"));
+  problems.push(...mcpImplementationProblems(params.clientInfo, "params.clientInfo"));
+  return problems;
+}
+async function dispatchAdmittedMcpRequest(message, context, surface) {
+  const { request: req, id, notification, protocol } = message;
+  const { era, version, supportedVersions: servedVersions } = protocol;
   let response;
   switch (req.method) {
+    // initialize / notifications/initialized / ping are REMOVED in the modern
+    // era. Under a modern request they are simply unknown methods; a legacy
+    // request keeps the handshake it depends on.
     case "initialize": {
-      const protocolVersion = typeof surface.protocolVersion === "function" ? surface.protocolVersion(req.params) : surface.protocolVersion;
+      if (era === "modern") {
+        response = unknownMethod(id, req.method);
+        break;
+      }
+      const problems = initializeParamsProblems(req.params);
+      if (problems.length > 0) {
+        response = rpcError(id, -32602, `Invalid params: ${problems.join("; ")}`);
+        break;
+      }
+      const offered = req.params?.protocolVersion;
+      const legacyServedVersions = servedVersions.filter(isLegacyProtocolVersion);
+      const fallbackLegacyVersion = legacyServedVersions.at(-1) ?? (typeof surface.protocolVersion === "function" ? surface.protocolVersion(req.params) : surface.protocolVersion);
+      const protocolVersion = isLegacyProtocolVersion(offered) && legacyServedVersions.includes(offered) ? offered : fallbackLegacyVersion;
       response = reply(id, {
         protocolVersion,
         serverInfo: { name: surface.serverName ?? MCP_SERVER_NAME, version: MCP_SERVER_VERSION },
-        capabilities: { tools: {} },
+        capabilities: SERVER_CAPABILITIES,
         instructions: surface.instructions
       });
       break;
     }
     case "notifications/initialized":
-      response = null;
+      response = era === "modern" ? unknownMethod(id, req.method) : null;
       break;
     case "ping":
-      response = reply(id, {});
+      response = era === "modern" ? unknownMethod(id, req.method) : reply(id, {});
+      break;
+    case "server/discover":
+      response = era === "modern" ? reply(id, discoverResult(surface, servedVersions)) : unknownMethod(id, req.method);
       break;
     case "tools/list":
       response = reply(id, { tools: surface.tools });
@@ -1524,7 +1891,8 @@ async function dispatchMcpRequest(req, context, surface) {
       const args = req.params.arguments ?? {};
       const problems = validateMcpToolArguments(tool, args);
       if (problems.length > 0) {
-        response = rpcError(id, -32602, `Invalid arguments for ${name}: ${problems.join("; ")}`);
+        const message2 = `Invalid arguments for ${name}: ${problems.join("; ")}`;
+        response = usesToolErrorForInvalidArguments(version) ? toolResult(id, { ok: false, error: { code: "INVALID_ARGUMENTS", message: message2 } }, true) : rpcError(id, -32602, message2);
         break;
       }
       response = await surface.handleToolCall(id, { ...req.params, arguments: args }, context);
@@ -1537,9 +1905,31 @@ async function dispatchMcpRequest(req, context, surface) {
       response = reply(id, { resources: [] });
       break;
     default:
-      response = rpcError(id, -32601, `Method not found: ${req.method}`);
+      response = unknownMethod(id, req.method);
+  }
+  return notification ? null : decorateMcpResult(response, req.method, era, surface.serverName ?? MCP_SERVER_NAME);
+}
+var LIST_RESULT_TTL_MS = 3e5;
+var CACHEABLE_METHODS = /* @__PURE__ */ new Set(["server/discover", "tools/list", "prompts/list", "resources/list"]);
+function decorateMcpResult(response, method, era, serverName) {
+  if (era !== "modern" || !response || !plainJsonObject(response.result)) return response;
+  const existingMeta = plainJsonObject(response.result._meta) ? response.result._meta : {};
+  const result = {
+    resultType: "complete",
+    ...response.result,
+    _meta: {
+      ...existingMeta,
+      [META_SERVER_INFO]: { name: serverName, version: MCP_SERVER_VERSION }
+    }
+  };
+  if (CACHEABLE_METHODS.has(method)) {
+    result.ttlMs = LIST_RESULT_TTL_MS;
+    result.cacheScope = "public";
   }
-  return notification ? null : response;
+  return { ...response, result };
+}
+function unknownMethod(id, method) {
+  return rpcError(id, -32601, `Method not found: ${method}`);
 }
 function createExecuteTool(options) {
   const hostedNote = options.hosted ? `Hosted note: execute runs in an on-demand isolate and costs more than the direct
@@ -2656,6 +3046,7 @@ import {
   readFileSync,
   readdirSync,
   renameSync,
+  rmdirSync,
   unlinkSync,
   writeFileSync,
   writeSync
@@ -2669,7 +3060,12 @@ var DEFAULT_TTL_MS = 60 * 60 * 1e3;
 var MANIFEST_NAME = ".agentic-mermaid-artifacts-v1.json";
 var LOCK_NAME = ".agentic-mermaid-artifacts-v1.lock";
 var MAX_MANIFEST_BYTES = 1024 * 1024;
+var MAX_LOCK_BYTES = 4096;
 var MANAGED_NAME = /^[0-9a-z]+-[0-9a-f-]{36}\.[a-z0-9_-]+$/;
+var IMPLICIT_NAMESPACE = /^store-[1-9][0-9]*-[0-9a-f-]{36}$/;
+var LEGACY_IMPLICIT_NAMESPACE = /^agentic-mermaid-mcp-artifacts-[1-9][0-9]*-[0-9a-f-]{36}$/;
+var IMPLICIT_REAP_GRACE_MS = 3e4;
+var DEFAULT_ARTIFACT_ROOT = join(tmpdir(), "agentic-mermaid-mcp-artifacts");
 function positiveSafeInteger(value, field) {
   if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`artifact ${field} must be a positive safe integer`);
   return value;
@@ -2689,7 +3085,9 @@ var ArtifactStore = class {
   lockFd = -1;
   closed = false;
   constructor(opts = {}) {
-    this.dir = resolve(opts.dir ?? join(tmpdir(), "agentic-mermaid-mcp-artifacts"));
+    if (opts.dir !== void 0 && opts.namespaceRoot !== void 0) {
+      throw new Error("artifact dir and namespaceRoot are mutually exclusive");
+    }
     this.baseUrl = normalizeBaseUrl(opts.baseUrl);
     this.maxBytes = positiveSafeInteger(opts.maxBytes ?? DEFAULT_MAX_BYTES, "maxBytes");
     this.maxTotalBytes = positiveSafeInteger(opts.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES, "maxTotalBytes");
@@ -2697,7 +3095,23 @@ var ArtifactStore = class {
     this.ttlMs = positiveSafeInteger(opts.ttlMs ?? DEFAULT_TTL_MS, "ttlMs");
     if (this.maxBytes > this.maxTotalBytes) throw new Error("artifact maxBytes must not exceed maxTotalBytes");
     this.now = opts.now ?? (() => Date.now());
-    mkdirSync(this.dir, { recursive: true, mode: 448 });
+    if (opts.dir !== void 0) {
+      this.dir = resolve(opts.dir);
+      mkdirSync(this.dir, { recursive: true, mode: 448 });
+    } else {
+      const root = resolve(opts.namespaceRoot ?? DEFAULT_ARTIFACT_ROOT);
+      mkdirSync(root, { recursive: true, mode: 448 });
+      const rootStat = lstatSync(root);
+      if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+        throw new Error("artifact namespace root must be a real directory");
+      }
+      if (opts.namespaceRoot === void 0) {
+        reapImplicitArtifactNamespaces(resolve(tmpdir()), this.now(), LEGACY_IMPLICIT_NAMESPACE);
+      }
+      reapImplicitArtifactNamespaces(root, this.now());
+      this.dir = join(root, `store-${process.pid}-${randomUUID()}`);
+      mkdirSync(this.dir, { mode: 448 });
+    }
     this.manifestPath = join(this.dir, MANIFEST_NAME);
     this.lockPath = join(this.dir, LOCK_NAME);
     this.acquireOwnership();
@@ -2900,7 +3314,7 @@ var ArtifactStore = class {
     }
     let totalBytes = 0;
     for (const candidate of manifest.records) {
-      if (!candidate || typeof candidate !== "object" || typeof candidate.name !== "string" || !MANAGED_NAME.test(candidate.name) || typeof candidate.mimeType !== "string" || candidate.mimeType.length === 0 || !Number.isSafeInteger(candidate.bytes) || candidate.bytes < 0 || typeof candidate.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(candidate.sha256) || !Number.isSafeInteger(candidate.createdAt) || !Number.isSafeInteger(candidate.expiresAt) || candidate.expiresAt <= candidate.createdAt) {
+      if (!isManifestRecord(candidate)) {
         throw new Error("artifact manifest contains an invalid record");
       }
       const path = safePath(this.dir, candidate.name);
@@ -2941,6 +3355,113 @@ var ArtifactStore = class {
     if (persist) this.persistManifest();
   }
 };
+function reapImplicitArtifactNamespaces(root, now, namespacePattern = IMPLICIT_NAMESPACE) {
+  let entries;
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (!namespacePattern.test(name)) continue;
+    const dir = safePath(root, name);
+    try {
+      const namespace = lstatSync(dir);
+      if (!namespace.isDirectory() || namespace.isSymbolicLink()) continue;
+      if (now - namespace.mtimeMs < IMPLICIT_REAP_GRACE_MS) continue;
+      const lockPath = join(dir, LOCK_NAME);
+      if (existsSync(lockPath)) {
+        const lock = lstatSync(lockPath);
+        if (!lock.isFile() || lock.isSymbolicLink() || lock.size > MAX_LOCK_BYTES) continue;
+        const marker = JSON.parse(readFileSync(lockPath, "utf8"));
+        if (marker.host !== hostname() || !Number.isSafeInteger(marker.pid) || marker.pid <= 0) continue;
+        if (processIsAlive(marker.pid)) continue;
+        const current = lstatSync(lockPath);
+        if (current.dev !== lock.dev || current.ino !== lock.ino) continue;
+        unlinkSync(lockPath);
+      }
+      reapClosedNamespace(dir, now);
+    } catch {
+    }
+  }
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function reapClosedNamespace(dir, now) {
+  const manifestPath = join(dir, MANIFEST_NAME);
+  let records = [];
+  if (existsSync(manifestPath)) {
+    const stat = lstatSync(manifestPath);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_MANIFEST_BYTES) return;
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    if (manifest?.schemaVersion !== 1 || !Array.isArray(manifest.records) || manifest.records.some((record) => !isManifestRecord(record))) return;
+    records = manifest.records;
+  }
+  const live = [];
+  for (const record of records) {
+    const path = safePath(dir, record.name);
+    if (record.expiresAt <= now) {
+      try {
+        unlinkSync(path);
+      } catch {
+      }
+      continue;
+    }
+    try {
+      const file = lstatSync(path);
+      if (file.isFile() && !file.isSymbolicLink() && file.size === record.bytes) live.push(record);
+      else if (file.isFile() || file.isSymbolicLink()) unlinkSync(path);
+    } catch {
+    }
+  }
+  const liveNames = new Set(live.map((record) => record.name));
+  for (const name of readdirSync(dir)) {
+    if (!MANAGED_NAME.test(name) || liveNames.has(name)) continue;
+    const path = safePath(dir, name);
+    try {
+      const file = lstatSync(path);
+      if (file.isFile() || file.isSymbolicLink()) unlinkSync(path);
+    } catch {
+    }
+  }
+  if (live.length > 0) {
+    if (live.length !== records.length) persistManifestRecords(dir, live);
+    return;
+  }
+  try {
+    const manifest = lstatSync(manifestPath);
+    if (manifest.isFile() && !manifest.isSymbolicLink()) unlinkSync(manifestPath);
+  } catch {
+  }
+  try {
+    rmdirSync(dir);
+  } catch {
+  }
+}
+function persistManifestRecords(dir, records) {
+  const path = join(dir, MANIFEST_NAME);
+  const temp = join(dir, `.${MANIFEST_NAME}.${process.pid}.${randomUUID()}.tmp`);
+  try {
+    writeFileSync(temp, JSON.stringify({ schemaVersion: 1, records }), { mode: 384 });
+    renameSync(temp, path);
+  } finally {
+    try {
+      unlinkSync(temp);
+    } catch {
+    }
+  }
+}
+function isManifestRecord(candidate) {
+  if (!candidate || typeof candidate !== "object") return false;
+  const record = candidate;
+  return typeof record.name === "string" && MANAGED_NAME.test(record.name) && typeof record.mimeType === "string" && record.mimeType.length > 0 && Number.isSafeInteger(record.bytes) && record.bytes >= 0 && typeof record.sha256 === "string" && /^[a-f0-9]{64}$/.test(record.sha256) && Number.isSafeInteger(record.createdAt) && Number.isSafeInteger(record.expiresAt) && record.expiresAt > record.createdAt;
+}
 function createArtifactStore(opts = {}) {
   return new ArtifactStore(opts);
 }
@@ -2967,6 +3488,9 @@ function safePath(root, name) {
 
 // src/mcp/server.ts
 var PROTOCOL_VERSION = "2024-11-05";
+var STDIO_PROTOCOL_VERSIONS = ["2024-11-05", "2025-03-26", "2025-06-18", "2025-11-25", "2026-07-28"];
+var HTTP_SSE_PROTOCOL_VERSIONS = ["2024-11-05"];
+var HTTP_SSE_DISPATCH = { supportedVersions: HTTP_SSE_PROTOCOL_VERSIONS };
 var MAX_RPC_BODY_BYTES = 1024 * 1024;
 var MAX_SANDBOX_TIMEOUT_MS = 3e4;
 var MAX_SSE_SESSIONS = 32;
@@ -2989,12 +3513,21 @@ var MCP_NARROWERS = BUILTIN_FAMILY_METADATA.map((f) => f.narrower).join("/");
 var LOCAL_INSTRUCTIONS = `agentic-mermaid Code Mode server. Primary tool execute runs synchronous JavaScript against the typed mermaid.* SDK in a sandbox; async/await and Promise jobs are not supported. describe_sdk progressively discloses one family's version-matched mutation schema; call it before authoring unfamiliar ops. render_png and describe are narrow helpers. render_png can return base64, managed file paths, or managed URLs when the transport config provides an artifact store. There is no mutate tool on this server: structured edits go through the SDK's mermaid.mutate(...) inside execute; narrow via ${MCP_NARROWERS}. Every built-in renderable family ships a typed path when the body narrows; only opaque fallback bodies are source-level only. Layout is deterministic; there is no layout seed (the optional style seed only re-rolls ink of styled looks, never geometry).`;
 var LOCAL_SURFACE = {
   protocolVersion: PROTOCOL_VERSION,
+  supportedVersions: STDIO_PROTOCOL_VERSIONS,
   tools: LOCAL_TOOLS,
   instructions: LOCAL_INSTRUCTIONS,
   handleToolCall
 };
-async function handleRequest(req, context = {}) {
-  return dispatchMcpRequest(req, context, LOCAL_SURFACE);
+function admitLocalRequest(req, options = {}) {
+  return admitMcpMessage(req, {
+    supportedVersions: surfaceSupportedVersions(LOCAL_SURFACE, options),
+    negotiatedVersion: options.protocolVersion,
+    protocolEra: options.protocolEra
+  });
+}
+async function handleRequest(req, context = {}, options = {}) {
+  const admission = admitLocalRequest(req, options);
+  return admission.ok ? dispatchAdmittedMcpRequest(admission.message, context, LOCAL_SURFACE) : admission.response;
 }
 async function handleToolCall(id, params, context) {
   const p = params;
@@ -3075,7 +3608,7 @@ function artifactPayload(artifact, output) {
   return { ...base, path: artifact.path };
 }
 function getDefaultArtifactStore() {
-  defaultArtifactStore ??= createArtifactStore({ dir: join2(tmpdir2(), "agentic-mermaid-mcp-artifacts") });
+  defaultArtifactStore ??= createArtifactStore();
   if (!defaultArtifactStoreExitHook) {
     defaultArtifactStoreExitHook = true;
     process.once("exit", () => defaultArtifactStore?.close());
@@ -3088,6 +3621,112 @@ function warmUpPngRenderer() {
   } catch {
   }
 }
+function stdioCancellationTarget(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const request = value;
+  if (request.jsonrpc !== "2.0" || request.method !== "notifications/cancelled" || Object.prototype.hasOwnProperty.call(request, "id")) return void 0;
+  const params = request.params;
+  if (!params || typeof params !== "object" || Array.isArray(params)) return void 0;
+  const requestId = params.requestId;
+  return typeof requestId === "string" || typeof requestId === "number" && Number.isSafeInteger(requestId) ? requestId : void 0;
+}
+function stdioRequestId(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const request = value;
+  if (request.jsonrpc !== "2.0" || typeof request.method !== "string" || !Object.prototype.hasOwnProperty.call(request, "id")) return void 0;
+  const requestId = request.id;
+  return typeof requestId === "string" || typeof requestId === "number" && Number.isSafeInteger(requestId) ? requestId : void 0;
+}
+function stdioRequestKey(id) {
+  return `${typeof id}:${String(id)}`;
+}
+function createStdioMessageProcessor(context, write, dispatch = dispatchAdmittedMcpRequest) {
+  let negotiatedProtocolVersion = null;
+  let negotiatedEra = null;
+  let admissionGate = Promise.resolve();
+  const tasks = /* @__PURE__ */ new Set();
+  const inFlight = /* @__PURE__ */ new Map();
+  const register = (id, controller) => {
+    if (id === void 0) return;
+    const key = stdioRequestKey(id);
+    const controllers = inFlight.get(key) ?? /* @__PURE__ */ new Set();
+    controllers.add(controller);
+    inFlight.set(key, controllers);
+  };
+  const unregister = (id, controller) => {
+    if (id === void 0) return;
+    const key = stdioRequestKey(id);
+    const controllers = inFlight.get(key);
+    controllers?.delete(controller);
+    if (controllers?.size === 0) inFlight.delete(key);
+  };
+  const emit = (response, exactIds, signal) => {
+    if (response && !signal?.aborted) write(stringifyJsonRpc(response, exactIds) + "\n");
+  };
+  const accept = (line) => {
+    let exact;
+    let request;
+    try {
+      exact = preserveExactJsonRpcIds(line);
+      request = JSON.parse(exact.body);
+    } catch (cause) {
+      write(JSON.stringify(rpcError(null, -32700, `parse error: ${cause instanceof Error ? cause.message : String(cause)}`)) + "\n");
+      return;
+    }
+    const cancellationTarget = stdioCancellationTarget(request);
+    if (cancellationTarget !== void 0) {
+      for (const controller2 of inFlight.get(stdioRequestKey(cancellationTarget)) ?? []) controller2.abort();
+      return;
+    }
+    const requestId = stdioRequestId(request);
+    const controller = new AbortController();
+    register(requestId, controller);
+    const preparation = admissionGate.then(async () => {
+      const dispatchOptions = negotiatedEra === "legacy" ? { protocolEra: "legacy", protocolVersion: negotiatedProtocolVersion, supportedVersions: negotiatedProtocolVersion ? [negotiatedProtocolVersion] : void 0 } : negotiatedEra === "modern" ? { protocolEra: "modern", supportedVersions: STDIO_PROTOCOL_VERSIONS } : {};
+      const admission = admitLocalRequest(request, dispatchOptions);
+      if (admission.ok && negotiatedEra === null && request.method === "initialize") {
+        const response = controller.signal.aborted ? null : await dispatch(admission.message, { ...context, signal: controller.signal }, LOCAL_SURFACE);
+        if (!controller.signal.aborted && response?.result && typeof response.result === "object") {
+          const selected = response.result.protocolVersion;
+          if (typeof selected === "string" && STDIO_PROTOCOL_VERSIONS.includes(selected)) {
+            negotiatedProtocolVersion = selected;
+            negotiatedEra = "legacy";
+          }
+        }
+        emit(response, exact.ids, controller.signal);
+        return { handled: true, admission };
+      }
+      if (admission.ok && negotiatedEra === null && admission.message.protocol.era === "modern") {
+        negotiatedEra = "modern";
+      }
+      return { handled: false, admission };
+    });
+    admissionGate = preparation.then(() => void 0, () => void 0);
+    let task;
+    task = preparation.then(async (prepared) => {
+      if (prepared.handled) return;
+      const response = prepared.admission.ok ? controller.signal.aborted ? null : await dispatch(prepared.admission.message, { ...context, signal: controller.signal }, LOCAL_SURFACE) : prepared.admission.response;
+      emit(response, exact.ids, controller.signal);
+    }).catch((cause) => {
+      emit(
+        rpcError(requestId ?? null, -32603, `internal error: ${cause instanceof Error ? cause.message : String(cause)}`),
+        exact.ids,
+        controller.signal
+      );
+    }).finally(() => {
+      unregister(requestId, controller);
+      tasks.delete(task);
+    });
+    tasks.add(task);
+  };
+  return {
+    accept,
+    async drain() {
+      await admissionGate;
+      while (tasks.size > 0) await Promise.allSettled([...tasks]);
+    }
+  };
+}
 async function runStdio(options = {}) {
   warmUpPngRenderer();
   const artifactStore = createArtifactStore({
@@ -3097,22 +3736,20 @@ async function runStdio(options = {}) {
     maxArtifacts: options.maxArtifacts,
     ttlMs: options.artifactTtlMs
   });
+  const processor = createStdioMessageProcessor(
+    { artifactStore, maxSandboxTimeoutMs: options.maxSandboxTimeoutMs },
+    (line) => process.stdout.write(line)
+  );
   process.stdin.setEncoding("utf8");
   let buf = "";
-  process.stdin.on("data", async (chunk) => {
+  process.stdin.on("data", (chunk) => {
     buf += chunk;
     let nl;
     while ((nl = buf.indexOf("\n")) >= 0) {
       const line = buf.slice(0, nl).trim();
       buf = buf.slice(nl + 1);
       if (!line) continue;
-      try {
-        const exact = preserveExactJsonRpcIds(line);
-        const res = await handleRequest(JSON.parse(exact.body), { artifactStore, maxSandboxTimeoutMs: options.maxSandboxTimeoutMs });
-        if (res) process.stdout.write(stringifyJsonRpc(res, exact.ids) + "\n");
-      } catch (e) {
-        process.stdout.write(JSON.stringify(rpcError(null, -32700, `parse error: ${e.message}`)) + "\n");
-      }
+      processor.accept(line);
     }
   });
   try {
@@ -3120,6 +3757,7 @@ async function runStdio(options = {}) {
       process.stdin.on("end", () => resolve2());
       process.stdin.on("close", () => resolve2());
     });
+    await processor.drain();
   } finally {
     artifactStore.close();
   }
@@ -3288,7 +3926,7 @@ async function postSseMessage(req, res, sessions, context, maxBytes) {
   } catch {
     throw new HttpStatusError(400, "invalid JSON-RPC body");
   }
-  const response = await handleRequest(parsed, context);
+  const response = await handleRequest(parsed, context, HTTP_SSE_DISPATCH);
   if (response) {
     sse.write(`event: message
 data: ${stringifyJsonRpc(response, exact.ids)}
@@ -3308,7 +3946,7 @@ async function postRpc(req, res, context, maxBytes) {
   } catch {
     throw new HttpStatusError(400, "invalid JSON-RPC body");
   }
-  const response = await handleRequest(parsed, context);
+  const response = await handleRequest(parsed, context, HTTP_SSE_DISPATCH);
   if (response === null) {
     res.writeHead(202);
     res.end();
@@ -3482,4 +4120,4 @@ export {
   parseMcpCliOptions,
   runMcpCli
 };
-//# sourceMappingURL=chunk-FGO3J7RA.js.map
+//# sourceMappingURL=chunk-NE6JBHSE.js.map