@abinnovision/payloadcms-mcpx 1.0.0-beta.13 → 1.0.0-beta.15

package/dist/types.d.mts

@@ -22,27 +22,18 @@ declare module "payload" {
  *   land on, it means the write itself is permitted and lands live.
  */
 type McpxWriteMode = "draft" | "live" | false;
-/**
- * What an exposed collection offers to MCP clients. A key can only enable
- * what the config exposes here.
- */
+/** A key can only enable what the config exposes here. */
 interface McpxCollectionOptions {
-  /**
-   * Expose `describeSchema`, `findDocuments` and `getDocument`. Default `true`.
-   */
+  /** Expose `describeSchema`, `findDocuments`, `getDocument`. Default `true`. */
   read?: boolean;
   /**
-   * Expose `patchDocument`, `createDocument` and `validateDocument`, and how
-   * far those writes reach. Default `false`.
+   * Expose `patchDocument`, `validateDocument` and, unless this is an upload
+   * collection, `createDocument`, and how far those writes reach. Default
+   * `false`.
    */
   write?: McpxWriteMode;
 }
-/**
- * What an exposed global offers to MCP clients. Structurally the same as
- * {@link McpxCollectionOptions}, kept separate because the tools it names
- * differ: a global is a singleton, so neither `findDocuments` nor
- * `createDocument` reaches one.
- */
+/** A singleton, so neither `findDocuments` nor `createDocument` reaches one. */
 interface McpxGlobalOptions {
   /** Expose `describeSchema` and `getDocument`. Default `true`. */
   read?: boolean;
@@ -53,77 +44,60 @@ interface McpxGlobalOptions {
   write?: McpxWriteMode;
 }
 type McpxToolExtra = RequestHandlerExtra<ServerRequest, ServerNotification>;
-/**
- * A collection or global the plugin config exposes, before an API key's
- * checkboxes narrow it further.
- */
+/** What the config exposes, before an API key's checkboxes narrow it. */
 interface McpxExposedEntity {
   slug: string;
   read: boolean;
   write: McpxWriteMode;
   hasDrafts: boolean;
+  /** An upload document is a file, and no tool here can supply one. */
+  isUpload: boolean;
   /** Name of the capability group on the key document. */
   fieldName: string;
 }
-/**
- * Everything a tool knows about the current request: the authenticated
- * request, what this key may touch and the limits in force.
- */
+/** What a tool knows about the current request. */
 interface McpxToolScope {
   req: PayloadRequest;
   capabilities: McpxResolvedCapabilities;
-  /** Collection slugs the key may read / write / publish. */
   readable: string[];
   writable: string[];
   publishable: string[];
-  /** Global slugs the key may read / write / publish. */
   readableGlobals: string[];
   writableGlobals: string[];
   publishableGlobals: string[];
-  /** Configured locale codes, or `null` when localization is off. */
+  /** `null` when localization is off. */
   locales: null | string[];
   defaultLocale: null | string;
   limits: {
     maxLimit: number;
     maxDepth: number;
   };
-  /** What the plugin config exposes, before the key's checkboxes apply. */
   exposure: {
     collections: McpxExposedEntity[];
     globals: McpxExposedEntity[];
   };
 }
 /**
- * A tool. The builtins and any tool passed through `options.tools` use this
- * same shape and register through the same loop. Every tool runs with
- * `req.user` resolved from the key and `req.context.mcpx` set.
- *
- * `Args` only needs stating when `inputSchema` is built per request, which
- * leaves no static shape to infer from; a tool with a fixed shape gets its
- * argument type from that shape.
+ * A tool, builtin or custom. Runs with `req.user` resolved from the key and
+ * `req.context.mcpx` set. `Args` only needs stating when `inputSchema` is built
+ * per request, leaving no static shape to infer from.
  */
 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;
-  /**
-   * Fixed text, or text built per request so it can state what this key's
-   * writes actually do.
-   */
+  /** 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
-   * appears in `tools/list`. Defaults to the tool's own checkbox on the API
-   * key, which the builtins replace to derive availability from the key's
-   * collection and global capabilities. Defining it replaces that checkbox
-   * check rather than adding to it.
+   * A tool that is not enabled never appears in `tools/list`. Defaults to the
+   * tool's own checkbox on the API key; defining it replaces that check rather
+   * than adding to it.
    */
   isEnabled?: (scope: McpxToolScope) => boolean;
   /**
-   * A fixed shape, or one built per request so enums can be narrowed to what
-   * the key may touch. Registered strictly either way: an unknown argument is
-   * rejected by name instead of being stripped and the tool answering as if
-   * it had not been passed.
+   * Built per request so enums can be narrowed to what the key may touch.
+   * Registered strictly either way: an unknown argument is rejected by name
+   * rather than stripped.
    */
   inputSchema?: Shape | ((scope: McpxToolScope) => z.ZodRawShape);
   handler(ctx: {
@@ -134,44 +108,36 @@ interface McpxTool<Shape extends z.ZodRawShape = z.ZodRawShape, Args = z.infer<z
     extra: McpxToolExtra;
   }): CallToolResult | Promise<CallToolResult>;
 }
-/**
- * A tool with its argument type erased, which is how a registry holds tools of
- * differing input shapes. Each tool validates its own arguments through its
- * input schema.
- */
+/** Argument type erased, so a registry can hold tools of differing shapes. */
 type McpxAnyTool = McpxTool<z.ZodRawShape, never>;
-/**
- * Defines a tool with a fixed input shape. The handler's arguments are
- * inferred from that shape.
- */
+/** Fixed shape; arguments inferred from it. */
 declare function defineMcpxTool<Shape extends z.ZodRawShape>(tool: McpxTool<Shape> & {
   inputSchema?: Shape;
 }): McpxTool<Shape>;
-/**
- * Defines a tool whose input shape is built per request and returned as an
- * object literal. The handler's arguments are inferred from that literal, so
- * a scope-narrowed enum still types as the value it produces.
- */
+/** Per-request shape returned as an object literal; arguments inferred from it. */
 declare function defineMcpxTool<Shape extends z.ZodRawShape>(tool: McpxTool<Shape> & {
   inputSchema: (scope: McpxToolScope) => Shape;
 }): McpxAnyTool;
 /**
- * Defines a tool whose input shape is assembled from helpers that erase to
- * `z.ZodRawShape`, as the builtins do. Nothing is left to infer from, so the
- * handler's arguments are stated instead: `defineMcpxTool<Args>({ ... })`.
+ * Per-request shape built from helpers that erase to `z.ZodRawShape`, as the
+ * builtins do. Nothing to infer from, so state the arguments instead.
  */
 declare function defineMcpxTool<Args>(tool: McpxTool<z.ZodRawShape, Args> & {
   inputSchema: (scope: McpxToolScope) => z.ZodRawShape;
 }): McpxAnyTool;
-/**
- * Outcome of resolving an API key. `user` must carry `collection`.
- */
 interface McpxAuthResult {
+  /** Must carry `collection`. */
   user: TypedUser;
   apiKeyId: number | string;
   /** The `capabilities` group as stored on the key document. */
   capabilities: unknown;
 }
+/**
+ * Everything the plugin accepts. `collections` is the only required option.
+ *
+ * A type alias rather than an interface: `definePlugin` constrains its options
+ * to `Record<string, unknown>`, which interfaces do not satisfy.
+ */
 type McpxPluginOptions = {
   /** Allow-list of collections. `true` is shorthand for `{ read: true }`. */
   collections: Partial<Record<CollectionSlug, McpxCollectionOptions | true>>;
@@ -213,30 +179,25 @@ type McpxPluginOptions = {
     version?: string;
   };
 };
+/** What a key may do with one entity. Globals reuse this shape. */
 interface McpxCollectionCapabilities {
   read: boolean;
   write: boolean;
-  /**
-   * Whether the key may publish this entity's draft. Only ever true where the
-   * config sets `write: "live"` and the entity has drafts.
-   */
+  /** Only ever true where the config sets `write: "live"` and drafts exist. */
   publish: boolean;
 }
-/**
- * Capabilities in force for one request: plugin config AND key checkboxes.
- */
+/** In force for one request: plugin config AND key checkboxes. */
 interface McpxResolvedCapabilities {
   collections: Record<string, McpxCollectionCapabilities>;
   globals: Record<string, McpxCollectionCapabilities>;
   tools: Record<string, boolean>;
 }
+/** Stamped on `req.context.mcpx`; see {@link isMcpxRequest}. */
 interface McpxRequestContext {
   apiKeyId: number | string;
   capabilities: McpxResolvedCapabilities;
 }
-/**
- * One reason a human could not publish the draft as it stands.
- */
+/** 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;

package/dist/write/draft-guard.mjs

@@ -1,12 +1,9 @@
-import { claimPublishIntent, isClaimedPublish } from "./publish-intent.mjs";
+import { hasPublishIntent, takePublishIntent } from "./publish-intent.mjs";
 import { isMcpxRequest } from "../request.mjs";
 import { APIError } from "payload";
 import { hasDraftsEnabled } from "payload/shared";
 //#region src/write/draft-guard.ts
-/**
-* Operation arguments that widen or redirect a write. Cleared on every MCP
-* create and update, publishes included, so a tool cannot smuggle them in.
-*/ const STRIPPED_ARGS = /* @__PURE__ */ new Set([
+/** Cleared on every MCP write, publishes included, so none can be smuggled in. */ const STRIPPED_ARGS = /* @__PURE__ */ new Set([
 	"where",
 	"publishAllLocales",
 	"publishSpecificLocale",
@@ -21,19 +18,13 @@ import { hasDraftsEnabled } from "payload/shared";
 *
 * `draft` alone is not enough: Payload's update path only saves a draft when
 * `data._status !== "published"`, so `_status` is dropped and left to Payload.
-* This runs as `beforeOperation`, before Payload reads any of these arguments,
-* so it holds for every create and update on an MCP request, not only the
-* builtin tools. Deletes are not guarded in v1; custom tools that delete are
-* the integrator's responsibility. `restoreVersion` and `duplicate` are outside
-* the operation filter too — `restoreVersion` is caught by `refusePublish`
-* because it runs the collection's `beforeChange` hooks, and anything going
-* straight to `payload.db` bypasses all of this.
+* Writing it here rather than in the tool keeps the tool honest, since this is
+* the only thing that can grant a publish.
 *
-* On a claimed publish the argument scrubbing is unchanged — the whole
-* `STRIPPED_ARGS` list still goes, `deletedAt` still goes, autosave, locks and
-* trash are still forced off. Only `draft` and `_status` differ. Writing
-* `_status` here rather than in the tool keeps the tool honest: it asks to
-* publish, and this is the only thing that can grant it.
+* Not covered: deletes, `duplicate`, files (the local API lifts `file` and
+* `filePath` onto `req` before this runs), and anything going straight to
+* `payload.db`. `restoreVersion` is caught by {@link refusePublish} instead,
+* because it runs the collection's `beforeChange` hooks.
 */ const scrubWriteArgs = (args, publishing) => {
 	const next = Object.fromEntries(Object.entries(args).filter(([key]) => !STRIPPED_ARGS.has(key)));
 	if (next["data"] && typeof next["data"] === "object") {
@@ -50,72 +41,49 @@ import { hasDraftsEnabled } from "payload/shared";
 	return next;
 };
 const forceDraftWrite = (hookArgs) => {
-	const { args, collection, operation, req } = hookArgs;
+	const { args, operation, req } = hookArgs;
 	if (!isMcpxRequest(req) || operation !== "create" && operation !== "update") return args;
-	const publishing = operation === "update" && claimPublishIntent({
-		kind: "collection",
-		slug: collection.slug,
-		id: args.id
-	});
+	const publishing = operation === "update" && hasPublishIntent(args.data);
 	return scrubWriteArgs(args, publishing);
 };
 /**
-* The global counterpart of {@link forceDraftWrite}, with one important
-* difference: Payload's `updateGlobal` destructures `draft`,
-* `publishAllLocales`, `publishSpecificLocale`, `unpublishAllLocales` and
-* `overrideLock` *before* it runs `beforeOperation`, and re-reads only `data`
-* afterwards. Setting those here is a no-op. What still lands is `data`, and
-* that is what the global draft guarantee actually rests on: `_status` is
-* stripped, so a rogue `updateGlobal({ draft: false })` reaches
-* {@link refusePublishGlobal} with no status and is refused there. The alarm,
-* not the correction, is load-bearing for globals.
-*
-* The publish branch matters for the same reason. `publishDocument` passes
-* `draft: false` at the call site because the hook cannot, and this hook must
-* put `_status` back rather than strip it.
-*
-* The global operation union has no `create` member because a global always
-* exists, so only `update` is intercepted.
+* The global counterpart of {@link forceDraftWrite}, with one difference that
+* decides where the guarantee lives: `updateGlobal` destructures `draft` and
+* the publish arguments *before* it runs `beforeOperation` and re-reads only
+* `data` afterwards, so setting them here is a no-op. What lands is `data` with
+* `_status` stripped, which makes {@link refusePublishGlobal} the alarm that
+* actually holds the line. `publishDocument` therefore passes `draft: false` at
+* the call site, and this hook puts `_status` back rather than stripping it.
 */ const forceDraftWriteGlobal = (hookArgs) => {
-	const { global, operation, req } = hookArgs;
+	const { operation, req } = hookArgs;
 	const args = hookArgs.args;
 	if (!isMcpxRequest(req) || operation !== "update") return args;
-	const publishing = claimPublishIntent({
-		kind: "global",
-		slug: global.slug
-	});
-	return scrubWriteArgs(args, publishing);
+	return scrubWriteArgs(args, hasPublishIntent(args["data"]));
 };
 /**
-* Refuses an MCP write that would still not land as a draft, and — on the one
-* operation that claimed a publish intent — refuses anything that would not
-* land as a publish. An alarm rather than the guarantee for collections, where
-* `forceDraftWrite` should make it unreachable; the guarantee itself for
-* globals, per {@link forceDraftWriteGlobal}. It throws instead of correcting
-* `_status` because Payload has already chosen the write branch by the time a
-* `beforeChange` hook runs.
-*/ const refuseUnlessExpected = (req, target, data) => {
+* Throws instead of correcting `_status`, because Payload has already chosen
+* the write branch by the time a `beforeChange` hook runs. Unreachable for a
+* collection if {@link forceDraftWrite} did its job; the guarantee itself for a
+* global. Last hook that needs the marker, so it takes it off.
+*/ const refuseUnlessExpected = (req, slug, data) => {
+	const publishing = takePublishIntent(data);
 	if (!isMcpxRequest(req)) return;
 	const status = data._status;
-	const publishing = isClaimedPublish(target.kind, target.slug);
 	const expected = publishing ? "published" : "draft";
 	if (status === expected) return;
-	req.payload.logger.warn(`[payloadcms-mcpx] Refused a write to ${target.slug} that would not have been a ${expected} (_status: ${String(status)}).`);
+	req.payload.logger.warn(`[payloadcms-mcpx] Refused a write to ${slug} that would not have been a ${expected} (_status: ${String(status)}).`);
 	throw new APIError(publishing ? "This publish was refused because it would not have saved a published document." : "MCP clients may only write drafts. This write was refused because it would not have been saved as one. Use publishDocument to publish.", 403);
 };
-const refusePublish = ({ collection, data, req }) => {
-	refuseUnlessExpected(req, {
-		kind: "collection",
-		slug: collection.slug
-	}, data);
+/**
+* Installs {@link refuseUnlessExpected} on every collection write. Returns
+* `data` unchanged when the write is allowed; the hook exists for its throw.
+*/ const refusePublish = ({ collection, data, req }) => {
+	refuseUnlessExpected(req, collection.slug, data);
 	return data;
 };
-/** The global counterpart of {@link refusePublish}. */ const refusePublishGlobal = ({ data, global, req }) => {
+const refusePublishGlobal = ({ data, global, req }) => {
 	const next = data;
-	refuseUnlessExpected(req, {
-		kind: "global",
-		slug: global.slug
-	}, next);
+	refuseUnlessExpected(req, global.slug, next);
 	return next;
 };
 /**

package/dist/write/patch.mjs

@@ -6,10 +6,7 @@ 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`. Discriminated on `op`
-* so an operation carries only the members RFC 6902 defines for it.
-*/ const PATCH_OPERATION_SCHEMA = z.discriminatedUnion("op", [
+/** Discriminated on `op`, so an operation carries only its own members. */ const PATCH_OPERATION_SCHEMA = z.discriminatedUnion("op", [
 	z.strictObject({
 		op: z.literal("add"),
 		path: POINTER,
@@ -40,31 +37,18 @@ const POINTER = z.string().regex(JSON_POINTER_PATTERN);
 		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));
-/**
-* The pointer an operation removes a value from, if it removes one at all.
-*/ const droppedPointer = (operation) => {
+const isReservedPointer = (pointer) => pointer.split("/").slice(1).some((segment) => RESERVED_FIELD_NAMES.has(segment));
+const droppedPointer = (operation) => {
 	if (operation.op === "remove") return operation.path;
 	return operation.op === "move" ? operation.from : void 0;
 };
-/**
-* Whether a pointer addresses a list element rather than a field.
-*/ const isElementPointer = (pointer) => {
+const isElementPointer = (pointer) => {
 	const last = pointer.split("/").pop() ?? "";
 	return last === "-" || /^\d+$/.test(last);
 };
 const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-/**
-* A Lexical editor state. Its nodes manage their own ids, so it is never
-* descended into.
-*/ const isRichTextState = (value) => isPlainObject(value["root"]) && Array.isArray(value["root"]["children"]);
-/**
-* Visits every row in a value: a plain object that carries `blockType` or
-* sits directly inside an array. Rich text states manage their own nodes and
-* are never descended into.
-*/ const walkRows = (value, visit, isRow = false) => {
+/** Its nodes manage their own ids, so it is never descended into. */ const isRichTextState = (value) => isPlainObject(value["root"]) && Array.isArray(value["root"]["children"]);
+/** A row is a plain object carrying `blockType`, or one sitting in an array. */ const walkRows = (value, visit, isRow = false) => {
 	if (Array.isArray(value)) {
 		for (const entry of value) walkRows(entry, visit, true);
 		return;
@@ -97,10 +81,7 @@ const isPlainObject = (value) => typeof value === "object" && value !== null &&
 		delete row["id"];
 	});
 };
-/**
-* Drops every row id from a copy of `value`. Used on create, where no stored
-* row exists and any incoming id is client-invented.
-*/ const stripRowIds = (value) => {
+/** For create, where no stored row exists and any incoming id is invented. */ const stripRowIds = (value) => {
 	const next = structuredClone(value);
 	walkRows(next, (row) => {
 		delete row["id"];
@@ -122,34 +103,24 @@ const isPlainObject = (value) => typeof value === "object" && value !== null &&
 		op: "add"
 	} : cloned;
 };
-/**
-* 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) => {
+/** The one it carries, or the one it takes from `from`. `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) => {
+/** A pointer stopping short addresses a subtree; the fields beneath 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, {
+/** An element has no descriptor, so its field 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.
+* Checked against the document as it stands when this operation runs: both
+* pointers must resolve, the written value 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] : []];
@@ -191,13 +162,10 @@ const isPlainObject = (value) => typeof value === "object" && value !== null &&
 	}
 };
 /**
-* 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.
+* One evolving copy, so an operation depending on an earlier one resolves
+* against the shape it actually modifies, and a failure leaves the original
+* untouched. The caller writes nothing unless the whole batch came back
+* applied, so a partial batch is never persisted.
 */ const applyPatchOperations = (config, target) => {
 	const next = structuredClone(target.doc);
 	for (const [index, operation] of target.patches.entries()) {
@@ -214,18 +182,15 @@ const isPlainObject = (value) => typeof value === "object" && value !== null &&
 	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([
+const ROW_KEYS = /* @__PURE__ */ new Set([
 	"blockName",
 	"blockType",
 	"id"
 ]);
 /**
-* Picks the keys the schema walker describes out of `value`, descending into
-* groups, named tabs, arrays and blocks. Everything Payload maintains or
-* derives (`_status`, timestamps, join and virtual fields, upload base fields)
-* is left out, so the write-back carries only what a client could have set.
+* Everything Payload maintains or derives (`_status`, timestamps, join and
+* virtual fields, upload base fields) is left out, so the write-back carries
+* only what a client could have set.
 */ const pickDescribed = (config, value, at) => {
 	const { fields, prefix, isRow } = at;
 	const relative = describeAddressableFields(fields).flatMap((descriptor) => {
@@ -279,10 +244,7 @@ const isPlainObject = (value) => typeof value === "object" && value !== null &&
 	}
 	return result;
 };
-/**
-* The data handed to `payload.update` after a patch: the patched document
-* reduced to the fields the client may write, plus row identity keys.
-*/ const buildWriteData = (config, target, doc) => {
+/** The patched document reduced to writable fields, plus row identity keys. */ const buildWriteData = (config, target, doc) => {
 	return pickDescribed(config, doc, {
 		fields: target.flattenedFields,
 		prefix: [],

package/dist/write/publish-blockers.mjs

@@ -5,23 +5,17 @@ import { beforeChangeTraverseFields, beforeValidateTraverseFields } from "payloa
 /**
 * Runs Payload's own field validation over a draft without saving anything.
 *
-* Draft saves skip validation unless `versions.drafts.validate` is set, so an
-* agent building a document incrementally gets no signal until a human presses
-* Publish. This is the same traversal a real save runs, exported from
-* `payload`, called with `skipValidation: false` so it collects into `errors`
-* instead of throwing. The `beforeValidate` pass runs first because some field
-* hooks (Lexical's) prepare state in `context` that their `beforeChange`
-* counterpart depends on.
+* The same traversal a real save runs, exported from `payload` and called with
+* `skipValidation: false` so it collects into `errors` instead of throwing. The
+* `beforeValidate` pass runs first because some field hooks (Lexical's) prepare
+* state in `context` that their `beforeChange` counterpart depends on.
 *
 * Nothing is written: `data` is a copy, the context is a scratch copy and the
 * locale merge actions are discarded. `overrideAccess` is true because the
 * question is "could this be published", not "may this client write it".
 *
-* 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.
+* `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"];

package/dist/write/publish-intent.mjs

@@ -1,39 +1,17 @@
-import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
 //#region src/write/publish-intent.ts
-const store = new AsyncLocalStorage();
-/** Runs `fn` with `intent` in force. */ const withPublishIntent = async (intent, fn) => await store.run({
-	...intent,
-	claimed: false
-}, fn);
-const activeFor = (target) => {
-	const active = store.getStore();
-	return active && active.kind === target.kind && active.slug === target.slug && active.id === target.id ? active : void 0;
-};
-/**
-* Claims the intent for one operation, which `beforeOperation` does so that a
-* re-entrant write to the same document — an `afterChange` hook calling
-* `payload.update`, say — cannot ride along on it. Only the first operation to
-* ask gets it.
-*/ const claimPublishIntent = (target) => {
-	const active = activeFor(target);
-	if (!active || active.claimed) return false;
-	active.claimed = true;
+const PUBLISH_INTENT = "__mcpxPublishIntent";
+const TOKEN = randomUUID();
+const withPublishIntent = (data) => ({
+	...data,
+	[PUBLISH_INTENT]: TOKEN
+});
+const carries = (data) => typeof data === "object" && data !== null && data[PUBLISH_INTENT] === TOKEN;
+const hasPublishIntent = (data) => carries(data);
+/** Asked by the last hook that needs it, so it takes the marker off. */ const takePublishIntent = (data) => {
+	if (!carries(data)) return false;
+	delete data[PUBLISH_INTENT];
 	return true;
 };
-/**
-* Whether this change belongs to the operation that claimed the intent, which
-* is what lets the `beforeChange` alarm accept a published status.
-*
-* The id is deliberately not compared here. A `beforeChange` hook reads it from
-* the loaded document, where Payload has already coerced it to the collection's
-* id type, while the claim above saw the raw tool argument; comparing the two
-* would refuse a legitimate publish over `1` versus `"1"`. Nothing is lost: a
-* nested write to another document of the same collection during the publish
-* cannot claim the intent, so `forceDraftWrite` has already stripped its
-* `_status` and it fails the alarm on that.
-*/ const isClaimedPublish = (kind, slug) => {
-	const active = store.getStore();
-	return active?.kind === kind && active.slug === slug && active.claimed;
-};
 //#endregion
-export { claimPublishIntent, isClaimedPublish, withPublishIntent };
+export { hasPublishIntent, takePublishIntent, withPublishIntent };

package/dist/write/transaction.mjs

@@ -1,9 +1,8 @@
 import { commitTransaction, initTransaction, killTransaction } from "payload";
 //#region src/write/transaction.ts
 /**
-* Runs `fn` inside one database transaction on `req`, so a read followed by a
-* write is committed or rolled back together. Adapters without transaction
-* support, or a request that already owns one, run `fn` as is.
+* Adapters without transaction support, or a request that already owns one, run
+* `fn` as is.
 *
 * Atomicity, not isolation: neither SQLite nor Postgres at read committed locks
 * the row on the read, so an `expectedUpdatedAt` check remains best effort. Nor

package/package.json

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