@plitzi/sdk-server 0.32.9 → 0.32.10

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @plitzi/sdk-server
 
+## 0.32.10
+
+### Patch Changes
+
+- v0.32.10
+- Updated dependencies
+  - @plitzi/plitzi-sdk@0.32.10
+  - @plitzi/sdk-schema@0.32.10
+  - @plitzi/sdk-shared@0.32.10
+
 ## 0.32.9
 
 ### Patch Changes

package/dist/core/services/mcp.js

@@ -2,15 +2,17 @@ import { handleMcp } from "../../modules/mcp/handler.js";
 import { createHttpPreviewClient } from "../../modules/mcp/previewClient.js";
 import { createHttpScreenshotClient } from "../../modules/mcp/screenshotClient.js";
 //#region src/core/services/mcp.ts
-var mcpPathOf = (path) => path ?? "/";
+var mcpPathOf = (config) => config.mcpAi?.path ?? config.mcp?.path ?? "/mcp";
 var serveMcp = (ctx) => {
-	const { previewClient, screenshot } = ctx.config;
-	const preview = previewClient ? createHttpPreviewClient(previewClient) : void 0;
-	const screenshotClient = screenshot ? createHttpScreenshotClient(screenshot) : void 0;
-	return handleMcp(ctx.raw, ctx.rawRes, ctx.req, ctx.config.adapters, preview, screenshotClient, ctx.config.mcpLogger, ctx.config.renderApp);
+	const { previewClient, screenshot, adapters, mcpLogger } = ctx.config;
+	return handleMcp(ctx.raw, ctx.rawRes, ctx.req, adapters, {
+		preview: previewClient ? createHttpPreviewClient(previewClient) : void 0,
+		screenshot: screenshot ? createHttpScreenshotClient(screenshot) : void 0,
+		logger: mcpLogger
+	});
 };
 var mcpStage = async (ctx) => {
-	if (!ctx.req.path.startsWith(mcpPathOf(ctx.config.mcp?.path))) return false;
+	if (!ctx.req.path.startsWith(mcpPathOf(ctx.config))) return false;
 	await serveMcp(ctx);
 	return true;
 };

package/dist/mcp.d.ts

@@ -0,0 +1,2 @@
+export * from './src/mcp.js'
+export {}

package/dist/mcp.js

@@ -0,0 +1,6 @@
+import { createMcpServer } from "./modules/mcp/server.js";
+import { handleMcp, readMcpBody, serveMcp } from "./modules/mcp/handler.js";
+import { createHttpPreviewClient } from "./modules/mcp/previewClient.js";
+import { createHttpScreenshotClient } from "./modules/mcp/screenshotClient.js";
+import { createMCPServer } from "./core/server/mcpServer.js";
+export { createHttpPreviewClient, createHttpScreenshotClient, createMCPServer, createMcpServer, handleMcp, readMcpBody, serveMcp };

package/dist/modules/mcp/apps/example/view.tsx

@@ -0,0 +1,70 @@
+/* eslint-disable react-refresh/only-export-components -- one bundled entry: components cannot move out. */
+import { useApp, useHostStyles } from '@modelcontextprotocol/ext-apps/react';
+import { useState } from 'react';
+import { createRoot } from 'react-dom/client';
+
+import type { McpUiHostContext } from '@modelcontextprotocol/ext-apps';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+
+/** The smallest MCP App view there is — copy this folder to start a new one. It shows the whole contract:
+ *  connect, receive the tool call and its result, call a tool back, and inherit the host's look. Everything it
+ *  imports is bundled into the page, so a view that stays this small stays a few KB. */
+
+// Host CSS variables: the chat's own palette and fonts, applied by useHostStyles below.
+const panel = {
+  padding: 16,
+  font: 'var(--font-sans, system-ui, sans-serif)',
+  color: 'var(--color-text-primary, #0f172a)',
+  background: 'var(--color-background-secondary, #f8fafc)',
+  borderRadius: 'var(--border-radius-md, 8px)'
+} as const;
+
+const textOf = (result: CallToolResult): string => result.content.find(entry => entry.type === 'text')?.text ?? '';
+
+const ExampleApp = () => {
+  const [result, setResult] = useState<CallToolResult | null>(null);
+  const [context, setContext] = useState<McpUiHostContext | undefined>(undefined);
+
+  // useApp creates the App, runs onAppCreated so every handler is in place BEFORE the handshake, and connects.
+  const { app, error } = useApp({
+    appInfo: { name: 'Plitzi Example', version: '1.0.0' },
+    capabilities: {},
+    onAppCreated: instance => {
+      // The result of the tool that opened this view. `ontoolinput` gives its arguments instead.
+      instance.ontoolresult = setResult;
+      instance.onhostcontextchanged = params => setContext(previous => ({ ...previous, ...params }));
+      instance.onteardown = () => ({});
+    }
+  });
+
+  useHostStyles(app, context);
+
+  if (error) {
+    return <div style={panel}>Could not connect to the host: {error.message}</div>;
+  }
+
+  if (!app) {
+    return null;
+  }
+
+  const insets = context?.safeAreaInsets;
+  const message = result ? textOf(result) : 'Waiting for the tool result…';
+
+  return (
+    <div style={{ ...panel, margin: `${insets?.top ?? 0}px ${insets?.right ?? 0}px` }}>
+      <p>{message}</p>
+      {/* An app can call the server's tools on its own — each call is a round-trip, so plan for latency. */}
+      <button
+        type="button"
+        onClick={() => void app.callServerTool({ name: 'plitzi_search', arguments: {} }).then(setResult)}
+      >
+        Call plitzi_search
+      </button>
+    </div>
+  );
+};
+
+const root = document.getElementById('app');
+if (root) {
+  createRoot(root).render(<ExampleApp />);
+}

package/dist/modules/mcp/apps/index.js

@@ -0,0 +1,12 @@
+import { registerApp } from "./shared/registerApp.js";
+import { RENDER_APP_URI, renderApp } from "./render/index.js";
+//#region src/modules/mcp/apps/index.ts
+/** Every MCP App this server serves. A new one is a folder beside `render/` (its definition + its view) and one
+*  line here — the tool that opens it points at its `uri` through `ui: { resourceUri }`. Start from `example/`,
+*  which is that same shape stripped to the minimum. */
+var apps = [renderApp];
+var registerApps = (server) => {
+	for (const app of apps) registerApp(server, app);
+};
+//#endregion
+export { RENDER_APP_URI, apps, registerApps };

package/dist/modules/mcp/apps/render/index.js

@@ -0,0 +1,16 @@
+import { require } from "../shared/resolve.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/modules/mcp/apps/render/index.ts
+var RENDER_APP_URI = "ui://plitzi/render.html";
+var HERE = path.dirname(fileURLToPath(import.meta.url));
+var renderApp = {
+	uri: RENDER_APP_URI,
+	name: "plitzi-render-app",
+	title: "Plitzi widget",
+	description: "Interactive view that renders a plitzi_render widget with the Plitzi SDK.",
+	entry: path.join(HERE, "view.tsx"),
+	styles: () => [path.join(path.dirname(require.resolve("@plitzi/plitzi-sdk")), "plitzi-sdk.css")]
+};
+//#endregion
+export { RENDER_APP_URI, renderApp };

package/dist/modules/mcp/apps/render/view.tsx

@@ -0,0 +1,108 @@
+/* eslint-disable react-refresh/only-export-components -- one bundled entry: components cannot move out. */
+import { useApp, useHostStyles } from '@modelcontextprotocol/ext-apps/react';
+import PlitziSdk from '@plitzi/plitzi-sdk';
+import { Component, useEffect, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+
+import type { McpUiHostContext } from '@modelcontextprotocol/ext-apps';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { OfflineDataRaw } from '@plitzi/sdk-shared';
+import type { ReactNode } from 'react';
+
+/** The view for plitzi_render: the entry the server bundles (React, the MCP Apps runtime and the Plitzi SDK
+ *  included) and inlines in the shared ui:// page shell — which is what lets it run in a sandbox that can fetch
+ *  nothing. It mounts on `#app`, the shell's root. */
+
+const panelStyle = { padding: 16, font: '13px/1.5 system-ui, sans-serif', color: '#b91c1c' } as const;
+
+// Every failure ends up here: an iframe left on its placeholder would hide the reason in the sandbox's console.
+const ErrorPanel = ({ title, details }: { title: string; details: string }) => (
+  <div style={panelStyle}>
+    <strong>{title}</strong>
+    <pre style={{ margin: '8px 0 0', whiteSpace: 'pre-wrap', color: '#7f1d1d', fontSize: 12 }}>{details}</pre>
+  </div>
+);
+
+class RenderBoundary extends Component<{ children: ReactNode }, { error?: Error }> {
+  state: { error?: Error } = {};
+
+  static getDerivedStateFromError(error: Error) {
+    return { error };
+  }
+
+  render() {
+    if (this.state.error) {
+      return <ErrorPanel title="Widget failed to render" details={this.state.error.message} />;
+    }
+
+    return this.props.children;
+  }
+}
+
+const RenderApp = () => {
+  const [result, setResult] = useState<CallToolResult | null>(null);
+  const [cancelled, setCancelled] = useState<string | undefined>(undefined);
+  const [context, setContext] = useState<McpUiHostContext | undefined>(undefined);
+
+  // useApp creates the App, runs onAppCreated so every handler is in place BEFORE the handshake, and connects.
+  const { app, error } = useApp({
+    appInfo: { name: 'Plitzi Widget', version: '1.0.0' },
+    capabilities: {},
+    onAppCreated: instance => {
+      instance.ontoolresult = setResult;
+      instance.ontoolcancelled = params => setCancelled(params.reason ?? 'The host cancelled the render.');
+      instance.onhostcontextchanged = params => setContext(previous => ({ ...previous, ...params }));
+      instance.onteardown = () => ({});
+    }
+  });
+
+  // The context the host sent in its initialize result predates any change notification.
+  useEffect(() => {
+    if (app) {
+      setContext(app.getHostContext());
+    }
+  }, [app]);
+
+  useHostStyles(app, context);
+
+  const failure = error?.message ?? cancelled;
+  if (failure) {
+    return <ErrorPanel title="Could not render the widget" details={failure} />;
+  }
+
+  // Still connecting, or connected and waiting for the result: the page's CSS placeholder covers both.
+  if (!result) {
+    return null;
+  }
+
+  // The payload rides in structuredContent, which the protocol types as unknown-valued; plitzi_render is the one
+  // guaranteeing the shape, and the SDK validates it again when it renders.
+  const offlineData = result.structuredContent?.offlineData as OfflineDataRaw | undefined;
+  if (!offlineData) {
+    // A failed render answers with its (already compact) reasons as the tool's JSON text summary.
+    const text = result.content.find(entry => entry.type === 'text');
+
+    return <ErrorPanel title="Render failed" details={text?.text ?? 'The tool returned no widget data.'} />;
+  }
+
+  const insets = context?.safeAreaInsets;
+
+  return (
+    <div
+      style={{
+        padding: `${insets?.top ?? 0}px ${insets?.right ?? 0}px ${insets?.bottom ?? 0}px ${insets?.left ?? 0}px`
+      }}
+    >
+      <RenderBoundary>
+        <PlitziSdk offlineData={offlineData} offlineMode environment="main" renderMode="raw" />
+      </RenderBoundary>
+    </div>
+  );
+};
+
+const root = document.getElementById('app');
+if (root) {
+  // The SDK styles its tree from this container class down.
+  root.className = 'plitzi-root-container';
+  createRoot(root).render(<RenderApp />);
+}

package/dist/modules/mcp/apps/shared/bundle.js

@@ -0,0 +1,22 @@
+import { require } from "./resolve.js";
+import { zodEnglishOnly } from "./zodEnglishOnly.js";
+import { build } from "esbuild";
+//#region src/modules/mcp/apps/shared/bundle.ts
+var bundle = async (entry) => {
+	return (await build({
+		entryPoints: [entry],
+		bundle: true,
+		write: false,
+		format: "iife",
+		platform: "browser",
+		target: "es2022",
+		jsx: "automatic",
+		minify: true,
+		alias: { "@plitzi/plitzi-sdk": require.resolve("@plitzi/plitzi-sdk") },
+		define: { "process.env.NODE_ENV": "\"production\"" },
+		plugins: [zodEnglishOnly],
+		logLevel: "silent"
+	})).outputFiles[0].text;
+};
+//#endregion
+export { bundle };

package/dist/modules/mcp/apps/shared/page.js

@@ -0,0 +1,23 @@
+import { bundle } from "./bundle.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
+import ejs from "ejs";
+//#region src/modules/mcp/apps/shared/page.ts
+var SHELL = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "shell.ejs");
+var template = () => ejs.compile(readFileSync(SHELL, "utf-8"), { filename: SHELL });
+var pages = /* @__PURE__ */ new Map();
+var page = (app) => {
+	let html = pages.get(app.uri);
+	if (!html) {
+		html = bundle(app.entry).then((script) => template()({
+			title: app.title,
+			app: script,
+			css: (app.styles?.() ?? []).map((file) => readFileSync(file, "utf-8")).join("\n")
+		}));
+		pages.set(app.uri, html);
+	}
+	return html;
+};
+//#endregion
+export { page };

package/dist/modules/mcp/apps/shared/registerApp.js

@@ -0,0 +1,27 @@
+import { page } from "./page.js";
+import { RESOURCE_MIME_TYPE, registerAppResource } from "@modelcontextprotocol/ext-apps/server";
+//#region src/modules/mcp/apps/shared/registerApp.ts
+var DEFAULT_CSP = {
+	resourceDomains: [
+		"*",
+		"data:",
+		"blob:"
+	],
+	connectDomains: ["*"]
+};
+/** Serves the app as a self-contained page: no import map, no asset mounts, no cross-origin fetches, so the
+*  strictest host sandbox runs it and no deployment has to serve anything extra. */
+var registerApp = (server, app) => {
+	const meta = { ui: { csp: app.csp ?? DEFAULT_CSP } };
+	registerAppResource(server, app.name, app.uri, {
+		description: app.description,
+		_meta: meta
+	}, async () => ({ contents: [{
+		uri: app.uri,
+		mimeType: RESOURCE_MIME_TYPE,
+		text: await page(app),
+		_meta: meta
+	}] }));
+};
+//#endregion
+export { registerApp };

package/dist/modules/mcp/apps/shared/resolve.js

@@ -0,0 +1,5 @@
+import { createRequire } from "node:module";
+//#region src/modules/mcp/apps/shared/resolve.ts
+var require = createRequire(import.meta.url);
+//#endregion
+export { require };

package/dist/modules/mcp/apps/shared/shell.ejs

@@ -0,0 +1,37 @@
+<%#
+  The page shell every MCP App shares. The host renders it in a sandboxed iframe on ITS OWN origin: the app and
+  its styles are inlined, so the page fetches NOTHING and runs under a deny-by-default sandbox CSP.
+-%>
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title><%= title %></title>
+
+    <style>
+      html,
+      body {
+        margin: 0;
+      }
+      /* The app renders nothing until the host pushes the tool result in. */
+      #app:empty::after {
+        content: 'Rendering…';
+        display: block;
+        padding: 16px;
+        font: 14px system-ui, sans-serif;
+        color: #64748b;
+      }
+    </style>
+    <style>
+<%- css %>
+    </style>
+  </head>
+  <body>
+    <div id="app"></div>
+
+    <script>
+<%- app %>
+    </script>
+  </body>
+</html>

package/dist/modules/mcp/apps/shared/zodEnglishOnly.js

@@ -0,0 +1,23 @@
+//#region src/modules/mcp/apps/shared/zodEnglishOnly.ts
+var NAMESPACE = "zod-locales-stub";
+var ZOD_PACKAGE = /node_modules[/\\]zod[/\\]/u;
+/** Drops zod's ~40 translations (194 KB): they are re-exported as a namespace, which no bundler can tree-shake.
+*  English survives because zod imports `locales/en.js` directly, not through this index. */
+var zodEnglishOnly = {
+	name: "zod-english-only",
+	setup(builder) {
+		builder.onResolve({ filter: /locales[/\\]index\.js$/ }, (args) => ZOD_PACKAGE.test(args.importer) ? {
+			path: args.path,
+			namespace: NAMESPACE
+		} : void 0);
+		builder.onLoad({
+			filter: /.*/,
+			namespace: NAMESPACE
+		}, () => ({
+			contents: "export {};",
+			loader: "js"
+		}));
+	}
+};
+//#endregion
+export { zodEnglishOnly };

package/dist/modules/mcp/handler.js

@@ -1,5 +1,5 @@
 import { createMcpServer } from "./server.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 //#region src/modules/mcp/handler.ts
 var readMcpBody = (req) => new Promise((resolve, reject) => {
 	let raw = "";
@@ -64,13 +64,10 @@ var serveMcp = async (raw, res, server) => {
 		await transport.close();
 	}
 };
-var handleMcp = (raw, res, req, adapters, preview, screenshot, logger, renderApp) => serveMcp(raw, res, createMcpServer({
+var handleMcp = (raw, res, req, adapters, options = {}) => serveMcp(raw, res, createMcpServer({
 	adapters,
 	getSpaceId: () => adapters.getSpaceId?.(req) ?? Promise.resolve(void 0),
-	preview,
-	screenshot,
-	logger,
-	renderApp
+	...options
 }));
 //#endregion
 export { createMcpServer, handleMcp, readMcpBody, serveMcp };

package/dist/modules/mcp/resources/register.js

@@ -4,7 +4,7 @@ import { resourceErrorMessage } from "./canonical.js";
 import { envelope, jsonContents } from "./envelope.js";
 import { readResource } from "./router.js";
 import { registerRenderResources } from "./renderGuide.js";
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp";
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 //#region src/modules/mcp/resources/register.ts
 /** Register every resource on the MCP server: fixed listings plus templated per-item reads. The space is
 *  loaded lazily via getSpace, so listing resources never touches the store — only reading one does. */

package/dist/modules/mcp/server.js

@@ -1,18 +1,19 @@
+import { registerApps } from "./apps/index.js";
 import { emptySpace, emptySpaceMessage, unauthorizedSpaceMessage } from "./helpers/space.js";
 import { serverInstructions } from "./helpers/guide.js";
 import { createMcpLog } from "./helpers/log.js";
 import { registerResources } from "./resources/register.js";
-import { registerRenderApp } from "./resources/renderApp.js";
 import { tools } from "./tools/index.js";
 import { isCallToolResult } from "../ai/toolkit.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
+import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 //#region src/modules/mcp/server.ts
 var MCP_ENV = "main";
 var asText = (data) => ({ content: [{
 	type: "text",
 	text: JSON.stringify(data)
 }] });
-var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger, renderApp }) => {
+var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger }) => {
 	const log = createMcpLog(logger);
 	let spaceIdPromise;
 	const requireSpaceId = () => spaceIdPromise ??= getSpaceId().then((id) => {
@@ -42,10 +43,10 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger, rend
 	const getSpace = () => spacePromise ??= loadSpace();
 	const server = new McpServer({
 		name: "plitzi-mcp",
-		version: "0.32.9"
+		version: "0.32.10"
 	}, { instructions: serverInstructions });
 	registerResources(server, getSpace, MCP_ENV, log);
-	if (renderApp) registerRenderApp(server, renderApp.sdkBase, renderApp.devMode ?? false);
+	registerApps(server);
 	const toolContext = async () => ({
 		space: await getSpace(),
 		env: MCP_ENV,
@@ -63,12 +64,7 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger, rend
 	});
 	for (const tool of tools) {
 		if (tool.requires === "screenshot" && !screenshot) continue;
-		server.registerTool(tool.name, {
-			title: tool.title,
-			description: tool.description,
-			inputSchema: tool.inputShape,
-			...tool.ui && renderApp ? { _meta: { ui: tool.ui } } : {}
-		}, async (args) => {
+		const run = async (args) => {
 			const start = performance.now();
 			try {
 				const result = await tool.execute(args, tool.spaceless ? spacelessContext() : await toolContext());
@@ -78,7 +74,20 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger, rend
 				log.toolCall(tool.name, args, performance.now() - start, error);
 				throw error;
 			}
-		});
+		};
+		const config = {
+			title: tool.title,
+			description: tool.description,
+			inputSchema: tool.inputShape
+		};
+		if (tool.ui) {
+			registerAppTool(server, tool.name, {
+				...config,
+				_meta: { ui: tool.ui }
+			}, run);
+			continue;
+		}
+		server.registerTool(tool.name, config, run);
 	}
 	return server;
 };

package/dist/modules/mcp/tools/apply/index.js

@@ -6,7 +6,7 @@ import { defineTool } from "../shared/tool.js";
 import { validateOperations } from "../shared/validator/index.js";
 import { auditResources } from "../shared/validator/audit.js";
 import { z } from "zod";
-import { validateSchema } from "@plitzi/sdk-schema";
+import { validateSchema } from "@plitzi/sdk-schema/helpers/schemaValidator";
 //#region src/modules/mcp/tools/apply/index.ts
 var applyShape = {
 	environment,

package/dist/modules/mcp/tools/render.js

@@ -1,12 +1,12 @@
+import { RENDER_APP_URI } from "../apps/render/index.js";
 import { emptySpace } from "../helpers/space.js";
-import { RENDER_APP_URI } from "../resources/renderApp.js";
 import { operations } from "./operations/index.js";
 import { applyOperations } from "./apply/dispatch.js";
 import { defineTool } from "./shared/tool.js";
 import { validateOperations } from "./shared/validator/index.js";
 import { auditResources } from "./shared/validator/audit.js";
-import { validateSchema } from "@plitzi/sdk-schema";
-import { generateCache } from "@plitzi/sdk-style";
+import { validateSchema } from "@plitzi/sdk-schema/helpers/schemaValidator";
+import { generateCache } from "@plitzi/sdk-style/StyleHelper";
 //#region src/modules/mcp/tools/render.ts
 var HOST_PAGE_REF = "render";
 var seedSpace = () => {

package/dist/modules/ssr/registerExternalPlugins.js

@@ -1,6 +1,6 @@
+import path from "node:path";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
-import path from "node:path";
 //#region src/modules/ssr/registerExternalPlugins.ts
 var MANIFEST_TTL_MS = 600 * 1e3;
 var manifestCache = /* @__PURE__ */ new Map();

package/dist/modules/ssr/template.js

@@ -1,6 +1,6 @@
 import path from "node:path";
-import fs from "node:fs";
 import { fileURLToPath } from "node:url";
+import fs from "node:fs";
 import ejs from "ejs";
 //#region src/modules/ssr/template.ts
 var __dirname = path.dirname(fileURLToPath(import.meta.url));

package/dist/plugins/compile.js

@@ -1,6 +1,6 @@
-import fs from "node:fs/promises";
 import path from "node:path";
 import esbuild from "esbuild";
+import fs from "node:fs/promises";
 //#region src/plugins/compile.ts
 var EXTERNAL = [
 	"react",

package/dist/plugins/copy.js

@@ -1,5 +1,5 @@
-import fs from "node:fs/promises";
 import path from "node:path";
+import fs from "node:fs/promises";
 //#region src/plugins/copy.ts
 var copyPlugin = async (src, destDir, filename) => {
 	const dest = path.join(destDir, filename);

package/dist/plugins/manager.js

@@ -1,8 +1,8 @@
 import { compilePlugin } from "./compile.js";
 import { copyPlugin } from "./copy.js";
 import { detectAction, isComponentSource } from "./detect.js";
-import fs from "node:fs/promises";
 import path from "node:path";
+import fs from "node:fs/promises";
 //#region src/plugins/manager.ts
 var META_FILE = "meta.json";
 var DEFAULT_TTL_MS = 10080 * 60 * 1e3;

package/dist/src/core/requestParser.d.ts

@@ -1,4 +1,7 @@
 import { SSRRequest } from '@plitzi/sdk-shared';
 import { IncomingMessage } from 'node:http';
 export declare const parseRequest: (raw: IncomingMessage) => SSRRequest;
+/** The public origin the request was addressed to (proxy-aware via x-forwarded-proto, port included), or an empty
+ *  string when the request carries no usable authority. */
+export declare const requestOrigin: (req: SSRRequest) => string;
 export declare const readRawBody: (raw: IncomingMessage) => Promise<string>;

package/dist/src/index.d.ts

@@ -8,7 +8,7 @@ export { createPreview, createMemoryDraftStore, PREVIEW_TOKEN_PARAM } from './mo
 export { apply, search, read, validate, applyShape, searchShape, readShape, validateShape, operation, tools } from './modules/mcp/tools';
 export type { JsonAdaptersConfig } from './adapters/jsonAdapters';
 export type { ResolvedServices } from './core/createServer';
-export type { McpServerContext, PreviewClient, PreviewRequestBody, PreviewResult, HttpPreviewClientConfig, ScreenshotClient, ScreenshotImage, ScreenshotResult, Viewport, HttpScreenshotClientConfig } from './modules/mcp';
+export type { McpServerContext, McpRequestOptions, PreviewClient, PreviewRequestBody, PreviewResult, HttpPreviewClientConfig, ScreenshotClient, ScreenshotImage, ScreenshotResult, Viewport, HttpScreenshotClientConfig } from './modules/mcp';
 export type { ApplyInput, SearchInput, SearchResponse, SearchHit, ReadInput, ReadResponse, ReadHit, ValidateInput, WriteResponse, WriteElement, Persisters, Operation, ToolDef, ToolContext } from './modules/mcp/tools';
 export type { Space } from './modules/mcp/helpers';
 export type { Env } from './modules/mcp/types';

package/dist/src/mcp.d.ts

@@ -0,0 +1,13 @@
+/** The MCP role's entry point: everything an MCP deployment wires, and nothing else.
+ *
+ *  Import it as `@plitzi/sdk-server/mcp`. The package root is a barrel over every service (SSR, RSC, plugins, the
+ *  AI engine…), so pulling `createMCPServer` from there makes the process load that whole graph — including the
+ *  React element packages its types come from — where this entry loads only the MCP server. */
+export { createMCPServer } from './core/server/mcpServer';
+export { createMcpServer, handleMcp, serveMcp, readMcpBody } from './modules/mcp/handler';
+export { createHttpPreviewClient } from './modules/mcp/previewClient';
+export { createHttpScreenshotClient } from './modules/mcp/screenshotClient';
+export type { McpRequestOptions } from './modules/mcp/handler';
+export type { McpServerContext } from './modules/mcp/server';
+export type { PreviewClient, ScreenshotClient } from './modules/mcp/types';
+export type { HealthIdentity } from './core/health';

package/dist/src/modules/mcp/apps/apps.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/mcp/apps/example/index.d.ts

@@ -0,0 +1,8 @@
+import { McpApp } from '../../types';
+/** The reference app: the smallest definition that works, kept as the template a new app is copied from.
+ *
+ *  It is deliberately NOT in the `apps` list — nothing renders it, since no tool points at it — so it costs a
+ *  real deployment nothing while the test suite still builds it, which is what keeps it from rotting. To turn it
+ *  into a real app: add it to `apps` in ../index.ts and give a tool `ui: { resourceUri: EXAMPLE_APP_URI }`. */
+export declare const EXAMPLE_APP_URI = "ui://plitzi/example.html";
+export declare const exampleApp: McpApp;

package/dist/src/modules/mcp/apps/example/view.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/mcp/apps/index.d.ts

@@ -0,0 +1,8 @@
+import { McpApp } from '../types';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Every MCP App this server serves. A new one is a folder beside `render/` (its definition + its view) and one
+ *  line here — the tool that opens it points at its `uri` through `ui: { resourceUri }`. Start from `example/`,
+ *  which is that same shape stripped to the minimum. */
+export declare const apps: McpApp[];
+export declare const registerApps: (server: McpServer) => void;
+export { RENDER_APP_URI } from './render';