@abinnovision/payloadcms-mcpx 1.0.0-beta.11 → 1.0.0-beta.12

package/README.md

@@ -13,8 +13,9 @@ resolved server-side against the real config and the real document, so unknown
 fields, misplaced blocks and unusable rich text nodes or node fields are refused with the
 valid alternatives listed, never silently dropped.
 
-Writes are RFC 6902 patches that always land as drafts; publishing stays a
-human action in the admin panel. Every write returns the publish
+Writes are RFC 6902 patches that land as drafts, with `allowLiveWrites` as the
+one documented exception; publishing stays a human action in the admin panel.
+Every write returns the publish
 blockers: the validation failures that still prevent a human from publishing
 the draft. Capabilities are declared twice: the plugin config decides what
 can exist, a checkbox on each API key decides what does, and a missing checkbox
@@ -153,7 +154,7 @@ only the slugs the key may touch.
 | `getDocument`      | Read one document or a subtree of it.                       | `collection` + `id` \| `global`, `path?` (JSON pointer), `depth?`, `locale?`, `draft?`       |
 | `patchDocument`    | Apply RFC 6902 operations to the current draft.             | `collection` + `id` \| `global`, `locale`, `patches`, `expectedUpdatedAt?`                   |
 | `createDocument`   | Create a draft from a minimal seed.                         | `collection`, `locale`, `data`                                                               |
-| `validateDocument` | Publish blockers without writing.                           | `collection` + `id` \| `global`, `locale`                                                    |
+| `validateDocument` | Publish blockers without saving anything.                   | `collection` + `id` \| `global`, `locale`                                                    |
 
 Rules the tools enforce and explain in their own descriptions:
 
@@ -266,6 +267,12 @@ Collections with `versions.drafts.validate: true` refuse invalid drafts
 outright; those failures come back as `validationErrors`. Both carry pointers,
 restated from the dotted paths Payload reports internally.
 
+`publishBlockersUnavailable` marks a check that could not complete, which is
+not the same answer as a document with nothing wrong with it. `validateDocument`
+runs the same traversal without saving anything, so it is not free of side
+effects: field `beforeValidate` and `beforeChange` hooks run, and it carries no
+`readOnlyHint` for that reason.
+
 Writes also report `notApplied`: pointers whose value Payload kept unchanged,
 which happens when field-level access denies the update.
 
@@ -377,6 +384,11 @@ results shaped like a builtin's.
 | `auth.resolve`                       | none                           | Replace or wrap the default key resolution.                                                                        |
 | `serverInfo`                         | package name and version       | Reported to MCP clients.                                                                                           |
 
+`allowLiveWrites` is the only way an MCP write reaches live content. Where it is
+set, the server instructions and the `patchDocument` and `createDocument`
+descriptions name those slugs for the key in question, so a client is never told
+its writes are drafts while they are not.
+
 Misconfiguration (unknown slugs, write on a collection without drafts, upload
 collections exposed for write, tool name collisions) fails at startup with
 `InvalidConfiguration`. Auth collections cannot be exposed at all, read

package/dist/api-keys/fields.mjs

@@ -107,7 +107,7 @@ const SETUP_GUIDE_FIELD = "setupGuide";
 		label: global.slug,
 		fields: [...global.read ? [checkbox("read", "Describe and read this global.")] : [], ...global.write ? [checkbox("write", "Patch and validate this global's draft.")] : []]
 	}));
-	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",

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,25 +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`
@@ -62,4 +45,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,5 +1,5 @@
-import { jsonRpcError } from "./result.mjs";
 import { readableGlobalSlugs, readableSlugs, resolveCapabilities, writableGlobalSlugs, writableSlugs } from "../capabilities.mjs";
+import { jsonRpcError } from "./errors.mjs";
 import { resolveApiKeyAuth } from "../auth/resolve.mjs";
 import { createMcpServer } from "./server.mjs";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";

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,5 +1,6 @@
-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
@@ -10,6 +11,10 @@ import { z } from "zod";
 * scope to narrow enums to what the key may touch.
 */ const toolInputSchema = (tool, scope) => z.strictObject(typeof tool.inputSchema === "function" ? tool.inputSchema(scope) : tool.inputSchema ?? {});
 /**
+* A tool's description, which may be built from the scope so it can name the
+* targets this key writes live.
+*/ const toolDescription = (tool, scope) => typeof tool.description === "function" ? tool.description(scope) : tool.description;
+/**
 * Whether the key may call the tool. A tool that does not decide for itself is
 * gated by its own checkbox on the key, which is how the tools from
 * `options.tools` work; the builtins derive it from the key's collection and
@@ -26,7 +31,7 @@ import { z } from "zod";
 	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();
@@ -37,7 +42,7 @@ import { z } from "zod";
 	for (const tool of [...BUILTIN_TOOLS, ...options.tools]) {
 		if (!isToolEnabled(tool, scope)) continue;
 		server.registerTool(tool.name, {
-			description: tool.description,
+			description: toolDescription(tool, scope),
 			inputSchema: toolInputSchema(tool, scope),
 			...tool.annotations ? { annotations: tool.annotations } : {}
 		}, (args, extra) => guarded(() => tool.handler({
@@ -50,4 +55,4 @@ import { z } from "zod";
 	return server;
 };
 //#endregion
-export { createMcpServer, isToolEnabled, toolInputSchema };
+export { createMcpServer, isToolEnabled, toolDescription, toolInputSchema };

package/dist/index.d.mts

@@ -1,6 +1,5 @@
-import { errorResult, jsonResult } from "./endpoint/result.mjs";
-import { McpxAnyTool, McpxAuthResult, McpxCollectionCapabilities, McpxCollectionOptions, McpxExposedEntity, McpxGlobalOptions, McpxPluginOptions, McpxRequestContext, McpxResolvedCapabilities, McpxTool, McpxToolExtra, McpxToolScope, defineMcpxTool } from "./types.mjs";
+import { McpxAnyTool, McpxAuthResult, McpxCollectionCapabilities, McpxCollectionOptions, McpxExposedEntity, McpxGlobalOptions, McpxPluginOptions, McpxRequestContext, McpxResolvedCapabilities, McpxTool, McpxToolExtra, McpxToolScope, 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 McpxAnyTool, type McpxAuthResult, type McpxCollectionCapabilities, type McpxCollectionOptions, type McpxExposedEntity, type McpxGlobalOptions, type McpxPluginOptions, type McpxRequestContext, type McpxResolvedCapabilities, type McpxTool, type McpxToolExtra, type McpxToolScope, type PublishBlocker, defineMcpxTool, errorResult, isMcpxRequest, jsonResult, 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, PublishBlocker, defineMcpxTool, errorResult, isMcpxRequest, jsonResult, mcpxPlugin };

package/dist/index.mjs

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

package/dist/plugin.mjs

@@ -1,5 +1,6 @@
 import { createApiKeysCollection } from "./api-keys/collection.mjs";
 import { createMcpxHandler, methodNotAllowed } from "./endpoint/handler.mjs";
+import "./endpoint/index.mjs";
 import { normalizeOptions } from "./options.mjs";
 import { installDraftGuards, installGlobalDraftGuards } from "./write/draft-guard.mjs";
 import { definePlugin } from "payload";

package/dist/{write/draft-guard.d.mts → request.d.mts}

@@ -1,5 +1,5 @@
-import { CollectionConfig, PayloadRequest } from "payload";
-//#region src/write/draft-guard.d.ts
+import { PayloadRequest } from "payload";
+//#region src/request.d.ts
 /**
  * Whether a request originated from the MCP endpoint. The endpoint stamps
  * `req.context.mcpx`, which travels into every local API call made with the

package/dist/request.mjs

@@ -0,0 +1,8 @@
+//#region src/request.ts
+/**
+* Whether a request originated from the MCP endpoint. The endpoint stamps
+* `req.context.mcpx`, which travels into every local API call made with the
+* same `req`, including those made by custom tools.
+*/ const isMcpxRequest = (req) => req.context.mcpx !== void 0;
+//#endregion
+export { isMcpxRequest };

package/dist/{endpoint/result.d.mts → result.d.mts}

@@ -1,6 +1,5 @@
-import "payload";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-//#region src/endpoint/result.d.ts
+//#region src/result.d.ts
 /**
  * A successful tool result carrying `value` as JSON text.
  */

package/dist/result.mjs

@@ -0,0 +1,22 @@
+//#region src/result.ts
+/**
+* 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
+});
+//#endregion
+export { errorResult, jsonResult };

package/dist/schema/index.mjs

@@ -0,0 +1,6 @@
+import { allowedNodeTypes, lexicalSubSchema, nodeOptions, subSchemaNodeTypes } from "./lexical.mjs";
+import { JSON_POINTER_PATTERN, RESERVED_FIELD_NAMES, blockOf, blockSlugsOf, describeAddressableFields, describeFields, findBlocksField, findRichTextField, joinPath, pointerFromPayloadPath, splitPath, targetOf } from "./walk.mjs";
+import { nodeDescriber, reachableSchemaPaths } from "./describe.mjs";
+import { resolveDataPointer } from "./pointer.mjs";
+import { validateWriteValue } from "./shape.mjs";
+export { JSON_POINTER_PATTERN, RESERVED_FIELD_NAMES, allowedNodeTypes, blockOf, blockSlugsOf, describeAddressableFields, describeFields, findBlocksField, findRichTextField, joinPath, lexicalSubSchema, nodeDescriber, nodeOptions, pointerFromPayloadPath, reachableSchemaPaths, resolveDataPointer, splitPath, subSchemaNodeTypes, targetOf, validateWriteValue };

package/dist/schema/pointer.mjs

@@ -43,7 +43,7 @@ const partMatches = (part, segment) => segment !== void 0 && (part === "*" ? isI
 			if (isSubtreePrefix(descriptors, segments)) return {
 				...blockType === void 0 ? {} : { blockType },
 				fields,
-				prefix: segments
+				prefix: segments.map((segment) => isIndexSegment(segment) ? "*" : segment)
 			};
 			throw new Error(`"${joinPath(segments)}" is not a field here. Available: ${descriptors.map((descriptor) => descriptor.path).join(", ")}`);
 		}

package/dist/schema/walk.mjs

@@ -83,7 +83,7 @@ const withRows = (descriptor, field) => ({
 * Whether a descriptor stands for a construct that only holds other fields.
 *
 * These describe a position rather than a value, so everything that resolves a
-* path to something writable skips them; only {@link describeNode} reports
+* path to something writable skips them; only {@link nodeDescriber} reports
 * them, to carry what the container itself declares.
 */ const isContainer = (descriptor) => descriptor.type === "array" || descriptor.type === "group" || descriptor.type === "tab";
 /**
@@ -133,29 +133,25 @@ const withRows = (descriptor, field) => ({
 /**
 * The descriptors that address a value, which is what every walk resolving a
 * path against a document needs. A container describes a position rather than
-* a value, so only {@link describeNode} reports one.
+* a value, so only {@link nodeDescriber} reports one.
 */ const describeAddressableFields = (fields) => describeFields(fields).filter((descriptor) => !isContainer(descriptor));
 /**
-* Locates the blocks field that a resolved descriptor path refers to.
-*/ const findBlocksField = (fields, path) => {
+* Locates the field of `type` that a resolved descriptor path refers to.
+*/ const findFieldAt = (fields, path, type) => {
 	for (const field of fields) {
 		if (!("name" in field) || field.name !== path[0]) continue;
-		if (field.type === "blocks" && path.length === 1) return field;
-		if (field.type === "tab" || field.type === "group") return findBlocksField(field.flattenedFields, path.slice(1));
-		if (field.type === "array" && path[1] === "*") return findBlocksField(field.flattenedFields, path.slice(2));
+		if (field.type === type && path.length === 1) return field;
+		if (field.type === "tab" || field.type === "group") return findFieldAt(field.flattenedFields, path.slice(1), type);
+		if (field.type === "array" && path[1] === "*") return findFieldAt(field.flattenedFields, path.slice(2), type);
 	}
 };
 /**
+* Locates the blocks field that a resolved descriptor path refers to.
+*/ const findBlocksField = (fields, path) => findFieldAt(fields, path, "blocks");
+/**
 * Locates the rich text field that a resolved descriptor path refers to, so
 * its editor can be introspected for the fields its nodes carry.
-*/ const findRichTextField = (fields, path) => {
-	for (const field of fields) {
-		if (!("name" in field) || field.name !== path[0]) continue;
-		if (field.type === "richText" && path.length === 1) return field;
-		if (field.type === "tab" || field.type === "group") return findRichTextField(field.flattenedFields, path.slice(1));
-		if (field.type === "array" && path[1] === "*") return findRichTextField(field.flattenedFields, path.slice(2));
-	}
-};
+*/ const findRichTextField = (fields, path) => findFieldAt(fields, path, "richText");
 const targetOf = (config, ref) => {
 	const found = ref.kind === "collection" ? config.collections.find((candidate) => candidate.slug === ref.slug) : config.globals.find((candidate) => candidate.slug === ref.slug);
 	if (!found) throw new Error(`Unknown ${ref.kind} "${ref.slug}".`);

package/dist/tools/{index.mjs → builtin.mjs}

@@ -5,7 +5,7 @@ import { getDocument } from "./get-document.mjs";
 import { listCapabilities } from "./list-capabilities.mjs";
 import { patchDocument } from "./patch-document.mjs";
 import { validateDocument } from "./validate-document.mjs";
-//#region src/tools/index.ts
+//#region src/tools/builtin.ts
 /**
 * The builtin tools in registration order. They are ordinary {@link McpxTool}s
 * that ship with the plugin and register through the same loop as the tools

package/dist/tools/create-document.mjs

@@ -1,15 +1,19 @@
-import { errorResult, jsonResult } from "../endpoint/result.mjs";
-import { localeOf, localeShape, readTarget, slugEnum } from "./shared.mjs";
-import { resolveTarget } from "./target.mjs";
+import { errorResult, jsonResult } from "../result.mjs";
 import { validateWriteValue } from "../schema/shape.mjs";
+import "../schema/index.mjs";
+import { draftSentence, localeOf, localeShape, readTarget, slugEnum } from "./shared.mjs";
+import { resolveTarget } from "./target.mjs";
 import { defineMcpxTool } from "../types.mjs";
 import { stripRowIds } from "../write/patch.mjs";
 import { collectPublishBlockers } from "../write/publish-blockers.mjs";
 import { z } from "zod";
 //#region src/tools/create-document.ts
+const DESCRIPTION = (scope) => `Creates a new document from a minimal seed. Only the fields describeSchema lists may appear in "data"; unknown keys are refused with the valid siblings, and "id" is Payload's to assign. The document may be incomplete: the response lists "publishBlockers", which patchDocument can then work through, and "publishBlockersUnavailable" when that check itself failed. Use this when no document exists yet; prefer patching an existing draft otherwise.
+
+${draftSentence(scope)}`;
 const createDocument = defineMcpxTool({
 	name: "createDocument",
-	description: `Creates a new document as a draft from a minimal seed. Only the fields describeSchema lists may appear in "data"; unknown keys are refused with the valid siblings. The draft may be incomplete: the response lists "publishBlockers", which patchDocument can then work through. Use this when no document exists yet; prefer patching an existing draft otherwise.`,
+	description: DESCRIPTION,
 	annotations: {
 		readOnlyHint: false,
 		destructiveHint: false,
@@ -29,18 +33,18 @@ const createDocument = defineMcpxTool({
 		const target = resolveTarget(scope, { collection: args.collection }, "write");
 		const { payload } = scope.req;
 		const locale = localeOf(scope, args.locale);
-		const { id: _ignored, ...seed } = args.data;
+		if ("id" in args.data) return errorResult("Nothing was created.", { problems: ["/id: Payload assigns the id; it cannot be supplied."] });
 		const problems = validateWriteValue(payload.config, {
 			pointer: "",
 			resolution: {
 				fields: target.config.flattenedFields,
 				prefix: []
 			}
-		}, seed);
+		}, args.data);
 		if (problems.length > 0) return errorResult("Nothing was created.", { problems });
 		const created = await payload.create({
 			collection: args.collection,
-			data: stripRowIds(seed),
+			data: stripRowIds(args.data),
 			depth: 0,
 			draft: true,
 			overrideAccess: false,
@@ -53,7 +57,7 @@ const createDocument = defineMcpxTool({
 			locale,
 			privileged: true
 		});
-		const publishBlockers = await collectPublishBlockers(scope.req, {
+		const validation = await collectPublishBlockers(scope.req, {
 			doc: saved,
 			entity: target
 		});
@@ -61,7 +65,8 @@ const createDocument = defineMcpxTool({
 			id: saved["id"],
 			status: saved["_status"],
 			updatedAt: saved["updatedAt"],
-			...publishBlockers.length > 0 ? { publishBlockers } : {}
+			...validation.blockers.length > 0 ? { publishBlockers: validation.blockers } : {},
+			...validation.unavailable ? { publishBlockersUnavailable: true } : {}
 		});
 	}
 });

package/dist/tools/describe-schema.mjs

@@ -1,11 +1,11 @@
+import { jsonResult } from "../result.mjs";
 import { translatorFor } from "../i18n.mjs";
-import { jsonResult } from "../endpoint/result.mjs";
+import { nodeDescriber, reachableSchemaPaths } from "../schema/describe.mjs";
+import "../schema/index.mjs";
 import { targetShape } from "./shared.mjs";
 import { refOf, resolveTarget } from "./target.mjs";
 import { defineMcpxTool } from "../types.mjs";
-import { nodeDescriber, reachableSchemaPaths } from "../schema/describe.mjs";
 import { z } from "zod";
-//#region src/tools/describe-schema.ts
 const describeSchema = defineMcpxTool({
 	name: "describeSchema",
 	description: `Describes the writable shape of a document, one node at a time.

package/dist/tools/find-documents.mjs

@@ -1,9 +1,8 @@
-import { jsonResult } from "../endpoint/result.mjs";
+import { jsonResult } from "../result.mjs";
 import { depthShape, localeOf, localeShape, slugEnum } from "./shared.mjs";
 import { resolveTarget } from "./target.mjs";
 import { defineMcpxTool } from "../types.mjs";
 import { z } from "zod";
-//#region src/tools/find-documents.ts
 const findDocuments = defineMcpxTool({
 	name: "findDocuments",
 	description: `Finds documents in a collection. "where" is a Payload query object, e.g. {"title":{"contains":"home"}} or {"and":[...]}; "select" picks fields, e.g. {"title":true}. Drafts are included by default so unpublished work is visible. Keep depth at 0 unless populated relationships are needed; ids are enough for writes.`,

package/dist/tools/get-document.mjs

@@ -1,11 +1,11 @@
+import { errorResult, jsonResult } from "../result.mjs";
 import { JSON_POINTER_PATTERN } from "../schema/walk.mjs";
-import { errorResult, jsonResult } from "../endpoint/result.mjs";
+import "../schema/index.mjs";
 import { depthShape, idShape, localeOf, localeShape, targetShape } from "./shared.mjs";
 import { requireIdFor, resolveTarget } from "./target.mjs";
 import { defineMcpxTool } from "../types.mjs";
 import { z } from "zod";
 import { Pointer } from "rfc6902";
-//#region src/tools/get-document.ts
 const getDocument = defineMcpxTool({
 	name: "getDocument",
 	description: `Reads one document, or one subtree of it when "path" is given as a JSON pointer such as "/layout/sections/2". Returns the latest draft by default. Read before patching: the response carries "updatedAt" for expectedUpdatedAt and the indices pointers need.

package/dist/tools/list-capabilities.mjs

@@ -1,9 +1,8 @@
+import { jsonResult } from "../result.mjs";
 import { translatorFor } from "../i18n.mjs";
-import { jsonResult } from "../endpoint/result.mjs";
 import { translateLabel } from "./shared.mjs";
 import { defineMcpxTool } from "../types.mjs";
 import { hasDraftValidationEnabled } from "payload/shared";
-//#region src/tools/list-capabilities.ts
 const listCapabilities = defineMcpxTool({
 	name: "listCapabilities",
 	description: `Lists what this key may do: the collections and globals it can read or write, their draft behaviour and id type, the configured locales, the limits in force and the custom tools available. Call it first to orient; nothing here changes with the content model.

package/dist/tools/patch-document.mjs

@@ -1,24 +1,24 @@
-import { errorResult, jsonResult } from "../endpoint/result.mjs";
-import { idShape, localeOf, localeShape, readTarget, targetShape } from "./shared.mjs";
+import { errorResult, jsonResult } from "../result.mjs";
+import { draftSentence, idShape, localeOf, localeShape, readTarget, targetShape } from "./shared.mjs";
 import { refOf, requireIdFor, resolveTarget } from "./target.mjs";
 import { defineMcpxTool } from "../types.mjs";
-import { PATCH_OPERATION_SCHEMA, applyPatchToCopy, buildWriteData, findPatchProblems, isElementPointer } from "../write/patch.mjs";
+import { PATCH_OPERATION_SCHEMA, applyPatchOperations, buildWriteData, isElementPointer } from "../write/patch.mjs";
 import { collectPublishBlockers } from "../write/publish-blockers.mjs";
 import { withTransaction } from "../write/transaction.mjs";
 import { z } from "zod";
 import { Pointer } from "rfc6902";
 //#region src/tools/patch-document.ts
-const DESCRIPTION = `Applies RFC 6902 JSON Patch operations to one document.
+const DESCRIPTION = (scope) => `Applies RFC 6902 JSON Patch operations to one document.
 
 Pass exactly one of "collection" and "global". "id" is required with "collection" and must be omitted with "global", because a global is a singleton.
 
-The write always lands as a draft and is never published, whatever it contains; publishing stays a human action in the admin panel.
+${draftSentence(scope)}
 
 Only the fields describeSchema lists can be addressed. A pointer that does not resolve is refused with the fields that are valid at that point, and nothing is applied unless every operation in the batch validates first. describeSchema reports field paths in this same pointer syntax; a path becomes a pointer into a document by replacing each "*" and each block slug with its 0-based index.
 
 Adding a block requires "blockType" on the value. Append with "/-" as the last segment. To clear a field use "replace" with null; an array or blocks field refuses null and is emptied with [] instead. "remove" is only for list elements, because a field left out of a write is kept rather than cleared. Read the document first to learn the indices, and pass its "updatedAt" as expectedUpdatedAt so a concurrent edit is refused rather than overwritten.
 
-A successful write may come back with "publishBlockers": everything still wrong with the draft, such as required fields left empty. Those do not fail the write, because a draft is allowed to be incomplete, but a human cannot publish the document until the list is empty. "notApplied" lists pointers whose value Payload kept unchanged, which happens when field-level access denies the update.`;
+A successful write may come back with "publishBlockers": everything still wrong with the draft, such as required fields left empty. Those do not fail the write, because a draft is allowed to be incomplete, but a human cannot publish the document until the list is empty. "notApplied" lists pointers whose value Payload kept unchanged, which happens when field-level access denies the update. "publishBlockersUnavailable" means the check itself failed, so the empty list says nothing about whether the document is publishable.`;
 const sameInstant = (left, right) => typeof left === "string" && new Date(left).getTime() === new Date(right).getTime();
 const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /**
@@ -48,7 +48,7 @@ const patchDocument = defineMcpxTool({
 	description: DESCRIPTION,
 	annotations: {
 		readOnlyHint: false,
-		destructiveHint: false,
+		destructiveHint: true,
 		idempotentHint: false,
 		openWorldHint: false
 	},
@@ -79,13 +79,11 @@ const patchDocument = defineMcpxTool({
 				locale
 			});
 			if (args.expectedUpdatedAt !== void 0 && !sameInstant(doc["updatedAt"], args.expectedUpdatedAt)) return errorResult("The document changed since you read it. Read it again and re-apply the patch.", { updatedAt: doc["updatedAt"] });
-			const problems = findPatchProblems(payload.config, {
+			const applied = applyPatchOperations(payload.config, {
 				doc,
 				patches,
 				ref: refOf(target)
 			});
-			if (problems.length > 0) return errorResult("No operation was applied.", { problems });
-			const applied = applyPatchToCopy(doc, patches);
 			if ("problems" in applied) return errorResult("No operation was applied.", { problems: applied.problems });
 			const write = {
 				data: buildWriteData(payload.config, target.config, applied.next),
@@ -111,7 +109,7 @@ const patchDocument = defineMcpxTool({
 				privileged: true
 			});
 			const notApplied = notAppliedPointers(patches, applied.next, saved);
-			const publishBlockers = await collectPublishBlockers(scope.req, {
+			const validation = await collectPublishBlockers(scope.req, {
 				doc: saved,
 				entity: target
 			});
@@ -119,7 +117,8 @@ const patchDocument = defineMcpxTool({
 				...target.kind === "collection" ? { id: saved["id"] } : { global: target.slug },
 				status: saved["_status"],
 				updatedAt: saved["updatedAt"],
-				...publishBlockers.length > 0 ? { publishBlockers } : {},
+				...validation.blockers.length > 0 ? { publishBlockers: validation.blockers } : {},
+				...validation.unavailable ? { publishBlockersUnavailable: true } : {},
 				...notApplied.length > 0 ? { notApplied } : {}
 			});
 		});

package/dist/tools/shared.mjs

@@ -5,6 +5,21 @@ import { z } from "zod";
 const slugEnum = (slugs) => z.enum(slugs);
 const idSchema = z.union([z.string(), z.number()]).describe("Document id.");
 /**
+* Slugs this key may write whose writes land live rather than as a draft,
+* which is what `allowLiveWrites` permits for an entity without versions.
+* Empty for every key that can only write drafts.
+*/ const liveWriteSlugs = (scope) => {
+	const live = (entities, writable) => entities.filter((entity) => writable.includes(entity.slug) && entity.allowLiveWrites && !entity.hasDrafts).map((entity) => entity.slug);
+	return [...live(scope.exposure.collections, scope.writable), ...live(scope.exposure.globals, scope.writableGlobals)];
+};
+/**
+* The sentence the write tools and the server instructions end on: what a
+* write actually does for this key.
+*/ const draftSentence = (scope) => {
+	const live = liveWriteSlugs(scope);
+	return live.length === 0 ? "Every write lands as a draft and is never published; publishing stays a human action in the admin panel." : `Writes land as drafts and are never published, except for ${live.join(", ")}, which have no drafts: a write there changes the live document immediately. Publishing anything else stays a human action in the admin panel.`;
+};
+/**
 * Widens one branch to the superset a handler sees. The widening itself is
 * unchecked — the runtime shape really does vary — so `Branch` checks what it
 * can around it.
@@ -99,4 +114,4 @@ const depthShape = (scope) => ({ depth: z.number().int().min(0).max(scope.limits
 	return translateStatic(resolved, i18n) ?? fallback;
 };
 //#endregion
-export { depthShape, idSchema, idShape, localeOf, localeShape, readTarget, slugEnum, targetShape, translateLabel };
+export { depthShape, draftSentence, idSchema, idShape, liveWriteSlugs, localeOf, localeShape, readTarget, slugEnum, targetShape, translateLabel };

package/dist/tools/validate-document.mjs

@@ -1,18 +1,16 @@
-import { jsonResult } from "../endpoint/result.mjs";
+import { jsonResult } from "../result.mjs";
 import { idShape, localeOf, localeShape, readTarget, targetShape } from "./shared.mjs";
 import { requireIdFor, resolveTarget } from "./target.mjs";
 import { defineMcpxTool } from "../types.mjs";
 import { collectPublishBlockers } from "../write/publish-blockers.mjs";
-//#region src/tools/validate-document.ts
 const validateDocument = defineMcpxTool({
 	name: "validateDocument",
 	description: `Reports what still prevents a human from publishing the draft, without writing anything. The same list patchDocument returns after a write; use it to check work or to answer "is this ready".
 
-Pass exactly one of "collection" and "global". "id" is required with "collection" and must be omitted with "global", because a global is a singleton.`,
-	annotations: {
-		readOnlyHint: true,
-		openWorldHint: false
-	},
+Pass exactly one of "collection" and "global". "id" is required with "collection" and must be omitted with "global", because a global is a singleton.
+
+Nothing is written, but the check runs the same field-level beforeValidate and beforeChange hooks a save would, so a hook with side effects fires. "publishBlockersUnavailable" means the check itself failed, so the empty list says nothing.`,
+	annotations: { openWorldHint: false },
 	isEnabled: (scope) => scope.writable.length + scope.writableGlobals.length > 0,
 	inputSchema: (scope) => ({
 		...targetShape(scope, "write", {
@@ -40,7 +38,7 @@ Pass exactly one of "collection" and "global". "id" is required with "collection
 			locale,
 			privileged: true
 		});
-		const publishBlockers = await collectPublishBlockers(scope.req, {
+		const validation = await collectPublishBlockers(scope.req, {
 			doc,
 			entity: target
 		});
@@ -48,7 +46,8 @@ Pass exactly one of "collection" and "global". "id" is required with "collection
 			...target.kind === "collection" ? { id: doc["id"] } : { global: target.slug },
 			status: doc["_status"],
 			updatedAt: doc["updatedAt"],
-			publishBlockers
+			publishBlockers: validation.blockers,
+			...validation.unavailable ? { publishBlockersUnavailable: true } : {}
 		});
 	}
 });

package/dist/types.d.mts

@@ -1,7 +1,7 @@
 import { CollectionConfig, CollectionSlug, GlobalSlug, PayloadRequest, TypedUser } from "payload";
 import { z } from "zod";
-import { CallToolResult, ServerNotification, ServerRequest, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
 import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { CallToolResult, ServerNotification, ServerRequest, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
 //#region src/types.d.ts
 declare module "payload" {
   interface RequestContext {
@@ -103,7 +103,11 @@ interface McpxToolScope {
 interface McpxTool<Shape extends z.ZodRawShape = z.ZodRawShape, Args = z.infer<z.ZodObject<Shape>>> {
   /** camelCase, unique, not one of the builtin tool names. */
   name: string;
-  description: string;
+  /**
+   * Fixed text, or text built per request so it can state what this key's
+   * writes actually do.
+   */
+  description: string | ((scope: McpxToolScope) => string);
   annotations?: ToolAnnotations;
   /**
    * Whether this key may call the tool; a tool that is not enabled never
@@ -223,5 +227,15 @@ interface McpxRequestContext {
   apiKeyId: number | string;
   capabilities: McpxResolvedCapabilities;
 }
+/**
+ * One reason a human could not publish the draft as it stands.
+ */
+interface PublishBlocker {
+  /** Resolved field label path, e.g. "Layout > Block 2 (Hero) > Title". */
+  field?: string;
+  message: string;
+  /** JSON Pointer to the offending value, e.g. "/layout/2/title". */
+  path: string;
+}
 //#endregion
-export { McpxAnyTool, McpxAuthResult, McpxCollectionCapabilities, McpxCollectionOptions, McpxExposedEntity, McpxGlobalOptions, McpxPluginOptions, McpxRequestContext, McpxResolvedCapabilities, McpxTool, McpxToolExtra, McpxToolScope, defineMcpxTool };
+export { McpxAnyTool, McpxAuthResult, McpxCollectionCapabilities, McpxCollectionOptions, McpxExposedEntity, McpxGlobalOptions, McpxPluginOptions, McpxRequestContext, McpxResolvedCapabilities, McpxTool, McpxToolExtra, McpxToolScope, PublishBlocker, defineMcpxTool };

package/dist/write/draft-guard.mjs

@@ -1,3 +1,4 @@
+import { isMcpxRequest } from "../request.mjs";
 import { APIError } from "payload";
 import { hasDraftsEnabled } from "payload/shared";
 //#region src/write/draft-guard.ts
@@ -14,11 +15,6 @@ import { hasDraftsEnabled } from "payload/shared";
 	"overwriteExistingFiles"
 ]);
 /**
-* Whether a request originated from the MCP endpoint. The endpoint stamps
-* `req.context.mcpx`, which travels into every local API call made with the
-* same `req`, including those made by custom tools.
-*/ const isMcpxRequest = (req) => req.context.mcpx !== void 0;
-/**
 * Forces every MCP write into a draft save.
 *
 * `draft` alone is not enough: Payload's update path only saves a draft when
@@ -110,4 +106,4 @@ const refusePublish = ({ collection, data, req }) => {
 	}
 }));
 //#endregion
-export { forceDraftWrite, forceDraftWriteGlobal, installDraftGuards, installGlobalDraftGuards, isMcpxRequest, refusePublish, refusePublishGlobal };
+export { forceDraftWrite, forceDraftWriteGlobal, installDraftGuards, installGlobalDraftGuards, refusePublish, refusePublishGlobal };

package/dist/write/patch.mjs

@@ -1,24 +1,45 @@
-import { JSON_POINTER_PATTERN, RESERVED_FIELD_NAMES, blockOf, describeAddressableFields, findBlocksField, splitPath } from "../schema/walk.mjs";
-import { validateWriteValue } from "../schema/shape.mjs";
+import { JSON_POINTER_PATTERN, RESERVED_FIELD_NAMES, blockOf, describeAddressableFields, findBlocksField, joinPath, splitPath } from "../schema/walk.mjs";
 import { resolveDataPointer } from "../schema/pointer.mjs";
+import { validateWriteValue } from "../schema/shape.mjs";
+import "../schema/index.mjs";
 import { z } from "zod";
 import { Pointer, applyPatch } from "rfc6902";
 //#region src/write/patch.ts
+const POINTER = z.string().regex(JSON_POINTER_PATTERN);
 /**
-* One RFC 6902 operation as accepted by `patchDocument`.
-*/ const PATCH_OPERATION_SCHEMA = z.object({
-	from: z.string().regex(JSON_POINTER_PATTERN).optional(),
-	op: z.enum([
-		"add",
-		"copy",
-		"move",
-		"remove",
-		"replace",
-		"test"
-	]),
-	path: z.string().regex(JSON_POINTER_PATTERN),
-	value: z.unknown().optional()
-}).describe("An RFC 6902 operation.");
+* One RFC 6902 operation as accepted by `patchDocument`. Discriminated on `op`
+* so an operation carries only the members RFC 6902 defines for it.
+*/ const PATCH_OPERATION_SCHEMA = z.discriminatedUnion("op", [
+	z.strictObject({
+		op: z.literal("add"),
+		path: POINTER,
+		value: z.unknown()
+	}),
+	z.strictObject({
+		op: z.literal("remove"),
+		path: POINTER
+	}),
+	z.strictObject({
+		op: z.literal("replace"),
+		path: POINTER,
+		value: z.unknown()
+	}),
+	z.strictObject({
+		from: POINTER,
+		op: z.literal("move"),
+		path: POINTER
+	}),
+	z.strictObject({
+		from: POINTER,
+		op: z.literal("copy"),
+		path: POINTER
+	}),
+	z.strictObject({
+		op: z.literal("test"),
+		path: POINTER,
+		value: z.unknown()
+	})
+]).describe("An RFC 6902 operation.");
 /**
 * Whether a pointer touches a field Payload maintains.
 */ const isReservedPointer = (pointer) => pointer.split("/").slice(1).some((segment) => RESERVED_FIELD_NAMES.has(segment));
@@ -87,59 +108,112 @@ const isPlainObject = (value) => typeof value === "object" && value !== null &&
 	return next;
 };
 /**
-* Applies a patch to a deep copy of the document, so a failing operation
-* leaves the original untouched and nothing partial is ever written.
-*/ const applyPatchToCopy = (doc, patches) => {
-	const next = structuredClone(doc);
-	const prepared = patches.map((operation) => {
-		const cloned = "value" in operation ? {
-			...operation,
-			value: structuredClone(operation.value)
-		} : operation;
-		if (cloned.op === "replace" && !isElementPointer(cloned.path) && Pointer.fromJSON(cloned.path).get(next) === void 0) return {
-			...cloned,
-			op: "add"
-		};
-		return cloned;
-	});
-	const problems = applyPatch(next, prepared).flatMap((error, index) => error ? [`patches[${String(index)}]: ${error.message}`] : []);
-	if (problems.length > 0) return { problems };
-	reconcileRowIds(next, doc);
-	return { next };
+* The operation as it is applied: values are cloned so the written document
+* never shares references with the caller's operations, and a `replace` of a
+* field the target locale has no value for becomes an `add`, which is what
+* RFC 6902 requires when nothing is there to replace.
+*/ const prepare = (operation, doc) => {
+	const cloned = "value" in operation ? {
+		...operation,
+		value: structuredClone(operation.value)
+	} : operation;
+	return cloned.op === "replace" && !isElementPointer(cloned.path) && Pointer.fromJSON(cloned.path).get(doc) === void 0 ? {
+		...cloned,
+		op: "add"
+	} : cloned;
 };
 /**
-* Checks every operation against the schema before any is applied.
-*
-* A partially applied batch is worse than a refused one, so this returns all
-* problems and the caller applies nothing unless the list is empty.
-*/ const findPatchProblems = (config, target) => target.patches.flatMap((operation, index) => {
-	const at = `patches[${String(index)}]`;
-	const pointers = [operation.path, ..."from" in operation && operation.from ? [operation.from] : []];
-	if (pointers.includes("")) return [`${at}: an empty pointer addresses the whole document. Address a field instead.`];
+* The value an operation writes at its path: the one it carries, or the one it
+* takes from `from`. A `remove` writes nothing.
+*/ const effectiveValue = (operation, doc) => {
+	if ("value" in operation) return operation.value;
+	return "from" in operation ? Pointer.fromJSON(operation.from).get(doc) : void 0;
+};
+/**
+* Whether a resolved pointer lands in a read-only field. A pointer that stops
+* short of one addresses a subtree, and the fields beneath it decide.
+*/ const resolvesReadOnly = (resolution) => {
+	if (resolution.descriptor) return resolution.descriptor.readOnly === true;
+	const below = describeAddressableFields(resolution.fields).filter((descriptor) => resolution.prefix.every((part, offset) => part === splitPath(descriptor.path)[offset]));
+	return below.length > 0 && below.every((descriptor) => descriptor.readOnly);
+};
+/**
+* Whether the pointer addresses something read-only. An element carries no
+* descriptor of its own, so the field it belongs to is read one segment up.
+*/ const isReadOnlyPointer = (config, target) => resolvesReadOnly(resolveDataPointer(config, {
+	doc: target.doc,
+	pointer: isElementPointer(target.pointer) ? joinPath(splitPath(target.pointer).slice(0, -1)) : target.pointer,
+	ref: target.ref
+}));
+/**
+* Checks one operation against the schema, in the state the document is in
+* when that operation runs. Both pointers must resolve, whatever the operation
+* writes at its path must pass write validation, and what it drops must not sit
+* in a read-only field.
+*/ const findOperationProblems = (config, target) => {
+	const { doc, operation, ref } = target;
+	const pointers = [operation.path, ..."from" in operation ? [operation.from] : []];
+	if (pointers.includes("")) return ["an empty pointer addresses the whole document. Address a field instead."];
 	const reserved = pointers.find(isReservedPointer);
-	if (reserved !== void 0) return [`${at}: "${reserved}" addresses a field Payload maintains. Drafts are the only thing this tool writes, and id, _status, createdAt and updatedAt are not writable.`];
+	if (reserved !== void 0) return [`"${reserved}" addresses a field Payload maintains. Drafts are the only thing this tool writes, and id, _status, createdAt and updatedAt are not writable.`];
 	const dropped = droppedPointer(operation);
-	if (dropped !== void 0 && !isElementPointer(dropped)) return [`${at}: "${dropped}" is a field, not a list element, and removing it would do nothing. The patched document is written whole, and Payload keeps any field absent from a write rather than clearing it. Use "replace" with null to clear a field, or with [] to empty a list.`];
-	const value = "value" in operation ? operation.value : void 0;
+	if (dropped !== void 0 && !isElementPointer(dropped)) return [`"${dropped}" is a field, not a list element, and removing it would do nothing. The patched document is written whole, and Payload keeps any field absent from a write rather than clearing it. Use "replace" with null to clear a field, or with [] to empty a list.`];
 	try {
-		const moved = "from" in operation && operation.from ? Pointer.fromJSON(operation.from).get(target.doc) : void 0;
+		const value = effectiveValue(operation, doc);
+		if (value !== void 0 && operation.op !== "test" && isReadOnlyPointer(config, {
+			doc,
+			pointer: operation.path,
+			ref
+		})) return [`"${operation.path}" is read-only and cannot be written.`];
+		if (dropped !== void 0 && isReadOnlyPointer(config, {
+			doc,
+			pointer: dropped,
+			ref
+		})) return [`"${dropped}" sits in a read-only field and cannot be removed.`];
 		for (const pointer of pointers) {
 			const resolution = resolveDataPointer(config, {
-				addedValue: value ?? moved,
-				doc: target.doc,
+				addedValue: value,
+				doc,
 				pointer,
-				ref: target.ref
+				ref
 			});
-			if (pointer === operation.path && value !== void 0) return validateWriteValue(config, {
-				pointer,
-				resolution
-			}, value).map((problem) => `${at}: ${problem}`);
+			if (pointer === operation.path && value !== void 0) {
+				const problems = validateWriteValue(config, {
+					pointer,
+					resolution
+				}, value);
+				if (problems.length > 0) return problems;
+			}
 		}
 		return [];
 	} catch (error) {
-		return [`${at}: ${error instanceof Error ? error.message : "invalid"}`];
+		return [error instanceof Error ? error.message : "invalid"];
+	}
+};
+/**
+* Validates and applies every operation against one evolving copy of the
+* document, so an operation that depends on an earlier one resolves against
+* the shape it actually modifies.
+*
+* The copy means a failing operation leaves the original untouched, and the
+* caller writes nothing unless the whole batch came back applied, so a
+* partially applied batch is never persisted.
+*/ const applyPatchOperations = (config, target) => {
+	const next = structuredClone(target.doc);
+	for (const [index, operation] of target.patches.entries()) {
+		const at = `patches[${String(index)}]`;
+		const problems = findOperationProblems(config, {
+			doc: next,
+			operation,
+			ref: target.ref
+		});
+		if (problems.length > 0) return { problems: problems.map((problem) => `${at}: ${problem}`) };
+		const [error] = applyPatch(next, [prepare(operation, next)]);
+		if (error) return { problems: [`${at}: ${error.message}`] };
 	}
-});
+	reconcileRowIds(next, target.doc);
+	return { next };
+};
 /**
 * Keys Payload manages on a row that travel back into the write unchanged.
 */ const ROW_KEYS = /* @__PURE__ */ new Set([
@@ -216,4 +290,4 @@ const isPlainObject = (value) => typeof value === "object" && value !== null &&
 	});
 };
 //#endregion
-export { PATCH_OPERATION_SCHEMA, applyPatchToCopy, buildWriteData, droppedPointer, findPatchProblems, isElementPointer, isReservedPointer, stripRowIds };
+export { PATCH_OPERATION_SCHEMA, applyPatchOperations, buildWriteData, droppedPointer, isElementPointer, isReservedPointer, stripRowIds };

package/dist/write/publish-blockers.mjs

@@ -1,4 +1,5 @@
 import { pointerFromPayloadPath } from "../schema/walk.mjs";
+import "../schema/index.mjs";
 import { beforeChangeTraverseFields, beforeValidateTraverseFields } from "payload";
 //#region src/write/publish-blockers.ts
 /**
@@ -18,6 +19,9 @@ import { beforeChangeTraverseFields, beforeValidateTraverseFields } from "payloa
 *
 * Limits: only the locale the doc was read in is checked, and field-level
 * `beforeChange` hooks run again, which is safe only for pure ones.
+*
+* `unavailable` marks a traversal that threw, which is not the same answer as
+* a document with nothing wrong with it.
 */ const collectPublishBlockers = async (req, target) => {
 	const { doc, entity } = target;
 	const id = doc["id"];
@@ -62,13 +66,16 @@ import { beforeChangeTraverseFields, beforeValidateTraverseFields } from "payloa
 		});
 	} catch (error) {
 		req.payload.logger.warn(`[payloadcms-mcpx] Could not validate the ${entity.slug} draft: ${error instanceof Error ? error.message : "unknown error"}`);
-		return [];
+		return {
+			blockers: [],
+			unavailable: true
+		};
 	}
-	return errors.map((error) => ({
+	return { blockers: errors.map((error) => ({
 		message: error.message,
 		path: pointerFromPayloadPath(error.path),
 		...typeof error.label === "string" ? { field: error.label } : {}
-	}));
+	})) };
 };
 //#endregion
 export { collectPublishBlockers };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@abinnovision/payloadcms-mcpx",
-  "version": "1.0.0-beta.11",
+  "version": "1.0.0-beta.12",
   "description": "Payload CMS plugin exposing a fixed, schema-aware MCP tool surface with draft-only writes and per-API-key capabilities.",
   "keywords": [
     "payload",

package/dist/i18n.d.mts

@@ -1 +0,0 @@
-import { PayloadRequest } from "payload";

package/dist/schema/lexical.d.mts

@@ -1 +0,0 @@
-import "payload";

package/dist/schema/walk.d.mts

@@ -1,3 +0,0 @@
-import "./lexical.mjs";
-import "../i18n.mjs";
-import "payload";

package/dist/tools/target.d.mts

@@ -1,3 +0,0 @@
-import "../types.mjs";
-import "../schema/walk.mjs";
-import "payload";

package/dist/write/publish-blockers.d.mts

@@ -1,15 +0,0 @@
-import "../tools/target.mjs";
-import { PayloadRequest } from "payload";
-//#region src/write/publish-blockers.d.ts
-/**
- * One reason a human could not publish the draft as it stands.
- */
-interface PublishBlocker {
-  /** Resolved field label path, e.g. "Layout > Block 2 (Hero) > Title". */
-  field?: string;
-  message: string;
-  /** JSON Pointer to the offending value, e.g. "/layout/2/title". */
-  path: string;
-}
-//#endregion
-export type { PublishBlocker };