@plitzi/sdk-server 0.32.10 → 0.32.11

package/CHANGELOG.md

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

package/dist/core/http/dispatcher.js

@@ -2,21 +2,57 @@ import { applySecurityHeaders } from "./securityHeaders.js";
 import { buildResponseHelpers } from "../../helpers/buildResponseHelpers.js";
 import { parseRequest } from "../requestParser.js";
 //#region src/core/http/dispatcher.ts
-var runPipeline = async (raw, rawRes, buildContext, stages) => {
+var safePath = (url) => {
+	const [path = "/", query] = url.split("?");
+	if (!query) return path;
+	const keys = [...new Set(new URLSearchParams(query).keys())];
+	return keys.length > 0 ? `${path}?${keys.join("&")}` : path;
+};
+var errorText = (error) => error instanceof Error ? error.message : String(error);
+var statusOf = (rawRes, res) => rawRes.headersSent ? rawRes.statusCode : res.status;
+var runPipeline = async (raw, rawRes, buildContext, stages, server) => {
+	const startedAt = Date.now();
 	const req = parseRequest(raw);
 	const res = buildResponseHelpers(rawRes, req.headers["accept-encoding"]);
-	if (req.path === "\0") {
-		res.setStatus(400);
-		res.end();
-		return;
-	}
 	const ctx = buildContext(raw, rawRes, req, res);
-	applySecurityHeaders(res, ctx.config, ctx.port);
-	for (const stage of stages) if (await stage(ctx)) return;
+	const logger = ctx.config.logger;
+	const logRequest = (error) => {
+		if (!logger) return;
+		const status = statusOf(rawRes, res);
+		logger({
+			kind: "request",
+			server,
+			method: req.method,
+			path: safePath(req.url),
+			...ctx.operation === void 0 ? {} : { operation: ctx.operation },
+			status,
+			durationMs: Date.now() - startedAt,
+			ok: !error && status < 400,
+			...error ? { error: errorText(error) } : {},
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	};
+	try {
+		if (req.path === "\0") {
+			res.setStatus(400);
+			res.end();
+			logRequest();
+			return;
+		}
+		applySecurityHeaders(res, ctx.config, ctx.port);
+		for (const stage of stages) if (await stage(ctx)) {
+			logRequest();
+			return;
+		}
+		logRequest();
+	} catch (error) {
+		logRequest(error);
+		throw error;
+	}
 };
 var makeHandler = (label, buildContext, stages) => {
 	return (raw, rawRes) => {
-		runPipeline(raw, rawRes, buildContext, stages).catch((err) => {
+		runPipeline(raw, rawRes, buildContext, stages, label).catch((err) => {
 			console.error(`[${label}] Unhandled error:`, err);
 			try {
 				if (!rawRes.headersSent) rawRes.writeHead(500, { "Content-Type": "text/plain" });

package/dist/core/services/mcp.js

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

package/dist/helpers/serverLog.js

@@ -0,0 +1,33 @@
+//#region src/helpers/serverLog.ts
+var outcomeOf = (event) => event.ok ? "ok" : `ERROR ${event.error ?? ""}`.trim();
+var renderRequest = (event) => {
+	const operation = event.operation ? ` ${event.operation}` : "";
+	const timing = `${Math.round(event.durationMs)}ms`;
+	return `[${event.server}] ${event.method} ${event.path}${operation} ${event.status} ${timing} ${outcomeOf(event)}`;
+};
+var renderTool = (event) => {
+	const args = event.argsSummary ? ` ${event.argsSummary}` : "";
+	return `[mcp] tools/call ${event.name}${args} ${Math.round(event.durationMs)}ms ${outcomeOf(event)}`;
+};
+var renderResource = (event) => `[mcp] resources/read ${event.name} ${Math.round(event.durationMs)}ms ${outcomeOf(event)}`;
+/** One line for any {@link ServerLogEvent}: an HTTP request reads as an access-log line
+*  (`[SSR] GET /pricing 200 12ms ok`), the MCP events as what happened inside one
+*  (`[mcp] tools/call plitzi_apply {operations:[3]} 41ms ok`). Events arrive PII-free — the dispatcher strips
+*  query values and collects no headers, cookies or IPs, and tool args are summarised by shape — so rendering is
+*  a pure format. */
+var renderLogEvent = (event) => {
+	switch (event.kind) {
+		case "request": return renderRequest(event);
+		case "tool": return renderTool(event);
+		case "resource": return renderResource(event);
+	}
+};
+/** A drop-in `SSRServerConfig.logger` for consumers that just want the log on the console. Consumers with their
+*  own logging stack should pass their own sink instead and read the structured event. */
+var consoleLogger = (event) => {
+	const line = renderLogEvent(event);
+	if (event.ok) console.log(line);
+	else console.error(line);
+};
+//#endregion
+export { consoleLogger, renderLogEvent };

package/dist/index.js

@@ -1,4 +1,5 @@
 import { buildAgentGuide } from "./modules/mcp/helpers/agentPrompt.js";
+import { consoleLogger, renderLogEvent } from "./helpers/serverLog.js";
 import { operation } from "./modules/mcp/tools/operations/index.js";
 import { apply, applyShape } from "./modules/mcp/tools/apply/index.js";
 import { read, readShape } from "./modules/mcp/tools/read.js";
@@ -19,4 +20,4 @@ import { createSSRServer } from "./core/server/ssrServer.js";
 import { createServer } from "./core/createServer.js";
 import { createJsonAdapters } from "./adapters/jsonAdapters.js";
 import AIEngine from "./modules/ai/AIEngine.js";
-export { AIEngine, PREVIEW_TOKEN_PARAM, apply, applyShape, bindTools, buildAgentGuide, buildHealthPayload, createHttpPreviewClient, createHttpScreenshotClient, createJsonAdapters, createMCPServer, createMcpServer, createMemoryDraftStore, createPreview, createSSRServer, createServer, getAllowedModes, handleMcp, isCallToolResult, isToolActive, operation, read, readMcpBody, readShape, registerHealthCheck, resolveServices, resolveToolHandler, search, searchShape, serveMcp, toolResponseErr, toolResponseFromResult, toolResponseOk, tools, validate, validateShape, zodToJsonSchema };
+export { AIEngine, PREVIEW_TOKEN_PARAM, apply, applyShape, bindTools, buildAgentGuide, buildHealthPayload, consoleLogger, createHttpPreviewClient, createHttpScreenshotClient, createJsonAdapters, createMCPServer, createMcpServer, createMemoryDraftStore, createPreview, createSSRServer, createServer, getAllowedModes, handleMcp, isCallToolResult, isToolActive, operation, read, readMcpBody, readShape, registerHealthCheck, renderLogEvent, resolveServices, resolveToolHandler, search, searchShape, serveMcp, toolResponseErr, toolResponseFromResult, toolResponseOk, tools, validate, validateShape, zodToJsonSchema };

package/dist/mcp.js

@@ -1,6 +1,7 @@
+import { consoleLogger, renderLogEvent } from "./helpers/serverLog.js";
 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 };
+export { consoleLogger, createHttpPreviewClient, createHttpScreenshotClient, createMCPServer, createMcpServer, handleMcp, readMcpBody, renderLogEvent, serveMcp };

package/dist/modules/mcp/handler.js

@@ -15,6 +15,10 @@ var readMcpBody = (req) => new Promise((resolve, reject) => {
 	});
 	req.on("error", reject);
 });
+var operationOf = (body) => {
+	if (Array.isArray(body)) return `batch(${body.length})`;
+	if (typeof body === "object" && body !== null && "method" in body && typeof body.method === "string") return body.method;
+};
 var serveMcp = async (raw, res, server) => {
 	res.setHeader("Access-Control-Allow-Origin", "*");
 	res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -60,6 +64,7 @@ var serveMcp = async (raw, res, server) => {
 			return;
 		}
 		await transport.handleRequest(raw, res, body);
+		return operationOf(body);
 	} finally {
 		await transport.close();
 	}

package/dist/modules/mcp/helpers/log.js

@@ -1,7 +1,19 @@
+import { renderLogEvent } from "../../../helpers/serverLog.js";
 //#region src/modules/mcp/helpers/log.ts
 var MCP_DEBUG = process.env.MCP_DEBUG === "1";
-var summarize = (value, max = 300) => {
-	if (value === void 0) return;
+var MCP_LOG_ARGS = process.env.MCP_LOG_ARGS === "1";
+var shapeOf = (value, depth = 0) => {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return `[${value.length}]`;
+	if (typeof value === "object") {
+		if (depth >= 2) return "{…}";
+		const entries = Object.entries(value);
+		const shown = entries.slice(0, 8).map(([key, item]) => `${key}:${shapeOf(item, depth + 1)}`);
+		return `{${[...shown, ...entries.length > shown.length ? ["…"] : []].join(",")}}`;
+	}
+	return typeof value;
+};
+var rawSummary = (value, max = 300) => {
 	let json;
 	try {
 		json = JSON.stringify(value);
@@ -10,25 +22,23 @@ var summarize = (value, max = 300) => {
 	}
 	return json.length > max ? `${json.slice(0, max)}…` : json;
 };
-var errorText = (error) => error instanceof Error ? error.message : String(error);
-var consoleRender = (event) => {
-	const kind = event.kind === "tool" ? "tools/call" : "resources/read";
-	const detail = event.argsSummary ? ` ${event.argsSummary}` : "";
-	const status = event.ok ? "ok" : `ERROR ${event.error ?? ""}`;
-	console.log(`[mcp] ${kind} ${event.name}${detail} ${Math.round(event.durationMs)}ms ${status}`);
+var summarize = (value) => {
+	if (value === void 0) return;
+	return MCP_LOG_ARGS ? rawSummary(value) : shapeOf(value);
 };
+var errorText = (error) => error instanceof Error ? error.message : String(error);
 var noop = () => void 0;
 var inertLog = {
 	toolCall: noop,
 	resourceRead: noop
 };
-/** Build the request-log sink for one MCP server. Dispatches structured events to the consumer's `logger` when
+/** Build the protocol-log sink for one MCP server. Dispatches structured events to the consumer's `logger` when
 *  provided; otherwise renders to the console when MCP_DEBUG=1; otherwise a no-op. */
 var createMcpLog = (logger) => {
 	if (!logger && !MCP_DEBUG) return inertLog;
 	const emit = (event) => {
 		if (logger) logger(event);
-		else consoleRender(event);
+		else console.log(renderLogEvent(event));
 	};
 	return {
 		toolCall: (name, args, ms, error) => emit({

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

@@ -21,19 +21,25 @@ var registerResources = (server, getSpace, env, log) => {
 			throw error;
 		}
 	};
+	const emitStatic = (uri, read) => {
+		const start = performance.now();
+		const result = read();
+		log.resourceRead(uri, performance.now() - start);
+		return result;
+	};
 	server.registerResource("Guide", "plitzi://guide", {
 		description: "How to read and write this space with mcp-ai",
 		mimeType: "text/markdown"
-	}, () => ({ contents: [{
+	}, () => emitStatic("plitzi://guide", () => ({ contents: [{
 		uri: "plitzi://guide",
 		mimeType: "text/markdown",
 		text: guideText
-	}] }));
+	}] })));
 	server.registerResource("CSS properties", "plitzi://css-properties", {
 		description: "Valid kebab-case CSS property keys",
 		mimeType: "application/json"
-	}, () => jsonContents("plitzi://css-properties", envelope(cssProperties)));
-	registerRenderResources(server);
+	}, () => emitStatic("plitzi://css-properties", () => jsonContents("plitzi://css-properties", envelope(cssProperties))));
+	registerRenderResources(server, log);
 	const fixed = [
 		[
 			"Primer",

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

@@ -168,19 +168,29 @@ connects that source to a descendant's field.
 The tool returns \`rendered: false\` with \`errors: [{ path, message, hint }]\`. Read the hint, fix that one op, and
 retry — you never lose the rest of the batch.
 `;
-var registerRenderResources = (server) => {
+var registerRenderResources = (server, log) => {
 	server.registerResource("Render guide", RENDER_GUIDE_URI, {
 		description: "How to author a plitzi_render widget: operations, element types, styling, examples.",
 		mimeType: "text/markdown"
-	}, () => ({ contents: [{
-		uri: RENDER_GUIDE_URI,
-		mimeType: "text/markdown",
-		text: renderGuideText
-	}] }));
+	}, () => {
+		const start = performance.now();
+		const contents = { contents: [{
+			uri: RENDER_GUIDE_URI,
+			mimeType: "text/markdown",
+			text: renderGuideText
+		}] };
+		log.resourceRead(RENDER_GUIDE_URI, performance.now() - start);
+		return contents;
+	});
 	server.registerResource("Render element types", RENDER_TYPES_URI, {
 		description: "Built-in element types a plitzi_render widget can use, with descriptions.",
 		mimeType: "application/json"
-	}, () => jsonContents(RENDER_TYPES_URI, envelope(renderTypes())));
+	}, () => {
+		const start = performance.now();
+		const contents = jsonContents(RENDER_TYPES_URI, envelope(renderTypes()));
+		log.resourceRead(RENDER_TYPES_URI, performance.now() - start);
+		return contents;
+	});
 };
 //#endregion
 export { RENDER_GUIDE_URI, RENDER_TYPES_URI, registerRenderResources };

package/dist/modules/mcp/server.js

@@ -43,7 +43,7 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger }) =>
 	const getSpace = () => spacePromise ??= loadSpace();
 	const server = new McpServer({
 		name: "plitzi-mcp",
-		version: "0.32.10"
+		version: "0.32.11"
 	}, { instructions: serverInstructions });
 	registerResources(server, getSpace, MCP_ENV, log);
 	registerApps(server);

package/dist/plugins/manager.js

@@ -1,6 +1,7 @@
 import { compilePlugin } from "./compile.js";
 import { copyPlugin } from "./copy.js";
 import { detectAction, isComponentSource } from "./detect.js";
+import { assertPluginSources } from "./validate.js";
 import path from "node:path";
 import fs from "node:fs/promises";
 //#region src/plugins/manager.ts
@@ -19,6 +20,7 @@ var PluginManager = class {
 	nameIndex = /* @__PURE__ */ new Map();
 	devMode = false;
 	constructor(plugins, cacheDir, ttlMs, devMode = false) {
+		assertPluginSources(plugins);
 		this.plugins = plugins;
 		this.outputDir = path.resolve(process.cwd(), cacheDir ?? DEFAULT_CACHE_DIR);
 		this.ttlMs = ttlMs ?? DEFAULT_TTL_MS;

package/dist/plugins/validate.js

@@ -0,0 +1,23 @@
+import { isComponentSource } from "./detect.js";
+import fs from "node:fs";
+//#region src/plugins/validate.ts
+var isRemote = (js) => js.startsWith("http://") || js.startsWith("https://");
+/** The file a plugin source needs on disk, or null when nothing local is involved — a remote URL (fetched and
+*  cached at request time) or a component handed in directly. */
+var localSourcePath = (source) => {
+	if (isComponentSource(source) || isRemote(source.js)) return null;
+	return source.js;
+};
+/** Fail at boot on a plugin whose entry file is missing. A plugin entry is a plain string path in the server
+*  config, so nothing — not tsc, not eslint — notices when that file is moved or deleted; without this check the
+*  server starts happily and only dies on the first render that needs the plugin, with an esbuild resolve error
+*  far from its cause. */
+var assertPluginSources = (plugins) => {
+	const missing = Object.entries(plugins).map(([name, source]) => ({
+		name,
+		file: localSourcePath(source)
+	})).filter((entry) => entry.file !== null && !fs.existsSync(entry.file)).map((entry) => `  ${entry.name}: ${entry.file ?? ""}`);
+	if (missing.length > 0) throw new Error(`Plugin entry file not found (declared in the server config):\n${missing.join("\n")}`);
+};
+//#endregion
+export { assertPluginSources, localSourcePath };

package/dist/src/core/http/dispatcher.test.d.ts

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

package/dist/src/core/http/types.d.ts

@@ -10,6 +10,9 @@ export interface BaseContext {
     res: SSRResponseHelpers;
     config: SSRServerConfig;
     port: number;
+    /** Set by the stage that answers when the path alone does not identify the work (the MCP endpoint serves every
+     *  JSON-RPC method on the same URL). The dispatcher folds it into the access log. */
+    operation?: string;
 }
 export interface SSRContext extends BaseContext {
     renderFn: SSRTemplateFn;

package/dist/src/helpers/buildResponseHelpers.d.ts

@@ -1,6 +1,8 @@
 import { SSRResponseHelpers } from '@plitzi/sdk-shared';
 export type RawResponse = {
     headersSent: boolean;
+    /** The status actually written to the wire — the access log reads it once the response is out. */
+    statusCode: number;
     setHeader(name: string, value: string | number | readonly string[]): unknown;
     getHeaders(): Record<string, string | number | readonly string[]>;
     writeHead(statusCode: number, headers?: Record<string, string | number | readonly string[]>): unknown;

package/dist/src/helpers/serverLog.d.ts

@@ -0,0 +1,10 @@
+import { ServerLogEvent, ServerLogger } from '@plitzi/sdk-shared';
+/** One line for any {@link ServerLogEvent}: an HTTP request reads as an access-log line
+ *  (`[SSR] GET /pricing 200 12ms ok`), the MCP events as what happened inside one
+ *  (`[mcp] tools/call plitzi_apply {operations:[3]} 41ms ok`). Events arrive PII-free — the dispatcher strips
+ *  query values and collects no headers, cookies or IPs, and tool args are summarised by shape — so rendering is
+ *  a pure format. */
+export declare const renderLogEvent: (event: ServerLogEvent) => string;
+/** A drop-in `SSRServerConfig.logger` for consumers that just want the log on the console. Consumers with their
+ *  own logging stack should pass their own sink instead and read the structured event. */
+export declare const consoleLogger: ServerLogger;

package/dist/src/index.d.ts

@@ -1,5 +1,6 @@
 export { createServer, createSSRServer, createMCPServer, resolveServices } from './core/createServer';
 export { registerHealthCheck, buildHealthPayload } from './core/health';
+export { consoleLogger, renderLogEvent } from './helpers/serverLog';
 export type { HealthCheckApp, HealthIdentity } from './core/health';
 export { createJsonAdapters } from './adapters/jsonAdapters';
 export { AIEngine, toolResponseOk, toolResponseErr, zodToJsonSchema, getAllowedModes, bindTools, isToolActive, resolveToolHandler, isCallToolResult, toolResponseFromResult } from './modules/ai';

package/dist/src/mcp.d.ts

@@ -4,6 +4,7 @@
  *  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 { consoleLogger, renderLogEvent } from './helpers/serverLog';
 export { createMcpServer, handleMcp, serveMcp, readMcpBody } from './modules/mcp/handler';
 export { createHttpPreviewClient } from './modules/mcp/previewClient';
 export { createHttpScreenshotClient } from './modules/mcp/screenshotClient';

package/dist/src/modules/mcp/handler.d.ts

@@ -1,16 +1,16 @@
 import { createMcpServer } from './server';
 import { PreviewClient, ScreenshotClient } from './types';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { SSRAdapters, SSRRequest, McpLogger } from '@plitzi/sdk-shared';
+import { SSRAdapters, SSRRequest, ServerLogger } from '@plitzi/sdk-shared';
 import { IncomingMessage, ServerResponse } from 'node:http';
 /** Per-request wiring the MCP service does not resolve itself: the renderer clients and the log sink. Everything
  *  here is optional — the service degrades feature by feature. */
 export type McpRequestOptions = {
     preview?: PreviewClient;
     screenshot?: ScreenshotClient;
-    logger?: McpLogger;
+    logger?: ServerLogger;
 };
 export declare const readMcpBody: (req: IncomingMessage) => Promise<unknown>;
-export declare const serveMcp: (raw: IncomingMessage, res: ServerResponse, server: McpServer) => Promise<void>;
-export declare const handleMcp: (raw: IncomingMessage, res: ServerResponse, req: SSRRequest, adapters: SSRAdapters, options?: McpRequestOptions) => Promise<void>;
+export declare const serveMcp: (raw: IncomingMessage, res: ServerResponse, server: McpServer) => Promise<string | undefined>;
+export declare const handleMcp: (raw: IncomingMessage, res: ServerResponse, req: SSRRequest, adapters: SSRAdapters, options?: McpRequestOptions) => Promise<string | undefined>;
 export { createMcpServer };

package/dist/src/modules/mcp/helpers/log.d.ts

@@ -1,8 +1,8 @@
-import { McpLogger } from '@plitzi/sdk-shared';
+import { ServerLogger } from '@plitzi/sdk-shared';
 export interface McpLog {
     toolCall(name: string, args: unknown, ms: number, error?: unknown): void;
     resourceRead(uri: string, ms: number, error?: unknown): void;
 }
-/** Build the request-log sink for one MCP server. Dispatches structured events to the consumer's `logger` when
+/** Build the protocol-log sink for one MCP server. Dispatches structured events to the consumer's `logger` when
  *  provided; otherwise renders to the console when MCP_DEBUG=1; otherwise a no-op. */
-export declare const createMcpLog: (logger?: McpLogger) => McpLog;
+export declare const createMcpLog: (logger?: ServerLogger) => McpLog;

package/dist/src/modules/mcp/resources/renderGuide.d.ts

@@ -1,4 +1,5 @@
+import { McpLog } from '../helpers';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare const RENDER_GUIDE_URI = "plitzi://render/guide";
 export declare const RENDER_TYPES_URI = "plitzi://render/types";
-export declare const registerRenderResources: (server: McpServer) => void;
+export declare const registerRenderResources: (server: McpServer, log: McpLog) => void;

package/dist/src/modules/mcp/server.d.ts

@@ -1,6 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { PreviewClient, ScreenshotClient } from './types';
-import { SSRAdapters, McpLogger } from '@plitzi/sdk-shared';
+import { SSRAdapters, ServerLogger } from '@plitzi/sdk-shared';
 /** The MCP service is stateless: every request resolves its own `spaceId` (from the request JWT) and reads the
  *  space fresh through the adapters — schema and style are two documents, read/written independently. Both the
  *  spaceId and the space itself resolve lazily, so the public surface (handshake, tools-list, resources-list,
@@ -17,6 +17,6 @@ export interface McpServerContext {
     screenshot?: ScreenshotClient;
     /** Structured request-log sink. When set, every tool call and resource read emits an McpLogEvent to it (the
      *  consumer renders them); otherwise logging falls back to the console when MCP_DEBUG=1. */
-    logger?: McpLogger;
+    logger?: ServerLogger;
 }
 export declare const createMcpServer: ({ adapters, getSpaceId, preview, screenshot, logger }: McpServerContext) => McpServer;

package/dist/src/plugins/validate.d.ts

@@ -0,0 +1,9 @@
+import { PluginSource } from '@plitzi/sdk-shared';
+/** The file a plugin source needs on disk, or null when nothing local is involved — a remote URL (fetched and
+ *  cached at request time) or a component handed in directly. */
+export declare const localSourcePath: (source: PluginSource) => string | null;
+/** Fail at boot on a plugin whose entry file is missing. A plugin entry is a plain string path in the server
+ *  config, so nothing — not tsc, not eslint — notices when that file is moved or deleted; without this check the
+ *  server starts happily and only dies on the first render that needs the plugin, with an esbuild resolve error
+ *  far from its cause. */
+export declare const assertPluginSources: (plugins: Record<string, PluginSource>) => void;

package/dist/src/plugins/validate.test.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-server",
-  "version": "0.32.10",
+  "version": "0.32.11",
   "license": "AGPL-3.0",
   "files": [
     "dist"
@@ -29,9 +29,9 @@
   "dependencies": {
     "@modelcontextprotocol/ext-apps": "^1.7.5",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@plitzi/plitzi-sdk": "0.32.10",
-    "@plitzi/sdk-schema": "0.32.10",
-    "@plitzi/sdk-shared": "0.32.10",
+    "@plitzi/plitzi-sdk": "0.32.11",
+    "@plitzi/sdk-schema": "0.32.11",
+    "@plitzi/sdk-shared": "0.32.11",
     "ejs": "^6.0.1",
     "esbuild": "^0.28.1",
     "zod": "^4.4.3"