mountly-mcp 0.0.0 → 4.0.0

package/dist/chunk-4HC3OWAQ.js

@@ -0,0 +1,185 @@
+// src/json-render/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import {
+  EXTENSION_ID,
+  RESOURCE_MIME_TYPE,
+  getUiCapability,
+  registerAppResource,
+  registerAppTool
+} from "@modelcontextprotocol/ext-apps/server";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+var DEFAULT_RESOURCE_URI = "ui://json-render/view.html";
+var DEFAULT_TOOL_NAME = "render_ui";
+var LOOSE_SPEC_SCHEMA = z.looseObject({
+  root: z.string(),
+  elements: z.record(z.string(), z.unknown()),
+  state: z.unknown().optional()
+});
+function resolveInputSchema(options) {
+  if (options.inputSchema) return options.inputSchema;
+  const { catalog } = options;
+  if (typeof catalog.zodSchema !== "function") {
+    return { spec: LOOSE_SPEC_SCHEMA };
+  }
+  return { spec: z.union([catalog.zodSchema(), LOOSE_SPEC_SCHEMA]) };
+}
+function resolveDescription(options) {
+  if (options.description) return options.description;
+  const base = "Render an interactive UI. The `spec` argument must be a json-render spec conforming to the catalog.";
+  const prompt = typeof options.catalog.prompt === "function" ? options.catalog.prompt() : "";
+  return prompt ? `${base}
+
+${prompt}` : base;
+}
+function pickToolInputSpec(args) {
+  if (!args || typeof args !== "object") return args;
+  const record = args;
+  if (record.spec !== void 0) return record.spec;
+  return record;
+}
+function assertUiUri(uri) {
+  if (!uri.startsWith("ui://")) {
+    throw new Error(
+      `mountly-mcp/json-render: resourceUri must use 'ui://' scheme (received '${uri}')`
+    );
+  }
+}
+function registerJsonRenderResource(server, options) {
+  const uri = options.resourceUri ?? DEFAULT_RESOURCE_URI;
+  assertUiUri(uri);
+  const name = options.name ?? "json_render_ui";
+  const description = options.description ?? "Interactive json-render MCP App view.";
+  const registered = registerAppResource(
+    server,
+    name,
+    uri,
+    {
+      mimeType: RESOURCE_MIME_TYPE,
+      description,
+      _meta: {
+        ui: {
+          prefersBorder: true,
+          csp: { connectDomains: [], resourceDomains: [], frameDomains: [] }
+        }
+      }
+    },
+    async () => ({
+      contents: [
+        {
+          uri,
+          mimeType: RESOURCE_MIME_TYPE,
+          text: options.html,
+          _meta: {
+            ui: {
+              prefersBorder: true,
+              csp: { connectDomains: [], resourceDomains: [], frameDomains: [] }
+            }
+          }
+        }
+      ]
+    })
+  );
+  return { uri, remove: () => registered.remove() };
+}
+function registerJsonRenderTool(server, options) {
+  const name = options.name ?? DEFAULT_TOOL_NAME;
+  const resourceUri = options.resourceUri ?? DEFAULT_RESOURCE_URI;
+  assertUiUri(resourceUri);
+  const description = resolveDescription(options);
+  const visibility = options.visibility === void 0 ? ["model", "app"] : typeof options.visibility === "string" ? [options.visibility] : [...options.visibility];
+  const registered = registerAppTool(
+    server,
+    name,
+    {
+      title: options.title,
+      description,
+      inputSchema: resolveInputSchema(options),
+      _meta: {
+        ui: {
+          resourceUri,
+          visibility
+        }
+      }
+    },
+    (async (args) => {
+      const spec = pickToolInputSpec(args);
+      const validation = options.catalog.validate?.(spec);
+      const validSpec = validation?.success ? validation.data : spec;
+      return {
+        // Two shapes on purpose. `content[0].text` is the wire format
+        // `@json-render/mcp` emits and its iframe hook reads, so an app built
+        // against that package renders a Mountly server unchanged.
+        // `structuredContent` is what Mountly's own hosts and tests read.
+        content: [{ type: "text", text: JSON.stringify(validSpec) }],
+        structuredContent: { spec: validSpec }
+      };
+    })
+  );
+  return { name, remove: () => registered.remove() };
+}
+function createJsonRenderMcpApp(options) {
+  const configured = new McpServer(
+    { name: options.name, version: options.version },
+    { capabilities: { resources: {}, tools: {} } }
+  );
+  configured.server.registerCapabilities({
+    extensions: { [EXTENSION_ID]: { mimeTypes: [RESOURCE_MIME_TYPE] } }
+  });
+  const resourceUri = options.tool?.resourceUri ?? DEFAULT_RESOURCE_URI;
+  assertUiUri(resourceUri);
+  const toolName = options.tool?.name ?? DEFAULT_TOOL_NAME;
+  const resource = registerJsonRenderResource(configured, {
+    resourceUri,
+    html: options.html,
+    name: "json_render_ui"
+  });
+  const tool = registerJsonRenderTool(configured, {
+    catalog: options.catalog,
+    name: toolName,
+    title: options.tool?.title,
+    description: options.tool?.description,
+    resourceUri,
+    visibility: options.tool?.visibility,
+    inputSchema: options.tool?.inputSchema
+  });
+  const previousInitialized = configured.server.oninitialized;
+  const handleInitialized = () => {
+    previousInitialized?.();
+    const ui = getUiCapability(configured.server.getClientCapabilities());
+    if (ui?.mimeTypes?.includes(RESOURCE_MIME_TYPE)) return;
+    resource.remove();
+    tool.remove();
+  };
+  configured.server.oninitialized = handleInitialized;
+  return {
+    async connectInProcess(connectOptions) {
+      const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+      await configured.connect(serverTransport);
+      const client = new Client(
+        { name: `${options.name}-inprocess-client`, version: options.version },
+        connectOptions?.ui ?? true ? {
+          capabilities: {
+            extensions: { [EXTENSION_ID]: { mimeTypes: [RESOURCE_MIME_TYPE] } }
+          }
+        } : void 0
+      );
+      await client.connect(clientTransport);
+      return { client };
+    },
+    async listen(transport) {
+      await configured.connect(transport);
+    },
+    async close() {
+      await configured.close();
+    }
+  };
+}
+
+export {
+  registerJsonRenderResource,
+  registerJsonRenderTool,
+  createJsonRenderMcpApp
+};
+//# sourceMappingURL=chunk-4HC3OWAQ.js.map

package/dist/chunk-4HC3OWAQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/json-render/mcp.ts"],"sourcesContent":["import { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport { z } from \"zod\";\nimport {\n  EXTENSION_ID,\n  RESOURCE_MIME_TYPE,\n  getUiCapability,\n  registerAppResource,\n  registerAppTool,\n} from \"@modelcontextprotocol/ext-apps/server\";\nimport type { McpUiToolVisibility } from \"@modelcontextprotocol/ext-apps\";\nimport type { Catalog } from \"@json-render/core\";\nimport { Client } from \"@modelcontextprotocol/sdk/client/index.js\";\nimport { InMemoryTransport } from \"@modelcontextprotocol/sdk/inMemory.js\";\nimport type { Transport } from \"@modelcontextprotocol/sdk/shared/transport.js\";\nimport type { RunningMcpAppServer } from \"../server/index.js\";\n\nexport interface JsonRenderToolOptions {\n  /** MCP tool name. */\n  name?: string;\n  /** Human-readable tool title. */\n  title?: string;\n  /** Tool description for model selection. */\n  description?: string;\n  /** ui:// resource linked to this tool. */\n  resourceUri?: string;\n  /** Tool visibility in MCP Apps hosts. */\n  visibility?: McpUiToolVisibility | ReadonlyArray<McpUiToolVisibility>;\n  /** Optional explicit input schema override. */\n  inputSchema?: object;\n}\n\nexport interface RegisterJsonRenderResourceOptions {\n  resourceUri?: string;\n  name?: string;\n  description?: string;\n  html: string;\n}\n\nexport interface RegisterJsonRenderToolOptions {\n  catalog: Catalog;\n  name?: string;\n  title?: string;\n  description?: string;\n  resourceUri?: string;\n  visibility?: McpUiToolVisibility | ReadonlyArray<McpUiToolVisibility>;\n  inputSchema?: object;\n}\n\nexport interface CreateJsonRenderMcpAppOptions {\n  name: string;\n  version: string;\n  catalog: Catalog;\n  html: string;\n  tool?: JsonRenderToolOptions;\n}\n\nconst DEFAULT_RESOURCE_URI = \"ui://json-render/view.html\";\nconst DEFAULT_TOOL_NAME = \"render_ui\";\n\n/**\n * A spec shape loose enough to survive real model output. `@json-render/core`\n * generates a *strict* catalog schema: as of 0.20 `visible` is optional, but\n * `children` is still required on every element — the omission models make on\n * roughly a third of first attempts. Gating tool input on the strict schema\n * alone turns that into an SDK-level rejection before the handler can repair\n * anything. (`@json-render/mcp` passes the strict schema straight through and\n * inherits that failure.) Delete this branch once `children` is optional too.\n */\nconst LOOSE_SPEC_SCHEMA = z.looseObject({\n  root: z.string(),\n  elements: z.record(z.string(), z.unknown()),\n  state: z.unknown().optional(),\n});\n\n/**\n * The tool's input shape, matching `@json-render/mcp`: a single `spec`\n * argument typed by the catalog. Must be a Zod *raw shape* (a plain object of\n * Zod types) — handing the SDK a bare `ZodType` yields an empty\n * `{ type: \"object\", properties: {} }` schema, which tells the model nothing.\n */\nfunction resolveInputSchema(options: RegisterJsonRenderToolOptions): object {\n  if (options.inputSchema) return options.inputSchema;\n  const { catalog } = options;\n  if (typeof catalog.zodSchema !== \"function\") {\n    return { spec: LOOSE_SPEC_SCHEMA };\n  }\n  // The catalog branch documents the exact component vocabulary to the model;\n  // the loose branch keeps a near-miss spec from being rejected outright. The\n  // handler still validates against the catalog and reports what it repaired.\n  return { spec: z.union([catalog.zodSchema(), LOOSE_SPEC_SCHEMA]) };\n}\n\n/**\n * Catalogs carry their own model-facing prompt (component list, prop shapes,\n * authoring rules). Appending it is what makes the tool usable by a model —\n * a bare one-line description leaves it guessing at the component vocabulary.\n */\nfunction resolveDescription(options: RegisterJsonRenderToolOptions): string {\n  if (options.description) return options.description;\n  const base =\n    \"Render an interactive UI. The `spec` argument must be a json-render spec conforming to the catalog.\";\n  const prompt = typeof options.catalog.prompt === \"function\" ? options.catalog.prompt() : \"\";\n  return prompt ? `${base}\\n\\n${prompt}` : base;\n}\n\n/**\n * Unwrap the tool arguments. The declared shape is `{ spec }`, but a spec\n * passed at the top level is accepted too — hosts and hand-written clients do\n * both, and a spec is identifiable by its `root`/`elements` pair.\n */\nfunction pickToolInputSpec(args: unknown): unknown {\n  if (!args || typeof args !== \"object\") return args;\n  const record = args as Record<string, unknown>;\n  if (record.spec !== undefined) return record.spec;\n  return record;\n}\n\nfunction assertUiUri(uri: string): void {\n  if (!uri.startsWith(\"ui://\")) {\n    throw new Error(\n      `mountly-mcp/json-render: resourceUri must use 'ui://' scheme (received '${uri}')`,\n    );\n  }\n}\n\nexport function registerJsonRenderResource(\n  server: McpServer,\n  options: RegisterJsonRenderResourceOptions,\n): { uri: string; remove(): void } {\n  const uri = options.resourceUri ?? DEFAULT_RESOURCE_URI;\n  assertUiUri(uri);\n  const name = options.name ?? \"json_render_ui\";\n  const description = options.description ?? \"Interactive json-render MCP App view.\";\n  const registered = registerAppResource(\n    server,\n    name,\n    uri,\n    {\n      mimeType: RESOURCE_MIME_TYPE,\n      description,\n      _meta: {\n        ui: {\n          prefersBorder: true,\n          csp: { connectDomains: [], resourceDomains: [], frameDomains: [] },\n        },\n      },\n    },\n    async () => ({\n      contents: [\n        {\n          uri,\n          mimeType: RESOURCE_MIME_TYPE,\n          text: options.html,\n          _meta: {\n            ui: {\n              prefersBorder: true,\n              csp: { connectDomains: [], resourceDomains: [], frameDomains: [] },\n            },\n          },\n        },\n      ],\n    }),\n  );\n  return { uri, remove: () => registered.remove() };\n}\n\nexport function registerJsonRenderTool(\n  server: McpServer,\n  options: RegisterJsonRenderToolOptions,\n): { name: string; remove(): void } {\n  const name = options.name ?? DEFAULT_TOOL_NAME;\n  const resourceUri = options.resourceUri ?? DEFAULT_RESOURCE_URI;\n  assertUiUri(resourceUri);\n  const description = resolveDescription(options);\n  const visibility =\n    options.visibility === undefined\n      ? [\"model\", \"app\"]\n      : typeof options.visibility === \"string\"\n        ? [options.visibility]\n        : [...options.visibility];\n\n  const registered = registerAppTool(\n    server,\n    name,\n    {\n      title: options.title,\n      description,\n      inputSchema: resolveInputSchema(options) as never,\n      _meta: {\n        ui: {\n          resourceUri,\n          visibility,\n        },\n      },\n    } as never,\n    (async (args: unknown) => {\n      const spec = pickToolInputSpec(args);\n      // Repair-tolerant, like `@json-render/mcp`: a spec that fails catalog\n      // validation is still rendered rather than dropped — the renderer skips\n      // what it cannot resolve, and a partial UI beats a blank iframe.\n      const validation = options.catalog.validate?.(spec);\n      const validSpec = validation?.success ? validation.data : spec;\n      return {\n        // Two shapes on purpose. `content[0].text` is the wire format\n        // `@json-render/mcp` emits and its iframe hook reads, so an app built\n        // against that package renders a Mountly server unchanged.\n        // `structuredContent` is what Mountly's own hosts and tests read.\n        content: [{ type: \"text\", text: JSON.stringify(validSpec) }],\n        structuredContent: { spec: validSpec },\n      };\n    }) as never,\n  );\n  return { name, remove: () => registered.remove() };\n}\n\nexport function createJsonRenderMcpApp(\n  options: CreateJsonRenderMcpAppOptions,\n): RunningMcpAppServer {\n  const configured = new McpServer(\n    { name: options.name, version: options.version },\n    { capabilities: { resources: {}, tools: {} } },\n  );\n  configured.server.registerCapabilities({\n    extensions: { [EXTENSION_ID]: { mimeTypes: [RESOURCE_MIME_TYPE] } },\n  } as never);\n\n  const resourceUri = options.tool?.resourceUri ?? DEFAULT_RESOURCE_URI;\n  assertUiUri(resourceUri);\n  const toolName = options.tool?.name ?? DEFAULT_TOOL_NAME;\n  const resource = registerJsonRenderResource(configured, {\n    resourceUri,\n    html: options.html,\n    name: \"json_render_ui\",\n  });\n  const tool = registerJsonRenderTool(configured, {\n    catalog: options.catalog,\n    name: toolName,\n    title: options.tool?.title,\n    description: options.tool?.description,\n    resourceUri,\n    visibility: options.tool?.visibility,\n    inputSchema: options.tool?.inputSchema,\n  });\n  const previousInitialized = configured.server.oninitialized;\n  const handleInitialized = () => {\n    previousInitialized?.();\n    const ui = getUiCapability(configured.server.getClientCapabilities());\n    if (ui?.mimeTypes?.includes(RESOURCE_MIME_TYPE)) return;\n    resource.remove();\n    tool.remove();\n  };\n  configured.server.oninitialized = handleInitialized;\n\n  return {\n    async connectInProcess(connectOptions) {\n      const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();\n      await configured.connect(serverTransport);\n      const client = new Client(\n        { name: `${options.name}-inprocess-client`, version: options.version },\n        (connectOptions?.ui ?? true)\n          ? ({\n              capabilities: {\n                extensions: { [EXTENSION_ID]: { mimeTypes: [RESOURCE_MIME_TYPE] } },\n              },\n            } as never)\n          : undefined,\n      );\n      await client.connect(clientTransport);\n      return { client };\n    },\n    async listen(transport: Transport) {\n      await configured.connect(transport);\n    },\n    async close() {\n      await configured.close();\n    },\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-5EHNJCMF.js

@@ -0,0 +1,58 @@
+// src/json-render/spec-stream.ts
+import { createSpecStreamCompiler } from "@json-render/core";
+import {
+  compileSpecStream,
+  createJsonRenderTransform,
+  createSpecStreamCompiler as createSpecStreamCompiler2,
+  parseSpecStreamLine
+} from "@json-render/core";
+async function* compileTextStreamToSpecs(textStream) {
+  const compiler = createSpecStreamCompiler();
+  let buffer = "";
+  for await (const delta of textStream) {
+    buffer += delta;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const { result } = compiler.push(`${line}
+`);
+      yield { ...result };
+    }
+  }
+  if (buffer.trim()) {
+    const { result } = compiler.push(`${buffer}
+`);
+    yield { ...result };
+  }
+  return compiler.getResult();
+}
+function specToPatchLines(spec) {
+  const lines = [JSON.stringify({ op: "add", path: "/elements", value: {} })];
+  if (spec.state !== void 0) {
+    lines.push(JSON.stringify({ op: "add", path: "/state", value: spec.state }));
+  }
+  lines.push(JSON.stringify({ op: "add", path: "/root", value: spec.root }));
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [spec.root];
+  while (queue.length) {
+    const key = queue.shift();
+    if (seen.has(key) || !spec.elements[key]) continue;
+    seen.add(key);
+    const el = spec.elements[key];
+    const path = `/elements/${key.replace(/~/g, "~0").replace(/\//g, "~1")}`;
+    lines.push(JSON.stringify({ op: "add", path, value: el }));
+    for (const child of el.children ?? []) queue.push(child);
+  }
+  return lines;
+}
+
+export {
+  compileTextStreamToSpecs,
+  specToPatchLines,
+  compileSpecStream,
+  createJsonRenderTransform,
+  createSpecStreamCompiler2 as createSpecStreamCompiler,
+  parseSpecStreamLine
+};
+//# sourceMappingURL=chunk-5EHNJCMF.js.map

package/dist/chunk-5EHNJCMF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/json-render/spec-stream.ts"],"sourcesContent":["import { createSpecStreamCompiler } from \"@json-render/core\";\nimport type { Spec } from \"@json-render/core\";\n\n// json-render's streaming primitives, re-exported so the consumer side\n// (compile patches → progressive spec) is one import away.\nexport {\n  compileSpecStream,\n  createJsonRenderTransform,\n  createSpecStreamCompiler,\n  parseSpecStreamLine,\n} from \"@json-render/core\";\n\n/**\n * Drive json-render's stream compiler from a raw text stream of JSONL patches,\n * yielding the progressively-built spec after each complete line. This is the\n * live \"model token → patch → spec\" path, decoupled from any AI SDK so it can\n * drive a real model (see `streamSpec` in `mountly-mcp/json-render/server`), replay\n * a saved transcript, bridge a custom transport, or be unit-tested with a\n * hand-written stream. Buffers partial lines across chunk boundaries. The\n * generator's *return* value is the final compiled spec (before `autoFixSpec`).\n *\n * ```ts\n * for await (const partial of compileTextStreamToSpecs(result.textStream)) {\n *   render(partial); // each yield is one more element built\n * }\n * ```\n */\nexport async function* compileTextStreamToSpecs(\n  textStream: AsyncIterable<string>,\n): AsyncGenerator<Spec, Spec, void> {\n  const compiler = createSpecStreamCompiler<Spec>();\n  let buffer = \"\";\n  for await (const delta of textStream) {\n    buffer += delta;\n    const lines = buffer.split(\"\\n\");\n    // Keep the trailing partial line for the next chunk.\n    buffer = lines.pop() ?? \"\";\n    for (const line of lines) {\n      if (!line.trim()) continue;\n      const { result } = compiler.push(`${line}\\n`);\n      yield { ...result };\n    }\n  }\n  if (buffer.trim()) {\n    const { result } = compiler.push(`${buffer}\\n`);\n    yield { ...result };\n  }\n  return compiler.getResult();\n}\n\n/**\n * Turn a finished spec into json-render's streaming patch format — ordered\n * RFC-6902 JSONL lines (`/elements` scaffold, `/state`, `/root`, then each\n * element parent-before-child). Feed these to a `createSpecStreamCompiler` to\n * replay the build progressively, so a known spec streams in the same way a\n * live model would emit it. Pure spec work — no AI SDK dependency.\n */\nexport function specToPatchLines(spec: Spec): string[] {\n  const lines: string[] = [JSON.stringify({ op: \"add\", path: \"/elements\", value: {} })];\n  if (spec.state !== undefined) {\n    lines.push(JSON.stringify({ op: \"add\", path: \"/state\", value: spec.state }));\n  }\n  lines.push(JSON.stringify({ op: \"add\", path: \"/root\", value: spec.root }));\n\n  // Breadth-first from the root so parents stream before their children.\n  const seen = new Set<string>();\n  const queue = [spec.root];\n  while (queue.length) {\n    const key = queue.shift() as string;\n    if (seen.has(key) || !spec.elements[key]) continue;\n    seen.add(key);\n    const el = spec.elements[key];\n    const path = `/elements/${key.replace(/~/g, \"~0\").replace(/\\//g, \"~1\")}`;\n    lines.push(JSON.stringify({ op: \"add\", path, value: el }));\n    for (const child of el.children ?? []) queue.push(child);\n  }\n  return lines;\n}\n"],"mappings":";AAAA,SAAS,gCAAgC;AAKzC;AAAA,EACE;AAAA,EACA;AAAA,EACA,4BAAAA;AAAA,EACA;AAAA,OACK;AAiBP,gBAAuB,yBACrB,YACkC;AAClC,QAAM,WAAW,yBAA+B;AAChD,MAAI,SAAS;AACb,mBAAiB,SAAS,YAAY;AACpC,cAAU;AACV,UAAM,QAAQ,OAAO,MAAM,IAAI;AAE/B,aAAS,MAAM,IAAI,KAAK;AACxB,eAAW,QAAQ,OAAO;AACxB,UAAI,CAAC,KAAK,KAAK,EAAG;AAClB,YAAM,EAAE,OAAO,IAAI,SAAS,KAAK,GAAG,IAAI;AAAA,CAAI;AAC5C,YAAM,EAAE,GAAG,OAAO;AAAA,IACpB;AAAA,EACF;AACA,MAAI,OAAO,KAAK,GAAG;AACjB,UAAM,EAAE,OAAO,IAAI,SAAS,KAAK,GAAG,MAAM;AAAA,CAAI;AAC9C,UAAM,EAAE,GAAG,OAAO;AAAA,EACpB;AACA,SAAO,SAAS,UAAU;AAC5B;AASO,SAAS,iBAAiB,MAAsB;AACrD,QAAM,QAAkB,CAAC,KAAK,UAAU,EAAE,IAAI,OAAO,MAAM,aAAa,OAAO,CAAC,EAAE,CAAC,CAAC;AACpF,MAAI,KAAK,UAAU,QAAW;AAC5B,UAAM,KAAK,KAAK,UAAU,EAAE,IAAI,OAAO,MAAM,UAAU,OAAO,KAAK,MAAM,CAAC,CAAC;AAAA,EAC7E;AACA,QAAM,KAAK,KAAK,UAAU,EAAE,IAAI,OAAO,MAAM,SAAS,OAAO,KAAK,KAAK,CAAC,CAAC;AAGzE,QAAM,OAAO,oBAAI,IAAY;AAC7B,QAAM,QAAQ,CAAC,KAAK,IAAI;AACxB,SAAO,MAAM,QAAQ;AACnB,UAAM,MAAM,MAAM,MAAM;AACxB,QAAI,KAAK,IAAI,GAAG,KAAK,CAAC,KAAK,SAAS,GAAG,EAAG;AAC1C,SAAK,IAAI,GAAG;AACZ,UAAM,KAAK,KAAK,SAAS,GAAG;AAC5B,UAAM,OAAO,aAAa,IAAI,QAAQ,MAAM,IAAI,EAAE,QAAQ,OAAO,IAAI,CAAC;AACtE,UAAM,KAAK,KAAK,UAAU,EAAE,IAAI,OAAO,MAAM,OAAO,GAAG,CAAC,CAAC;AACzD,eAAW,SAAS,GAAG,YAAY,CAAC,EAAG,OAAM,KAAK,KAAK;AAAA,EACzD;AACA,SAAO;AACT;","names":["createSpecStreamCompiler"]}

package/dist/chunk-6QHKKFO3.js

@@ -0,0 +1,30 @@
+import {
+  escapeInlineScript,
+  serializeInlineScriptValue
+} from "./chunk-YJA4H6IB.js";
+
+// src/sandbox/index.ts
+function sandboxProxyHtml(hostOrigin, options = {}) {
+  const runtime = options.sandboxEntryScript ?? "";
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>mountly-mcp sandbox proxy</title>
+<style>
+  html, body { margin: 0; padding: 0; width: 100%; height: 100%; background: transparent; }
+  #inner { width: 100%; height: 100%; border: 0; background: white; }
+</style>
+</head>
+<body>
+<script>globalThis.__mountlyMcpSandbox__ = ${serializeInlineScriptValue({ hostOrigin })};</script>
+<script>${escapeInlineScript(runtime)}</script>
+</body>
+</html>
+`;
+}
+
+export {
+  sandboxProxyHtml
+};
+//# sourceMappingURL=chunk-6QHKKFO3.js.map

package/dist/chunk-6QHKKFO3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sandbox/index.ts"],"sourcesContent":["/**\n * Standalone sandbox proxy HTML for external hosts (Vercel AI SDK, etc.).\n *\n * The dev host already builds this internally, but external hosts need it too —\n * every host has to serve the proxy page on a separate origin (spec §8.4), and\n * hand-writing it is error-prone and drifts from the canonical CSP/permissions\n * logic in `sandbox-entry`.\n *\n * The proxy page is a thin HTML shell: it sets `__mountlyMcpSandbox__` with the\n * host origin and then runs the sandbox entry script (an IIFE). Hosts provide\n * the entry script themselves because loading strategy varies — some inline it,\n * others serve it as a separate `<script src>`.\n */\nimport { escapeInlineScript, serializeInlineScriptValue } from \"../html.js\";\n\nexport interface SandboxProxyHtmlOptions {\n  /**\n   * The compiled sandbox entry IIFE to inline. When omitted the page emits an\n   * empty `<script>` — the caller must arrange for the runtime to load another\n   * way (e.g. a `<script src>` tag).\n   */\n  sandboxEntryScript?: string;\n}\n\n/**\n * Return the complete sandbox proxy HTML document for the given host origin.\n *\n * This is the security boundary described in MCP Apps §8.4: it runs on an\n * origin distinct from the host, receives the view HTML over postMessage,\n * injects the CSP the sidecar declared, and relays messages.\n */\nexport function sandboxProxyHtml(\n  hostOrigin: string,\n  options: SandboxProxyHtmlOptions = {},\n): string {\n  const runtime = options.sandboxEntryScript ?? \"\";\n  return `<!doctype html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<title>mountly-mcp sandbox proxy</title>\n<style>\n  html, body { margin: 0; padding: 0; width: 100%; height: 100%; background: transparent; }\n  #inner { width: 100%; height: 100%; border: 0; background: white; }\n</style>\n</head>\n<body>\n<script>globalThis.__mountlyMcpSandbox__ = ${serializeInlineScriptValue({ hostOrigin })};</script>\n<script>${escapeInlineScript(runtime)}</script>\n</body>\n</html>\n`;\n}\n"],"mappings":";;;;;;AA+BO,SAAS,iBACd,YACA,UAAmC,CAAC,GAC5B;AACR,QAAM,UAAU,QAAQ,sBAAsB;AAC9C,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6CAWoC,2BAA2B,EAAE,WAAW,CAAC,CAAC;AAAA,UAC7E,mBAAmB,OAAO,CAAC;AAAA;AAAA;AAAA;AAIrC;","names":[]}

package/dist/chunk-AEVQKFXX.js

@@ -0,0 +1,119 @@
+import {
+  publishMcpView
+} from "./chunk-SADNMGP6.js";
+
+// src/react/context.ts
+import { createContext } from "react";
+var McpContext = createContext(null);
+McpContext.displayName = "McpContext";
+
+// src/react/hooks.ts
+import { useContext } from "react";
+import {
+  useAutoResize as useAutoResizeBase,
+  useDocumentTheme as useDocumentThemeBase,
+  useHostFonts as useHostFontsBase,
+  useHostStyleVariables as useHostStyleVariablesBase,
+  useHostStyles as useHostStylesBase
+} from "@modelcontextprotocol/ext-apps/react";
+function useEnsuredContext() {
+  const ctx = useContext(McpContext);
+  if (!ctx) {
+    throw new Error(
+      "mountly-mcp/react: useMcpApp/useToolInput/etc must be used inside a View wrapped with createMcpView()."
+    );
+  }
+  return ctx;
+}
+function useMcpApp() {
+  return useEnsuredContext().app;
+}
+function useToolInput() {
+  return useEnsuredContext().toolInput;
+}
+function useToolInputPartial() {
+  return useEnsuredContext().toolInputPartial;
+}
+function useToolResult() {
+  return useEnsuredContext().toolResult;
+}
+function useHostContext() {
+  return useEnsuredContext().hostContext;
+}
+function useDisplayMode() {
+  return useHostContext()?.displayMode;
+}
+function useRequestDisplayMode() {
+  const { app, hostContext } = useEnsuredContext();
+  return async (mode) => {
+    const available = hostContext?.availableDisplayModes;
+    if (available && !available.includes(mode)) return hostContext?.displayMode;
+    const result = await app.requestDisplayMode({ mode });
+    return result.mode;
+  };
+}
+function useHostStyleVariables() {
+  const { app, hostContext } = useEnsuredContext();
+  useHostStyleVariablesBase(app, hostContext ?? null);
+}
+function useHostFonts() {
+  const { app, hostContext } = useEnsuredContext();
+  useHostFontsBase(app, hostContext ?? null);
+}
+function useHostStyles() {
+  const { app, hostContext } = useEnsuredContext();
+  useHostStylesBase(app, hostContext ?? null);
+}
+function useDocumentTheme() {
+  return useDocumentThemeBase();
+}
+function useUpdateModelContext() {
+  const { app } = useEnsuredContext();
+  return async (params) => {
+    await app.updateModelContext(params);
+  };
+}
+function useAutoResize(...args) {
+  return useAutoResizeBase(...args);
+}
+
+// src/react/create-view.ts
+import { createElement } from "react";
+import { createWidget } from "mountly-react";
+function createMcpView(Component, options) {
+  const Wrapped = (props) => {
+    const { mcp, toolInput, toolInputPartial, toolResult, hostContext, ...rest } = props;
+    const value = {
+      app: mcp,
+      toolInput,
+      toolInputPartial,
+      toolResult,
+      hostContext
+    };
+    return createElement(
+      McpContext.Provider,
+      { value },
+      createElement(Component, rest)
+    );
+  };
+  return publishMcpView(createWidget(Wrapped, options));
+}
+
+export {
+  McpContext,
+  useMcpApp,
+  useToolInput,
+  useToolInputPartial,
+  useToolResult,
+  useHostContext,
+  useDisplayMode,
+  useRequestDisplayMode,
+  useHostStyleVariables,
+  useHostFonts,
+  useHostStyles,
+  useDocumentTheme,
+  useUpdateModelContext,
+  useAutoResize,
+  createMcpView
+};
+//# sourceMappingURL=chunk-AEVQKFXX.js.map

package/dist/chunk-AEVQKFXX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react/context.ts","../src/react/hooks.ts","../src/react/create-view.ts"],"sourcesContent":["import { createContext } from \"react\";\nimport type {\n  App,\n  McpUiHostContext,\n  McpUiToolInputNotification,\n  McpUiToolInputPartialNotification,\n  McpUiToolResultNotification,\n} from \"@modelcontextprotocol/ext-apps\";\n\n/**\n * Shared per-View context. The bridge populates this on each mount/update,\n * so consumers can synchronously read the initial values (no event subscription\n * race) and the React tree re-renders when the bridge calls `update()`.\n */\nexport interface McpContextValue {\n  app: App;\n  toolInput?: McpUiToolInputNotification[\"params\"];\n  toolInputPartial?: McpUiToolInputPartialNotification[\"params\"];\n  toolResult?: McpUiToolResultNotification[\"params\"];\n  hostContext?: McpUiHostContext;\n}\n\nexport const McpContext = createContext<McpContextValue | null>(null);\nMcpContext.displayName = \"McpContext\";\n","import { useContext } from \"react\";\nimport {\n  useAutoResize as useAutoResizeBase,\n  useDocumentTheme as useDocumentThemeBase,\n  useHostFonts as useHostFontsBase,\n  useHostStyleVariables as useHostStyleVariablesBase,\n  useHostStyles as useHostStylesBase,\n} from \"@modelcontextprotocol/ext-apps/react\";\nimport type {\n  App,\n  McpUiDisplayMode,\n  McpUiHostContext,\n  McpUiUpdateModelContextRequest,\n} from \"@modelcontextprotocol/ext-apps\";\nimport { McpContext } from \"./context.js\";\n\nfunction useEnsuredContext() {\n  const ctx = useContext(McpContext);\n  if (!ctx) {\n    throw new Error(\n      \"mountly-mcp/react: useMcpApp/useToolInput/etc must be used inside a View wrapped with createMcpView().\",\n    );\n  }\n  return ctx;\n}\n\n/** The view-side ext-apps App. Use this to call server tools, send messages, open links, etc. */\nexport function useMcpApp(): App {\n  return useEnsuredContext().app;\n}\n\n/** Complete notification params; read the tool arguments from `.arguments`. */\nexport function useToolInput<T = unknown>(): T | undefined {\n  return useEnsuredContext().toolInput as T | undefined;\n}\n\n/**\n * Streaming tool arguments (`ui/notifications/tool-input-partial`), present only\n * when the bridge runs with `streamToolInput`. Best-effort recovered JSON —\n * fields may be missing or change between notifications, so render loading\n * states from it, never critical operations. Undefined once the complete\n * {@link useToolInput} arrives.\n */\nexport function useToolInputPartial<T = unknown>(): Partial<T> | undefined {\n  return useEnsuredContext().toolInputPartial as Partial<T> | undefined;\n}\n\n/** Complete MCP tool result; structured data is available at `.structuredContent`. */\nexport function useToolResult<T = unknown>(): T | undefined {\n  return useEnsuredContext().toolResult as T | undefined;\n}\n\n/** Latest host context snapshot (theme, styles, displayMode, container dimensions, etc.). */\nexport function useHostContext(): McpUiHostContext | undefined {\n  return useEnsuredContext().hostContext;\n}\n\n/** Current display mode reported by the host. */\nexport function useDisplayMode(): McpUiDisplayMode | undefined {\n  return useHostContext()?.displayMode;\n}\n\n/**\n * Request a display mode change, resolving to the mode the host actually\n * applied — which the spec allows to differ from the one asked for.\n *\n * Modes the host didn't list in `availableDisplayModes` are never requested\n * (the spec requires views to check first); the current mode comes back\n * unchanged instead.\n */\nexport function useRequestDisplayMode(): (\n  mode: McpUiDisplayMode,\n) => Promise<McpUiDisplayMode | undefined> {\n  const { app, hostContext } = useEnsuredContext();\n  return async (mode) => {\n    const available = hostContext?.availableDisplayModes;\n    if (available && !available.includes(mode)) return hostContext?.displayMode;\n    const result = await app.requestDisplayMode({ mode });\n    return result.mode;\n  };\n}\n\n/** Apply host CSS variables (and react to host-context changes). */\nexport function useHostStyleVariables(): void {\n  const { app, hostContext } = useEnsuredContext();\n  useHostStyleVariablesBase(app, hostContext ?? null);\n}\n\n/** Apply host-provided `@font-face`/`@import` rules. */\nexport function useHostFonts(): void {\n  const { app, hostContext } = useEnsuredContext();\n  useHostFontsBase(app, hostContext ?? null);\n}\n\n/** One-shot helper: apply both host style variables and host fonts. */\nexport function useHostStyles(): void {\n  const { app, hostContext } = useEnsuredContext();\n  useHostStylesBase(app, hostContext ?? null);\n}\n\n/** Track the document theme reactively. */\nexport function useDocumentTheme() {\n  return useDocumentThemeBase();\n}\n\n/**\n * Return a function that calls `app.updateModelContext(params)`.\n *\n * Context updates are available to the model in future turns without\n * triggering an immediate response. Only the last update is kept.\n */\nexport function useUpdateModelContext(): (\n  params: McpUiUpdateModelContextRequest[\"params\"],\n) => Promise<void> {\n  const { app } = useEnsuredContext();\n  return async (params) => {\n    await app.updateModelContext(params);\n  };\n}\n\n/** Manually control auto-resize (rarely needed — the bridge calls setupSizeChangedNotifications by default). */\nexport function useAutoResize(...args: Parameters<typeof useAutoResizeBase>) {\n  return useAutoResizeBase(...args);\n}\n","/**\n * Wraps a React component as an MCP Apps View and publishes it for the bridge.\n * One call is enough — no manual global assign.\n */\nimport { createElement, type ComponentType } from \"react\";\nimport { createWidget } from \"mountly-react\";\nimport type { AdapterOptions } from \"mountly/adapter\";\nimport type { McpView, McpViewProps } from \"../types.js\";\nimport { publishMcpView } from \"../publish.js\";\nimport { McpContext, type McpContextValue } from \"./context.js\";\n\nexport function createMcpView<P extends object>(\n  Component: ComponentType<P>,\n  options?: AdapterOptions,\n): McpView {\n  const Wrapped = (props: P & McpViewProps) => {\n    const { mcp, toolInput, toolInputPartial, toolResult, hostContext, ...rest } =\n      props as McpViewProps & P;\n    const value: McpContextValue = {\n      app: mcp,\n      toolInput,\n      toolInputPartial,\n      toolResult,\n      hostContext,\n    };\n    return createElement(\n      McpContext.Provider,\n      { value },\n      createElement(Component as ComponentType, rest as P),\n    );\n  };\n  return publishMcpView(createWidget(Wrapped as ComponentType<P & McpViewProps>, options));\n}\n"],"mappings":";;;;;AAAA,SAAS,qBAAqB;AAsBvB,IAAM,aAAa,cAAsC,IAAI;AACpE,WAAW,cAAc;;;ACvBzB,SAAS,kBAAkB;AAC3B;AAAA,EACE,iBAAiB;AAAA,EACjB,oBAAoB;AAAA,EACpB,gBAAgB;AAAA,EAChB,yBAAyB;AAAA,EACzB,iBAAiB;AAAA,OACZ;AASP,SAAS,oBAAoB;AAC3B,QAAM,MAAM,WAAW,UAAU;AACjC,MAAI,CAAC,KAAK;AACR,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAGO,SAAS,YAAiB;AAC/B,SAAO,kBAAkB,EAAE;AAC7B;AAGO,SAAS,eAA2C;AACzD,SAAO,kBAAkB,EAAE;AAC7B;AASO,SAAS,sBAA2D;AACzE,SAAO,kBAAkB,EAAE;AAC7B;AAGO,SAAS,gBAA4C;AAC1D,SAAO,kBAAkB,EAAE;AAC7B;AAGO,SAAS,iBAA+C;AAC7D,SAAO,kBAAkB,EAAE;AAC7B;AAGO,SAAS,iBAA+C;AAC7D,SAAO,eAAe,GAAG;AAC3B;AAUO,SAAS,wBAE2B;AACzC,QAAM,EAAE,KAAK,YAAY,IAAI,kBAAkB;AAC/C,SAAO,OAAO,SAAS;AACrB,UAAM,YAAY,aAAa;AAC/B,QAAI,aAAa,CAAC,UAAU,SAAS,IAAI,EAAG,QAAO,aAAa;AAChE,UAAM,SAAS,MAAM,IAAI,mBAAmB,EAAE,KAAK,CAAC;AACpD,WAAO,OAAO;AAAA,EAChB;AACF;AAGO,SAAS,wBAA8B;AAC5C,QAAM,EAAE,KAAK,YAAY,IAAI,kBAAkB;AAC/C,4BAA0B,KAAK,eAAe,IAAI;AACpD;AAGO,SAAS,eAAqB;AACnC,QAAM,EAAE,KAAK,YAAY,IAAI,kBAAkB;AAC/C,mBAAiB,KAAK,eAAe,IAAI;AAC3C;AAGO,SAAS,gBAAsB;AACpC,QAAM,EAAE,KAAK,YAAY,IAAI,kBAAkB;AAC/C,oBAAkB,KAAK,eAAe,IAAI;AAC5C;AAGO,SAAS,mBAAmB;AACjC,SAAO,qBAAqB;AAC9B;AAQO,SAAS,wBAEG;AACjB,QAAM,EAAE,IAAI,IAAI,kBAAkB;AAClC,SAAO,OAAO,WAAW;AACvB,UAAM,IAAI,mBAAmB,MAAM;AAAA,EACrC;AACF;AAGO,SAAS,iBAAiB,MAA4C;AAC3E,SAAO,kBAAkB,GAAG,IAAI;AAClC;;;ACvHA,SAAS,qBAAyC;AAClD,SAAS,oBAAoB;AAMtB,SAAS,cACd,WACA,SACS;AACT,QAAM,UAAU,CAAC,UAA4B;AAC3C,UAAM,EAAE,KAAK,WAAW,kBAAkB,YAAY,aAAa,GAAG,KAAK,IACzE;AACF,UAAM,QAAyB;AAAA,MAC7B,KAAK;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,WAAO;AAAA,MACL,WAAW;AAAA,MACX,EAAE,MAAM;AAAA,MACR,cAAc,WAA4B,IAAS;AAAA,IACrD;AAAA,EACF;AACA,SAAO,eAAe,aAAa,SAA4C,OAAO,CAAC;AACzF;","names":[]}

package/dist/chunk-DKK26TRS.js

@@ -0,0 +1,199 @@
+// src/artifact/index.ts
+import { readFile, writeFile } from "fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "path";
+import {
+  McpUiDisplayModeSchema,
+  McpUiResourceMetaSchema,
+  RESOURCE_MIME_TYPE,
+  LATEST_PROTOCOL_VERSION
+} from "@modelcontextprotocol/ext-apps";
+var MCP_APP_MANIFEST_VERSION = 1;
+var MCP_APP_MANIFEST_FILE = "mountly-mcp.manifest.json";
+var McpAppConformanceError = class extends Error {
+  constructor(diagnostics) {
+    super(diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n"));
+    this.name = "McpAppConformanceError";
+    this.diagnostics = diagnostics;
+  }
+};
+function object(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function inspectMcpResourceDeclaration(value, source) {
+  const diagnostics = [];
+  const add = (code, message) => {
+    diagnostics.push({ severity: "error", code, message, source });
+  };
+  const candidate = object(value);
+  if (!candidate) {
+    add("artifact/not-object", "resource declaration must be an object");
+    return diagnostics;
+  }
+  if (candidate.protocolVersion !== LATEST_PROTOCOL_VERSION) {
+    add(
+      "artifact/protocol-version",
+      `sidecar protocolVersion must be '${LATEST_PROTOCOL_VERSION}' (received '${String(candidate.protocolVersion)}')`
+    );
+  }
+  if (typeof candidate.uri !== "string" || !candidate.uri.startsWith("ui://")) {
+    add("artifact/uri", `uri must use the 'ui://' scheme (received '${String(candidate.uri)}')`);
+  }
+  if (typeof candidate.name !== "string" || candidate.name.trim() === "") {
+    add("artifact/name", "name must be a non-empty string");
+  }
+  if (candidate.mimeType !== RESOURCE_MIME_TYPE) {
+    add(
+      "artifact/mime-type",
+      `sidecar mimeType must be '${RESOURCE_MIME_TYPE}' (received '${String(candidate.mimeType)}')`
+    );
+  }
+  if (typeof candidate.awaitToolResult !== "boolean") {
+    add("artifact/await-tool-result", "awaitToolResult must be a boolean");
+  }
+  if (!Array.isArray(candidate.displayModes) || candidate.displayModes.length === 0 || candidate.displayModes.some((mode) => !McpUiDisplayModeSchema.safeParse(mode).success)) {
+    add("artifact/display-modes", "displayModes must contain supported MCP Apps display modes");
+  }
+  const meta = object(candidate._meta);
+  const ui = meta && object(meta.ui);
+  if (!ui || !McpUiResourceMetaSchema.safeParse(ui).success) {
+    add("artifact/resource-meta", "_meta.ui must be valid MCP Apps resource metadata");
+  }
+  return diagnostics;
+}
+function parseMcpResourceDeclaration(value, source) {
+  const diagnostics = inspectMcpResourceDeclaration(value, source);
+  if (diagnostics.length > 0) throw new McpAppConformanceError(diagnostics);
+  return value;
+}
+async function readMcpAppArtifact(htmlPath, expectedUri) {
+  const absoluteHtmlPath = resolve(htmlPath);
+  const metaPath = `${absoluteHtmlPath}.meta.json`;
+  const [html, raw] = await Promise.all([
+    readFile(absoluteHtmlPath, "utf8"),
+    readFile(metaPath, "utf8")
+  ]);
+  if (!/^\s*<!doctype html>/i.test(html)) {
+    throw new McpAppConformanceError([
+      {
+        severity: "error",
+        code: "artifact/html5",
+        message: "View HTML must start with an HTML5 doctype",
+        source: absoluteHtmlPath
+      }
+    ]);
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(raw);
+  } catch (error) {
+    throw new McpAppConformanceError([
+      {
+        severity: "error",
+        code: "artifact/meta-json",
+        message: `metadata is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+        source: metaPath
+      }
+    ]);
+  }
+  const declaration = parseMcpResourceDeclaration(decoded, metaPath);
+  if (expectedUri !== void 0 && declaration.uri !== expectedUri) {
+    throw new McpAppConformanceError([
+      {
+        severity: "error",
+        code: "artifact/uri-mismatch",
+        message: `registration uri '${expectedUri}' does not match sidecar uri '${declaration.uri}'`,
+        source: metaPath
+      }
+    ]);
+  }
+  return {
+    name: declaration.name,
+    uri: declaration.uri,
+    htmlPath: absoluteHtmlPath,
+    metaPath,
+    declaration
+  };
+}
+function manifestPath(path, base) {
+  return isAbsolute(path) ? path : resolve(base, path);
+}
+async function writeMcpAppManifest(path, artifacts) {
+  const absolutePath = resolve(path);
+  const base = dirname(absolutePath);
+  const names = /* @__PURE__ */ new Set();
+  const uris = /* @__PURE__ */ new Set();
+  for (const artifact of artifacts) {
+    if (names.has(artifact.name))
+      throw new Error(`mountly-mcp: duplicate app name '${artifact.name}'`);
+    if (uris.has(artifact.uri)) throw new Error(`mountly-mcp: duplicate app uri '${artifact.uri}'`);
+    names.add(artifact.name);
+    uris.add(artifact.uri);
+  }
+  const manifest = {
+    formatVersion: MCP_APP_MANIFEST_VERSION,
+    protocolVersion: LATEST_PROTOCOL_VERSION,
+    apps: artifacts.map((artifact) => ({
+      name: artifact.name,
+      uri: artifact.uri,
+      html: relative(base, artifact.htmlPath),
+      meta: relative(base, artifact.metaPath),
+      declaration: artifact.declaration
+    }))
+  };
+  await writeFile(absolutePath, JSON.stringify(manifest, null, 2), "utf8");
+  return manifest;
+}
+async function readMcpAppManifest(path) {
+  const absolutePath = resolve(path);
+  const base = dirname(absolutePath);
+  let decoded;
+  try {
+    decoded = JSON.parse(await readFile(absolutePath, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `mountly-mcp: could not read manifest '${absolutePath}': ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const candidate = object(decoded);
+  if (candidate?.formatVersion !== MCP_APP_MANIFEST_VERSION || candidate.protocolVersion !== LATEST_PROTOCOL_VERSION || !Array.isArray(candidate.apps)) {
+    throw new Error(
+      `mountly-mcp: '${absolutePath}' is not a supported mountly-mcp manifest (expected formatVersion ${MCP_APP_MANIFEST_VERSION})`
+    );
+  }
+  const manifest = decoded;
+  const names = /* @__PURE__ */ new Set();
+  const uris = /* @__PURE__ */ new Set();
+  const artifacts = [];
+  for (const entry of manifest.apps) {
+    if (names.has(entry.name)) throw new Error(`mountly-mcp: duplicate app name '${entry.name}'`);
+    if (uris.has(entry.uri)) throw new Error(`mountly-mcp: duplicate app uri '${entry.uri}'`);
+    names.add(entry.name);
+    uris.add(entry.uri);
+    const declaration = parseMcpResourceDeclaration(entry.declaration, absolutePath);
+    if (declaration.name !== entry.name || declaration.uri !== entry.uri) {
+      throw new Error(
+        `mountly-mcp: manifest identity does not match declaration for '${entry.name}'`
+      );
+    }
+    artifacts.push({
+      name: entry.name,
+      uri: entry.uri,
+      htmlPath: manifestPath(entry.html, base),
+      metaPath: manifestPath(entry.meta, base),
+      declaration
+    });
+  }
+  return { path: absolutePath, manifest, artifacts };
+}
+
+export {
+  MCP_APP_MANIFEST_VERSION,
+  MCP_APP_MANIFEST_FILE,
+  McpAppConformanceError,
+  inspectMcpResourceDeclaration,
+  parseMcpResourceDeclaration,
+  readMcpAppArtifact,
+  writeMcpAppManifest,
+  readMcpAppManifest
+};
+//# sourceMappingURL=chunk-DKK26TRS.js.map