@abinnovision/payloadcms-mcpx 1.0.0-beta.8 → 1.0.0

package/dist/api-keys/collection.mjs

@@ -1,4 +1,4 @@
-import { createCapabilityFields, createKeyFields } from "./fields.mjs";
+import { createCapabilityFields, createKeyFields, withSetupGuideTab } from "./fields.mjs";
 import { generateApiKey, hashApiKey } from "./key.mjs";
 //#region src/api-keys/collection.ts
 /**
@@ -36,7 +36,7 @@ import { generateApiKey, hashApiKey } from "./key.mjs";
 			delete: ownKeysOnly
 		},
 		hooks: { beforeChange: [keyBeforeChange] },
-		fields: [
+		fields: withSetupGuideTab([
 			{
 				name: "user",
 				type: "relationship",
@@ -51,7 +51,7 @@ import { generateApiKey, hashApiKey } from "./key.mjs";
 			},
 			...createKeyFields(),
 			...createCapabilityFields(options)
-		]
+		], options)
 	};
 };
 //#endregion

package/dist/api-keys/fields.mjs

@@ -1,4 +1,4 @@
-import { CAPABILITIES_FIELD } from "../capabilities.mjs";
+import { CAPABILITIES_FIELD, canCreate, canPublish, canWrite } from "../capabilities.mjs";
 //#region src/api-keys/fields.ts
 const encryptKey = ({ req, value }) => typeof value === "string" ? req.payload.encrypt(value) : value;
 const decryptKey = ({ req, value }) => {
@@ -15,6 +15,7 @@ const checkbox = (name, description) => ({
 	defaultValue: false,
 	admin: { description }
 });
+/** Name of the `ui` field the "Connect a client" tab renders. */ const SETUP_GUIDE_FIELD = "setupGuide";
 /**
 * Fields every key carries. Key generation and the HMAC index live in the
 * collection-level `beforeChange` hook (see `collection.ts`), because sibling
@@ -56,24 +57,74 @@ const checkbox = (name, description) => ({
 	}
 ];
 /**
+* Wraps the key fields and the setup guide in unnamed tabs, so the wide
+* snippets get the full form width without pushing the key itself out of view.
+* Unnamed on purpose: named tabs would nest the data and move `capabilities`
+* off the document root, which capability resolution reads.
+*
+* The guide tab is conditioned on the update operation. On create there is no
+* key to hand out, and a tab leading to an empty panel is worse than no tab.
+*/ const withSetupGuideTab = (keyFields, options) => {
+	if (!options.setupGuide) return keyFields;
+	return [{
+		type: "tabs",
+		tabs: [{
+			label: "Key",
+			fields: keyFields
+		}, {
+			label: "Connect a client",
+			admin: { condition: (_data, _siblingData, { operation }) => operation === "update" },
+			fields: [{
+				name: SETUP_GUIDE_FIELD,
+				type: "ui",
+				admin: {
+					disableListColumn: true,
+					components: { Field: {
+						path: "@abinnovision/payloadcms-mcpx/client",
+						exportName: "McpxSetupGuide",
+						clientProps: { endpointPath: options.endpointPath }
+					} }
+				}
+			}]
+		}]
+	}];
+};
+const PUBLISH_DESCRIPTION = "Publish the current draft. Changes what the public sees.";
+/**
 * One checkbox per exposed operation, grouped per collection, per global and
 * per custom tool. Only operations the plugin config exposes get a checkbox, so
 * a key can never enable more than the config allows. Everything defaults to
 * off, which is why a key issued before a capability existed stays closed to it.
+*
+* An entity without versions gets no `publish` checkbox even under
+* `write: "live"`: there is no draft to promote there, the write itself is the
+* live change, and a second checkbox would only make `write` a dead setting.
+*
+* An upload collection gets the same checkboxes as any other, only worded for
+* what `write` reaches there: a document's own fields, never `createDocument`,
+* because the file comes from the admin panel.
 */ const createCapabilityFields = (options) => {
 	const collectionGroups = options.collections.map((collection) => ({
 		name: collection.fieldName,
 		type: "group",
 		label: collection.slug,
-		fields: [...collection.read ? [checkbox("read", "Describe, find and read documents.")] : [], ...collection.write ? [checkbox("write", "Create, patch and validate drafts.")] : []]
+		fields: [
+			...collection.read ? [checkbox("read", "Describe, find and read documents.")] : [],
+			...canWrite(collection) ? [checkbox("write", canCreate(collection) ? "Create, patch and validate drafts." : "Patch and validate drafts. The file itself is uploaded in the admin panel.")] : [],
+			...canPublish(collection) ? [checkbox("publish", PUBLISH_DESCRIPTION)] : []
+		]
 	}));
 	const globalGroups = options.globals.map((global) => ({
 		name: global.fieldName,
 		type: "group",
 		label: global.slug,
-		fields: [...global.read ? [checkbox("read", "Describe and read this global.")] : [], ...global.write ? [checkbox("write", "Patch and validate this global's draft.")] : []]
+		fields: [
+			...global.read ? [checkbox("read", "Describe and read this global.")] : [],
+			...canWrite(global) ? [checkbox("write", "Patch and validate this global's draft.")] : [],
+			...canPublish(global) ? [checkbox("publish", PUBLISH_DESCRIPTION)] : []
+		]
 	}));
-	const toolCheckboxes = options.tools.map((tool) => checkbox(tool.name, tool.description));
+	const toolCheckboxes = options.tools.map((tool) => checkbox(tool.name, typeof tool.description === "string" ? tool.description : tool.name));
 	const groups = [
 		...collectionGroups.length > 0 ? [{
 			name: "collections",
@@ -100,4 +151,4 @@ const checkbox = (name, description) => ({
 	}];
 };
 //#endregion
-export { createCapabilityFields, createKeyFields };
+export { SETUP_GUIDE_FIELD, createCapabilityFields, createKeyFields, withSetupGuideTab };

package/dist/api-keys/setup-guide.mjs

@@ -0,0 +1,56 @@
+//#region src/api-keys/setup-guide.ts
+/**
+* Stands in for the key in the snippets whenever the real one is unavailable,
+* so the instructions still render and say what is missing.
+*/ const KEY_PLACEHOLDER = "<your-key>";
+/**
+* Server name for the client config. MCP clients key their config by this, so
+* it has to survive labels with spaces or punctuation.
+*/ const toServerName = (label) => {
+	const slug = (label ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	return slug === "" ? "payload" : slug;
+};
+/**
+* A pure builder, so the admin component holds only rendering and the snippets
+* stay unit-testable.
+*/ const buildSetupGuide = (input) => {
+	const key = typeof input.apiKey === "string" ? input.apiKey : KEY_PLACEHOLDER;
+	const name = toServerName(input.label);
+	const url = input.endpointUrl;
+	return [
+		{
+			id: "endpoint",
+			title: "Endpoint",
+			description: "Streamable HTTP. Point any MCP client at this URL.",
+			snippet: url
+		},
+		{
+			id: "header",
+			title: "Authorization header",
+			description: "The only accepted credential; cookies and JWTs are ignored.",
+			snippet: `Authorization: Bearer ${key}`
+		},
+		{
+			id: "claude-code",
+			title: "Claude Code",
+			snippet: [`claude mcp add --transport http ${name} ${url} \\`, `  --header "Authorization: Bearer ${key}"`].join("\n")
+		},
+		{
+			id: "claude-desktop",
+			title: "Claude Desktop",
+			description: "Has no direct header support, so it goes through mcp-remote.",
+			snippet: JSON.stringify({ mcpServers: { [name]: {
+				command: "npx",
+				args: [
+					"-y",
+					"mcp-remote",
+					url,
+					"--header",
+					`Authorization: Bearer ${key}`
+				]
+			} } }, null, 2)
+		}
+	];
+};
+//#endregion
+export { KEY_PLACEHOLDER, buildSetupGuide, toServerName };

package/dist/auth/resolve.mjs

@@ -1,17 +1,15 @@
 import { hashApiKey } from "../api-keys/key.mjs";
 //#region src/auth/resolve.ts
 const BEARER = /^Bearer\s+(\S+)\s*$/i;
-/**
-* The bearer token of an `Authorization` header, or `null`.
-*/ const parseBearer = (headers) => {
-	const header = headers.get("authorization");
-	if (!header) return null;
-	return BEARER.exec(header.trim())?.[1] ?? null;
-};
 const relationId = (value) => {
 	if (typeof value === "string" || typeof value === "number") return value;
 	if (typeof value === "object" && value !== null && "id" in value) return value.id;
 };
+const parseBearer = (headers) => {
+	const header = headers.get("authorization");
+	if (!header) return null;
+	return BEARER.exec(header.trim())?.[1] ?? null;
+};
 /**
 * Resolves the bearer key of a request to the user it acts as.
 *

package/dist/capabilities.mjs

@@ -1,8 +1,23 @@
 //#region src/capabilities.ts
-/** Name of the capability group on the key document. */ const CAPABILITIES_FIELD = "capabilities";
+/** Group field holding the capability checkboxes on an API key document. */ const CAPABILITIES_FIELD = "capabilities";
+/** Whatever the write lands on; {@link isLiveWrite} tells the two apart. */ const canWrite = (entity) => entity.write !== false;
+/** The config lets MCP change live content and there is a draft to promote. */ const canPublish = (entity) => entity.write === "live" && entity.hasDrafts;
+/**
+* An upload document is a file, and no tool here carries one. Its own fields
+* stay patchable; the first version is made in the admin panel.
+*/ const canCreate = (entity) => canWrite(entity) && !entity.isUpload;
+/**
+* With no versions there is no draft to land on, so `write: "live"` permits the
+* write at all and every write is live.
+*/ const isLiveWrite = (entity) => entity.write === "live" && !entity.hasDrafts;
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const flag = (group, name) => isRecord(group) && group[name] === true;
 /**
+* Publishing is an extension of writing, never a capability of its own: a key
+* that may publish may also edit the draft it publishes. Both checkboxes are
+* therefore required, on top of the config exposing publishing at all.
+*/ const publishFlag = (entity, group) => canPublish(entity) && flag(group, "write") && flag(group, "publish");
+/**
 * Capabilities in force for a key: the plugin config decides what can exist,
 * the key's checkboxes decide what does. A missing checkbox is `false`, so keys
 * issued before a capability existed stay closed.
@@ -15,7 +30,8 @@ const flag = (group, name) => isRecord(group) && group[name] === true;
 		const group = isRecord(collectionsGroup) ? collectionsGroup[collection.fieldName] : void 0;
 		collections[collection.slug] = {
 			read: collection.read && flag(group, "read"),
-			write: collection.write && flag(group, "write")
+			write: canWrite(collection) && flag(group, "write"),
+			publish: publishFlag(collection, group)
 		};
 	}
 	const globals = {};
@@ -23,7 +39,8 @@ const flag = (group, name) => isRecord(group) && group[name] === true;
 		const group = isRecord(globalsGroup) ? globalsGroup[global.fieldName] : void 0;
 		globals[global.slug] = {
 			read: global.read && flag(group, "read"),
-			write: global.write && flag(group, "write")
+			write: canWrite(global) && flag(group, "write"),
+			publish: publishFlag(global, group)
 		};
 	}
 	const tools = {};
@@ -37,7 +54,9 @@ const flag = (group, name) => isRecord(group) && group[name] === true;
 const pick = (entries, operation) => Object.entries(entries).filter(([, value]) => value[operation]).map(([slug]) => slug);
 const readableSlugs = (capabilities) => pick(capabilities.collections, "read");
 const writableSlugs = (capabilities) => pick(capabilities.collections, "write");
+const publishableSlugs = (capabilities) => pick(capabilities.collections, "publish");
 const readableGlobalSlugs = (capabilities) => pick(capabilities.globals, "read");
 const writableGlobalSlugs = (capabilities) => pick(capabilities.globals, "write");
+const publishableGlobalSlugs = (capabilities) => pick(capabilities.globals, "publish");
 //#endregion
-export { CAPABILITIES_FIELD, readableGlobalSlugs, readableSlugs, resolveCapabilities, writableGlobalSlugs, writableSlugs };
+export { CAPABILITIES_FIELD, canCreate, canPublish, canWrite, isLiveWrite, publishableGlobalSlugs, publishableSlugs, readableGlobalSlugs, readableSlugs, resolveCapabilities, writableGlobalSlugs, writableSlugs };

package/dist/client/index.d.mts

@@ -0,0 +1,2 @@
+import { McpxSetupGuide } from "./setup-guide.mjs";
+export { McpxSetupGuide };

package/dist/client/index.mjs

@@ -0,0 +1,2 @@
+import { McpxSetupGuide } from "./setup-guide.mjs";
+export { McpxSetupGuide };

package/dist/client/setup-guide.d.mts

@@ -0,0 +1,14 @@
+import React from "react";
+//#region src/client/setup-guide.d.ts
+interface McpxSetupGuideProps {
+  /** Endpoint path below the API route, from the plugin options. */
+  endpointPath: string;
+}
+/**
+ * Per-key connection instructions on the API key edit view. Renders nothing
+ * until the document is saved, because before that there is no key to hand to
+ * a client.
+ */
+declare const McpxSetupGuide: React.FC<McpxSetupGuideProps>;
+//#endregion
+export { McpxSetupGuide };

package/dist/client/setup-guide.mjs

@@ -0,0 +1,87 @@
+"use client";
+import { buildSetupGuide } from "../api-keys/setup-guide.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { CopyToClipboard, useConfig, useDocumentInfo, useFormFields } from "@payloadcms/ui";
+import { useEffect, useState } from "react";
+//#region src/client/setup-guide.tsx
+const asString = (value) => typeof value === "string" ? value : void 0;
+/**
+* Reads `serverURL` when the config sets one and falls back to the browser's
+* origin. The fallback has to wait for mount: this component is server-rendered
+* first, where `window` does not exist.
+*/ const useOrigin = (serverUrl) => {
+	const [origin, setOrigin] = useState(serverUrl);
+	useEffect(() => {
+		if (serverUrl === "") setOrigin(window.location.origin);
+	}, [serverUrl]);
+	return origin;
+};
+/**
+* Payload's own theme variables, so the panel follows the admin's light and
+* dark themes without shipping a stylesheet consumers would have to transpile.
+*/ const styles = {
+	lead: { marginBottom: "calc(var(--base) * 0.75)" },
+	section: { marginBottom: "calc(var(--base) * 0.75)" },
+	sectionHeader: {
+		display: "flex",
+		alignItems: "center",
+		gap: "calc(var(--base) * 0.25)"
+	},
+	description: {
+		margin: "calc(var(--base) * 0.15) 0",
+		color: "var(--theme-elevation-500)"
+	},
+	snippet: {
+		margin: 0,
+		padding: "calc(var(--base) * 0.4)",
+		background: "var(--theme-elevation-50)",
+		border: "1px solid var(--theme-elevation-150)",
+		borderRadius: "3px",
+		fontFamily: "var(--font-mono)",
+		overflowX: "auto",
+		whiteSpace: "pre-wrap",
+		wordBreak: "break-all"
+	}
+};
+/**
+* Per-key connection instructions on the API key edit view. Renders nothing
+* until the document is saved, because before that there is no key to hand to
+* a client.
+*/ const McpxSetupGuide = ({ endpointPath }) => {
+	const { id } = useDocumentInfo();
+	const { config } = useConfig();
+	const apiKey = useFormFields(([fields]) => fields["apiKey"]?.value);
+	const label = useFormFields(([fields]) => fields["label"]?.value);
+	const origin = useOrigin(config.serverURL);
+	if (id === void 0) return null;
+	const sections = buildSetupGuide({
+		endpointUrl: `${origin.replace(/\/+$/, "")}${config.routes.api}${endpointPath}`,
+		apiKey: asString(apiKey),
+		label: asString(label)
+	});
+	return /*#__PURE__*/ jsxs("div", {
+		className: "field-type",
+		children: [/*#__PURE__*/ jsx("p", {
+			style: styles.lead,
+			children: "Every snippet below contains this key in full. Treat it like a password."
+		}), sections.map((section) => /*#__PURE__*/ jsxs("section", {
+			style: styles.section,
+			children: [
+				/*#__PURE__*/ jsxs("div", {
+					style: styles.sectionHeader,
+					children: [/*#__PURE__*/ jsx("strong", { children: section.title }), /*#__PURE__*/ jsx(CopyToClipboard, { value: section.snippet })]
+				}),
+				section.description ? /*#__PURE__*/ jsx("p", {
+					style: styles.description,
+					children: section.description
+				}) : null,
+				/*#__PURE__*/ jsx("pre", {
+					style: styles.snippet,
+					children: section.snippet
+				})
+			]
+		}, section.id))]
+	});
+};
+//#endregion
+export { McpxSetupGuide };

package/dist/endpoint/{result.mjs → errors.mjs}

@@ -1,6 +1,8 @@
+import { errorResult } from "../result.mjs";
 import { pointerFromPayloadPath } from "../schema/walk.mjs";
+import "../schema/index.mjs";
 import { APIError, ValidationError } from "payload";
-//#region src/endpoint/result.ts
+//#region src/endpoint/errors.ts
 /**
 * A JSON-RPC error response for failures that happen before the MCP server
 * is involved (auth, method, body parsing).
@@ -20,27 +22,6 @@ import { APIError, ValidationError } from "payload";
 	});
 };
 /**
-* A successful tool result carrying `value` as JSON text.
-*/ const jsonResult = (value) => ({ content: [{
-	type: "text",
-	text: JSON.stringify(value)
-}] });
-/**
-* A failed tool result. `extras` travel alongside the message so the client
-* can act on them (problems, validation errors, the current `updatedAt`).
-*/ const errorResult = (message, extras = {}) => ({
-	content: [{
-		type: "text",
-		text: JSON.stringify({
-			error: message,
-			...extras
-		})
-	}],
-	isError: true
-});
-/**
-* Maps an exception thrown by a tool to a result the client can read.
-*
 * Payload's public errors keep their message and status; a `ValidationError`
 * also surfaces its per-field detail, with each field's path restated as a
 * JSON Pointer so it reads like every other path this plugin reports. Anything
@@ -62,4 +43,4 @@ import { APIError, ValidationError } from "payload";
 	return errorResult("Internal error");
 };
 //#endregion
-export { errorResult, jsonResult, jsonRpcError, toToolError };
+export { jsonRpcError, toToolError };

package/dist/endpoint/handler.mjs

@@ -1,6 +1,6 @@
-import { readableGlobalSlugs, readableSlugs, resolveCapabilities, writableGlobalSlugs, writableSlugs } from "../capabilities.mjs";
+import { publishableGlobalSlugs, publishableSlugs, readableGlobalSlugs, readableSlugs, resolveCapabilities, writableGlobalSlugs, writableSlugs } from "../capabilities.mjs";
+import { jsonRpcError } from "./errors.mjs";
 import { resolveApiKeyAuth } from "../auth/resolve.mjs";
-import { jsonRpcError } from "./result.mjs";
 import { createMcpServer } from "./server.mjs";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 //#region src/endpoint/handler.ts
@@ -8,14 +8,20 @@ const buildScope = (req, options, capabilities) => {
 	const { localization } = req.payload.config;
 	return {
 		req,
-		options,
 		capabilities,
 		readable: readableSlugs(capabilities),
 		writable: writableSlugs(capabilities),
+		publishable: publishableSlugs(capabilities),
 		readableGlobals: readableGlobalSlugs(capabilities),
 		writableGlobals: writableGlobalSlugs(capabilities),
+		publishableGlobals: publishableGlobalSlugs(capabilities),
 		locales: localization ? localization.localeCodes : null,
-		defaultLocale: localization ? localization.defaultLocale : null
+		defaultLocale: localization ? localization.defaultLocale : null,
+		limits: options.limits,
+		exposure: {
+			collections: options.collections,
+			globals: options.globals
+		}
 	};
 };
 /**
@@ -68,7 +74,7 @@ const buildScope = (req, options, capabilities) => {
 		code: -32600,
 		message: "Invalid request: a JSON body is required."
 	});
-	const server = createMcpServer(buildScope(req, options, capabilities));
+	const server = createMcpServer(buildScope(req, options, capabilities), options);
 	const transport = new WebStandardStreamableHTTPServerTransport({ enableJsonResponse: true });
 	await server.connect(transport);
 	const headers = new Headers(req.headers);

package/dist/endpoint/index.mjs

@@ -0,0 +1,4 @@
+import { jsonRpcError, toToolError } from "./errors.mjs";
+import { createMcpServer, isToolEnabled, toolDescription, toolInputSchema } from "./server.mjs";
+import { createMcpxHandler, methodNotAllowed } from "./handler.mjs";
+export { createMcpServer, createMcpxHandler, isToolEnabled, jsonRpcError, methodNotAllowed, toToolError, toolDescription, toolInputSchema };

package/dist/endpoint/server.mjs

@@ -1,24 +1,23 @@
-import { toToolError } from "./result.mjs";
-import { BUILTIN_TOOLS } from "../tools/index.mjs";
+import { toToolError } from "./errors.mjs";
+import { draftSentence } from "../tools/shared.mjs";
+import { BUILTIN_TOOLS } from "../tools/builtin.mjs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 //#region src/endpoint/server.ts
+/** Strict, so an unknown argument is rejected by name rather than stripped. */ const toolInputSchema = (tool, scope) => z.strictObject(typeof tool.inputSchema === "function" ? tool.inputSchema(scope) : tool.inputSchema ?? {});
+/** May be built from the scope, to name the targets this key writes live. */ const toolDescription = (tool, scope) => typeof tool.description === "function" ? tool.description(scope) : tool.description;
+/** A tool that does not decide for itself is gated by its own checkbox. */ const isToolEnabled = (tool, scope) => tool.isEnabled ? tool.isEnabled(scope) : scope.capabilities.tools[tool.name] === true;
 /**
-* Builds a builtin tool's input schema as a strict object, so an unknown
-* argument is rejected with its name instead of being silently stripped and
-* the tool answering as if it had not been passed.
-*/ const builtinInputSchema = (tool, scope) => z.strictObject(tool.inputSchema(scope));
-/**
-* Builds the MCP server for one request. Tools are registered against the
-* key's capabilities, so `tools/list` shows exactly what the key may call and
-* every `collection` enum is limited to what it may touch.
-*/ const createMcpServer = (scope) => {
-	const { req, options, capabilities } = scope;
+* One server per request. Builtin and configured tools take the same route,
+* each registered against the key's capabilities, so `tools/list` shows exactly
+* what the key may call.
+*/ const createMcpServer = (scope, options) => {
+	const { req } = scope;
 	const { logger } = req.payload;
 	const server = new McpServer({
 		name: options.serverInfo.name,
 		version: options.serverInfo.version
-	}, { instructions: "Start with listCapabilities, then describeSchema for the collection or global you work on. Writes always land as drafts; a human publishes." });
+	}, { instructions: `Start with listCapabilities, then describeSchema for the collection or global you work on. ${draftSentence(scope)}` });
 	const guarded = (run) => async () => {
 		try {
 			return await run();
@@ -26,22 +25,15 @@ import { z } from "zod";
 			return toToolError(error, logger);
 		}
 	};
-	for (const tool of BUILTIN_TOOLS) {
-		if (!tool.isEnabled(scope)) continue;
-		server.registerTool(tool.name, {
-			description: tool.description,
-			inputSchema: builtinInputSchema(tool, scope),
-			annotations: tool.annotations
-		}, (args) => guarded(() => tool.handler(args, scope))());
-	}
-	for (const tool of options.tools) {
-		if (capabilities.tools[tool.name] !== true) continue;
+	for (const tool of [...BUILTIN_TOOLS, ...options.tools]) {
+		if (!isToolEnabled(tool, scope)) continue;
 		server.registerTool(tool.name, {
-			description: tool.description,
-			inputSchema: tool.inputSchema ?? {},
+			description: toolDescription(tool, scope),
+			inputSchema: toolInputSchema(tool, scope),
 			...tool.annotations ? { annotations: tool.annotations } : {}
 		}, (args, extra) => guarded(() => tool.handler({
 			args,
+			scope,
 			req,
 			extra
 		}))());
@@ -49,4 +41,4 @@ import { z } from "zod";
 	return server;
 };
 //#endregion
-export { builtinInputSchema, createMcpServer };
+export { createMcpServer, isToolEnabled, toolDescription, toolInputSchema };

package/dist/i18n.mjs

@@ -1,11 +1,6 @@
 //#region src/i18n.ts
-/**
-* A locale-keyed record, once it is known to hold nothing but strings.
-*/ const stringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string") ? value : void 0;
-/**
-* Picks the entry a language addresses, treating an empty value as absent so
-* the chain continues rather than yielding a useless string.
-*/ const pick = (record, language) => {
+const stringRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((entry) => typeof entry === "string") ? value : void 0;
+/** Treats an empty value as absent, so the fallback chain continues. */ const pick = (record, language) => {
 	for (const code of Array.isArray(language) ? language : [language]) {
 		const entry = record[code];
 		if (entry !== void 0 && entry.trim() !== "") return entry;
@@ -25,14 +20,8 @@
 	if (!record) return;
 	return pick(record, language.language) ?? pick(record, language.fallbackLanguage) ?? Object.values(record).find((entry) => entry.trim() !== "");
 };
-/**
-* Binds {@link translateStatic} to a request's language, so a walk that
-* resolves many descriptions carries no request of its own.
-*/ const translatorFor = (i18n) => (value) => translateStatic(value, i18n);
-/**
-* Translator for callers with no request in hand. Both language keys miss, so
-* the chain degrades to the record's first entry.
-*/ const translateAny = translatorFor({
+/** Bound to one request's language, so a walk carries no request of its own. */ const translatorFor = (i18n) => (value) => translateStatic(value, i18n);
+/** For callers with no request: both keys miss, so the first entry wins. */ const translateAny = translatorFor({
 	fallbackLanguage: "",
 	language: ""
 });

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { McpxAuthResult, McpxCollectionCapabilities, McpxCollectionOptions, McpxGlobalOptions, McpxPluginOptions, McpxRequestContext, McpxResolvedCapabilities, McpxTool, McpxToolExtra, defineMcpxTool } from "./types.mjs";
+import { McpxAnyTool, McpxAuthResult, McpxCollectionCapabilities, McpxCollectionOptions, McpxExposedEntity, McpxGlobalOptions, McpxPluginOptions, McpxRequestContext, McpxResolvedCapabilities, McpxTool, McpxToolExtra, McpxToolScope, McpxWriteMode, PublishBlocker, defineMcpxTool } from "./types.mjs";
 import { mcpxPlugin } from "./plugin.mjs";
-import { isMcpxRequest } from "./write/draft-guard.mjs";
-import { PublishBlocker } from "./write/publish-blockers.mjs";
-export { type McpxAuthResult, type McpxCollectionCapabilities, type McpxCollectionOptions, type McpxGlobalOptions, type McpxPluginOptions, type McpxRequestContext, type McpxResolvedCapabilities, type McpxTool, type McpxToolExtra, type PublishBlocker, defineMcpxTool, isMcpxRequest, mcpxPlugin };
+import { isMcpxRequest } from "./request.mjs";
+import { errorResult, jsonResult } from "./result.mjs";
+export { McpxAnyTool, McpxAuthResult, McpxCollectionCapabilities, McpxCollectionOptions, McpxExposedEntity, McpxGlobalOptions, McpxPluginOptions, McpxRequestContext, McpxResolvedCapabilities, McpxTool, McpxToolExtra, McpxToolScope, McpxWriteMode, PublishBlocker, defineMcpxTool, errorResult, isMcpxRequest, jsonResult, mcpxPlugin };

package/dist/index.mjs

@@ -1,4 +1,5 @@
-import { isMcpxRequest } from "./write/draft-guard.mjs";
-import { mcpxPlugin } from "./plugin.mjs";
+import { errorResult, jsonResult } from "./result.mjs";
 import { defineMcpxTool } from "./types.mjs";
-export { defineMcpxTool, isMcpxRequest, mcpxPlugin };
+import { isMcpxRequest } from "./request.mjs";
+import { mcpxPlugin } from "./plugin.mjs";
+export { defineMcpxTool, errorResult, isMcpxRequest, jsonResult, mcpxPlugin };