@abinnovision/payloadcms-mcpx 1.0.0-beta.4 → 1.0.0-beta.5

package/dist/tools/get-document.mjs

@@ -1,20 +1,26 @@
 import { JSON_POINTER_PATTERN } from "../schema/walk.mjs";
 import { errorResult, jsonResult } from "../endpoint/result.mjs";
-import { collectionEnum, depthShape, ensureAllowed, idSchema, localeOf, localeShape } from "./shared.mjs";
+import { depthShape, idShape, localeOf, localeShape, targetShape } from "./shared.mjs";
+import { requireIdFor, resolveTarget } from "./target.mjs";
 import { z } from "zod";
 import { Pointer } from "rfc6902";
 //#region src/tools/get-document.ts
 const getDocument = {
 	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.`,
+	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.
+
+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
 	},
-	isEnabled: (scope) => scope.readable.length > 0,
+	isEnabled: (scope) => scope.readable.length + scope.readableGlobals.length > 0,
 	inputSchema: (scope) => ({
-		collection: collectionEnum(scope.readable).describe("Collection holding the document."),
-		id: idSchema,
+		...targetShape(scope, "read", {
+			collection: "Collection holding the document.",
+			global: "Global to read."
+		}),
+		...idShape(scope, "read"),
 		path: z.string().regex(JSON_POINTER_PATTERN).optional().describe("JSON pointer to return only a subtree, e.g. \"/layout/sections/0\"."),
 		...depthShape(scope),
 		...localeShape(scope, {
@@ -24,17 +30,24 @@ const getDocument = {
 		draft: z.boolean().optional().describe("Return the latest draft. Default true.")
 	}),
 	handler: async (args, scope) => {
-		ensureAllowed(scope, args.collection, "read");
+		const target = resolveTarget(scope, args, "read");
+		const id = requireIdFor(target, args.id);
 		const locale = localeOf(scope, args.locale);
-		const doc = await scope.req.payload.findByID({
-			collection: args.collection,
-			id: args.id,
+		const shared = {
 			depth: args.depth ?? 0,
 			draft: args.draft ?? true,
 			overrideAccess: false,
 			req: scope.req,
 			...locale === void 0 ? {} : { locale }
-		});
+		};
+		const doc = await (target.kind === "collection" ? scope.req.payload.findByID({
+			...shared,
+			collection: target.slug,
+			id
+		}) : scope.req.payload.findGlobal({
+			...shared,
+			slug: target.slug
+		}));
 		if (args.path === void 0 || args.path === "") return jsonResult(doc);
 		let value;
 		try {
@@ -43,7 +56,7 @@ const getDocument = {
 			return errorResult(`"${args.path}" is not a valid JSON pointer.`);
 		}
 		return jsonResult({
-			id: doc["id"],
+			...target.kind === "collection" ? { id: doc["id"] } : { global: target.slug },
 			status: doc["_status"],
 			updatedAt: doc["updatedAt"],
 			path: args.path,

package/dist/tools/list-capabilities.mjs

@@ -5,7 +5,9 @@ import { hasDraftValidationEnabled } from "payload/shared";
 //#region src/tools/list-capabilities.ts
 const listCapabilities = {
 	name: "listCapabilities",
-	description: `Lists what this key may do: the collections 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.`,
+	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.
+
+A global is a singleton: it has no id, is not listed by findDocuments and cannot be created. Address one with the "global" argument where a collection document would take "collection" and "id".`,
 	annotations: {
 		readOnlyHint: true,
 		openWorldHint: false
@@ -34,8 +36,24 @@ const listCapabilities = {
 				idType: collection.customIDType ?? payload.db.defaultIDType
 			}];
 		});
+		const globals = scope.options.globals.flatMap((entry) => {
+			const capability = scope.capabilities.globals[entry.slug];
+			const config = payload.globals.config.find((candidate) => candidate.slug === entry.slug);
+			if (!capability || !config || !(capability.read || capability.write)) return [];
+			const description = staticDescription(config.admin.description);
+			return [{
+				slug: entry.slug,
+				label: translateLabel(scope, config.label, entry.slug),
+				...description === void 0 ? {} : { description },
+				read: capability.read,
+				write: capability.write,
+				drafts: entry.hasDrafts,
+				draftValidation: hasDraftValidationEnabled(config)
+			}];
+		});
 		return Promise.resolve(jsonResult({
 			collections,
+			...globals.length > 0 ? { globals } : {},
 			locales: scope.locales ? {
 				codes: scope.locales,
 				default: scope.defaultLocale

package/dist/tools/patch-document.mjs

@@ -1,5 +1,6 @@
 import { errorResult, jsonResult } from "../endpoint/result.mjs";
-import { collectionEnum, ensureAllowed, idSchema, localeOf, localeShape, readDraft } from "./shared.mjs";
+import { idShape, localeOf, localeShape, readTarget, targetShape } from "./shared.mjs";
+import { refOf, requireIdFor, resolveTarget } from "./target.mjs";
 import { PATCH_OPERATION_SCHEMA, applyPatchToCopy, buildWriteData, findPatchProblems, isElementPointer } from "../write/patch.mjs";
 import { collectPublishBlockers } from "../write/publish-blockers.mjs";
 import { withTransaction } from "../write/transaction.mjs";
@@ -8,6 +9,8 @@ import { Pointer } from "rfc6902";
 //#region src/tools/patch-document.ts
 const DESCRIPTION = `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.
 
 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.
@@ -48,10 +51,13 @@ const patchDocument = {
 		idempotentHint: false,
 		openWorldHint: false
 	},
-	isEnabled: (scope) => scope.writable.length > 0,
+	isEnabled: (scope) => scope.writable.length + scope.writableGlobals.length > 0,
 	inputSchema: (scope) => ({
-		collection: collectionEnum(scope.writable).describe("Collection holding the document."),
-		id: idSchema,
+		...targetShape(scope, "write", {
+			collection: "Collection holding the document.",
+			global: "Global to patch."
+		}),
+		...idShape(scope, "write"),
 		...localeShape(scope, {
 			required: true,
 			description: "Locale the patch applies to. Localized fields write here only."
@@ -60,47 +66,55 @@ const patchDocument = {
 		expectedUpdatedAt: z.string().optional().describe("The updatedAt read before patching. The write is refused if the document has changed since.")
 	}),
 	handler: async (args, scope) => {
-		const collection = ensureAllowed(scope, args.collection, "write");
+		const target = resolveTarget(scope, args, "write");
+		const id = requireIdFor(target, args.id);
 		const { payload } = scope.req;
 		const locale = localeOf(scope, args.locale);
 		return await withTransaction(scope.req, async () => {
-			const doc = await readDraft(scope, {
-				collection: args.collection,
-				id: args.id,
+			const doc = await readTarget(scope, {
+				target,
+				id,
 				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, {
-				collection: args.collection,
 				doc,
-				patches: args.patches
+				patches: args.patches,
+				ref: refOf(target)
 			});
 			if (problems.length > 0) return errorResult("No operation was applied.", { problems });
 			const applied = applyPatchToCopy(doc, args.patches);
 			if ("problems" in applied) return errorResult("No operation was applied.", { problems: applied.problems });
-			await payload.update({
-				collection: args.collection,
-				id: args.id,
-				data: buildWriteData(payload.config, collection, applied.next),
+			const write = {
+				data: buildWriteData(payload.config, target.config, applied.next),
 				depth: 0,
 				draft: true,
 				overrideAccess: false,
 				req: scope.req,
 				...locale === void 0 ? {} : { locale }
+			};
+			if (target.kind === "collection") await payload.update({
+				...write,
+				collection: target.slug,
+				id
+			});
+			else await payload.updateGlobal({
+				...write,
+				slug: target.slug
 			});
-			const saved = await readDraft(scope, {
-				collection: args.collection,
-				id: args.id,
+			const saved = await readTarget(scope, {
+				target,
+				id,
 				locale,
 				privileged: true
 			});
 			const notApplied = notAppliedPointers(args.patches, applied.next, saved);
 			const publishBlockers = await collectPublishBlockers(scope.req, {
-				collection,
-				doc: saved
+				doc: saved,
+				entity: target
 			});
 			return jsonResult({
-				id: saved["id"],
+				...target.kind === "collection" ? { id: saved["id"] } : { global: target.slug },
 				status: saved["_status"],
 				updatedAt: saved["updatedAt"],
 				...publishBlockers.length > 0 ? { publishBlockers } : {},

package/dist/tools/shared.mjs

@@ -1,8 +1,39 @@
-import { Forbidden, NotFound } from "payload";
+import { NotFound } from "payload";
 import { z } from "zod";
 //#region src/tools/shared.ts
-const collectionEnum = (slugs) => z.enum(slugs);
+const slugEnum = (slugs) => z.enum(slugs);
 const idSchema = z.union([z.string(), z.number()]).describe("Document id.");
+const slugsFor = (scope, operation) => ({
+	collections: operation === "read" ? scope.readable : scope.writable,
+	globals: operation === "read" ? scope.readableGlobals : scope.writableGlobals
+});
+/**
+* The `collection` and `global` arguments.
+*
+* When the key can reach no global, `global` is left out of the shape entirely
+* and `collection` stays required, mirroring how {@link localeShape} omits
+* `locale` when localization is off. A deployment without globals therefore
+* sees exactly the schema it saw before. Only the mixed case makes either
+* argument optional, and the handler enforces the exclusivity there.
+*/ const targetShape = (scope, operation, descriptions) => {
+	const { collections, globals } = slugsFor(scope, operation);
+	if (globals.length === 0) return { collection: slugEnum(collections).describe(descriptions.collection) };
+	if (collections.length === 0) return { global: slugEnum(globals).describe(descriptions.global) };
+	return {
+		collection: slugEnum(collections).optional().describe(descriptions.collection),
+		global: slugEnum(globals).optional().describe(descriptions.global)
+	};
+};
+/**
+* The `id` argument, which only a collection document has. Omitted when the key
+* can reach no collection, required when it can reach no global, and optional
+* in between, where `requireIdFor` enforces the dependency.
+*/ const idShape = (scope, operation) => {
+	const { collections, globals } = slugsFor(scope, operation);
+	if (collections.length === 0) return {};
+	if (globals.length === 0) return { id: idSchema };
+	return { id: idSchema.optional().describe("Document id. Required with \"collection\"; must be omitted with \"global\".") };
+};
 /**
 * The `locale` argument, present only when localization is configured.
 */ const localeShape = (scope, options) => {
@@ -12,15 +43,6 @@ const idSchema = z.union([z.string(), z.number()]).describe("Document id.");
 };
 const depthShape = (scope) => ({ depth: z.number().int().min(0).max(scope.options.limits.maxDepth).optional().describe(`Relationship population depth. Default 0, at most ${String(scope.options.limits.maxDepth)}.`) });
 /**
-* Throws unless the key may perform `operation` on `slug`. The input schema
-* already limits the enum, so this only guards against a stale tool list.
-*/ const ensureAllowed = (scope, slug, operation) => {
-	const allowed = operation === "read" ? scope.readable : scope.writable;
-	const collection = scope.req.payload.collections[slug];
-	if (!allowed.includes(slug) || !collection) throw new Forbidden(scope.req.t);
-	return collection.config;
-};
-/**
 * The locale to operate on: the explicit argument, else the request's, else
 * the default. `undefined` when localization is off.
 */ const localeOf = (scope, locale) => {
@@ -31,23 +53,34 @@ const depthShape = (scope) => ({ depth: z.number().int().min(0).max(scope.option
 /**
 * Reads the current draft in a fixed locale with no fallback, which is the
 * shape that may be written back or validated without mixing locales.
-*/ const readDraft = async (scope, args) => {
-	const doc = await scope.req.payload.findByID({
-		collection: args.collection,
-		id: args.id,
+*/ const readTarget = async (scope, args) => {
+	const { payload } = scope.req;
+	const privileged = args.privileged === true;
+	const shared = {
 		depth: 0,
 		draft: true,
 		...args.locale === void 0 ? {} : {
 			locale: args.locale,
 			fallbackLocale: false
 		},
-		overrideAccess: args.privileged === true,
-		showHiddenFields: args.privileged === true,
-		disableErrors: true,
+		overrideAccess: privileged,
+		showHiddenFields: privileged,
 		req: scope.req
+	};
+	if (args.target.kind === "collection") {
+		const doc = await payload.findByID({
+			...shared,
+			collection: args.target.slug,
+			id: args.id,
+			disableErrors: true
+		});
+		if (!doc) throw new NotFound(scope.req.t);
+		return doc;
+	}
+	return await payload.findGlobal({
+		...shared,
+		slug: args.target.slug
 	});
-	if (!doc) throw new NotFound(scope.req.t);
-	return doc;
 };
 /**
 * Resolves a collection label for the request's language.
@@ -62,4 +95,4 @@ const depthShape = (scope) => ({ depth: z.number().int().min(0).max(scope.option
 	return fallback;
 };
 //#endregion
-export { collectionEnum, depthShape, ensureAllowed, idSchema, localeOf, localeShape, readDraft, translateLabel };
+export { depthShape, idSchema, idShape, localeOf, localeShape, readTarget, slugEnum, targetShape, translateLabel };

package/dist/tools/target.d.mts

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

package/dist/tools/target.mjs

@@ -0,0 +1,49 @@
+import { APIError, Forbidden } from "payload";
+//#region src/tools/target.ts
+const refOf = (target) => ({
+	kind: target.kind,
+	slug: target.slug
+});
+/**
+* Resolves the `collection`/`global` arguments to one entity and checks the key
+* may perform `operation` on it.
+*
+* A tool's `inputSchema` returns a raw shape, which leaves no top-level
+* `.refine` to express "exactly one of collection and global". The rule is
+* enforced here instead, with a message naming the offending arguments so one
+* failed call teaches it.
+*/ const resolveTarget = (scope, args, operation) => {
+	const { collection, global } = args;
+	if (collection !== void 0 && global !== void 0) throw new APIError("Pass either \"collection\" or \"global\", not both.", 400);
+	if (collection === void 0 && global === void 0) throw new APIError("One of \"collection\" or \"global\" is required. Call listCapabilities to see which slugs are available.", 400);
+	if (collection !== void 0) {
+		const allowed = operation === "read" ? scope.readable : scope.writable;
+		const found = scope.req.payload.collections[collection];
+		if (!allowed.includes(collection) || !found) throw new Forbidden(scope.req.t);
+		return {
+			kind: "collection",
+			slug: collection,
+			config: found.config
+		};
+	}
+	const slug = global;
+	const allowed = operation === "read" ? scope.readableGlobals : scope.writableGlobals;
+	const found = scope.req.payload.globals.config.find((candidate) => candidate.slug === slug);
+	if (!allowed.includes(slug) || !found) throw new Forbidden(scope.req.t);
+	return {
+		kind: "global",
+		slug,
+		config: found
+	};
+};
+/**
+* Checks `id` against the resolved target. A collection document needs one; a
+* global is a singleton and must not carry one. The schema cannot express the
+* dependency, so it is stated here and in every affected tool description.
+*/ const requireIdFor = (target, id) => {
+	if (target.kind === "collection" && id === void 0) throw new APIError(`"id" is required when "collection" is "${target.slug}".`, 400);
+	if (target.kind === "global" && id !== void 0) throw new APIError(`"id" must be omitted when "global" is "${target.slug}"; a global is a singleton.`, 400);
+	return target.kind === "collection" ? id : void 0;
+};
+//#endregion
+export { refOf, requireIdFor, resolveTarget };

package/dist/tools/types.d.mts

@@ -0,0 +1,5 @@
+import "../types.mjs";
+import "../options.mjs";
+import { PayloadRequest } from "payload";
+import { z } from "zod";
+import { CallToolResult, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";

package/dist/tools/validate-document.mjs

@@ -1,43 +1,50 @@
 import { jsonResult } from "../endpoint/result.mjs";
-import { collectionEnum, ensureAllowed, idSchema, localeOf, localeShape, readDraft } from "./shared.mjs";
+import { idShape, localeOf, localeShape, readTarget, targetShape } from "./shared.mjs";
+import { requireIdFor, resolveTarget } from "./target.mjs";
 import { collectPublishBlockers } from "../write/publish-blockers.mjs";
 //#region src/tools/validate-document.ts
 const validateDocument = {
 	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".`,
+	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
 	},
-	isEnabled: (scope) => scope.writable.length > 0,
+	isEnabled: (scope) => scope.writable.length + scope.writableGlobals.length > 0,
 	inputSchema: (scope) => ({
-		collection: collectionEnum(scope.writable).describe("Collection holding the document."),
-		id: idSchema,
+		...targetShape(scope, "write", {
+			collection: "Collection holding the document.",
+			global: "Global to validate."
+		}),
+		...idShape(scope, "write"),
 		...localeShape(scope, {
 			required: true,
 			description: "Locale to validate."
 		})
 	}),
 	handler: async (args, scope) => {
-		const collection = ensureAllowed(scope, args.collection, "write");
+		const target = resolveTarget(scope, args, "write");
+		const id = requireIdFor(target, args.id);
 		const locale = localeOf(scope, args.locale);
-		await readDraft(scope, {
-			collection: args.collection,
-			id: args.id,
+		await readTarget(scope, {
+			target,
+			id,
 			locale
 		});
-		const doc = await readDraft(scope, {
-			collection: args.collection,
-			id: args.id,
+		const doc = await readTarget(scope, {
+			target,
+			id,
 			locale,
 			privileged: true
 		});
 		const publishBlockers = await collectPublishBlockers(scope.req, {
-			collection,
-			doc
+			doc,
+			entity: target
 		});
 		return jsonResult({
-			id: doc["id"],
+			...target.kind === "collection" ? { id: doc["id"] } : { global: target.slug },
 			status: doc["_status"],
 			updatedAt: doc["updatedAt"],
 			publishBlockers

package/dist/types.d.mts

@@ -1,4 +1,4 @@
-import { CollectionConfig, CollectionSlug, PayloadRequest, TypedUser } from "payload";
+import { CollectionConfig, CollectionSlug, GlobalSlug, PayloadRequest, TypedUser } from "payload";
 import { z } from "zod";
 import { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import { CallToolResult, ServerNotification, ServerRequest, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
@@ -29,6 +29,26 @@ interface McpxCollectionOptions {
    */
   allowLiveWrites?: boolean;
 }
+/**
+ * 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.
+ */
+interface McpxGlobalOptions {
+  /** Expose `describeSchema` and `getDocument`. Default `true`. */
+  read?: boolean;
+  /**
+   * Expose `patchDocument` and `validateDocument`. Default `false`. Requires
+   * `versions.drafts` unless `allowLiveWrites` is set.
+   */
+  write?: boolean;
+  /**
+   * Permit writes to a global without drafts. Such writes land on the live
+   * document because there is no draft to land on. Default `false`.
+   */
+  allowLiveWrites?: boolean;
+}
 type McpxToolExtra = RequestHandlerExtra<ServerRequest, ServerNotification>;
 /**
  * A custom tool. It is gated by its own checkbox on every API key and runs
@@ -63,6 +83,8 @@ interface McpxAuthResult {
 type McpxPluginOptions = {
   /** Allow-list of collections. `true` is shorthand for `{ read: true }`. */
   collections: Partial<Record<CollectionSlug, McpxCollectionOptions | true>>;
+  /** Allow-list of globals. `true` is shorthand for `{ read: true }`. */
+  globals?: Partial<Record<GlobalSlug, McpxGlobalOptions | true>>;
   /** Collection the keys act as. Default `config.admin.user`, then `users`. */
   userCollection?: CollectionSlug;
   apiKeys?: {
@@ -103,6 +125,7 @@ interface McpxCollectionCapabilities {
  */
 interface McpxResolvedCapabilities {
   collections: Record<string, McpxCollectionCapabilities>;
+  globals: Record<string, McpxCollectionCapabilities>;
   tools: Record<string, boolean>;
 }
 interface McpxRequestContext {
@@ -110,4 +133,4 @@ interface McpxRequestContext {
   capabilities: McpxResolvedCapabilities;
 }
 //#endregion
-export { McpxAuthResult, McpxCollectionCapabilities, McpxCollectionOptions, McpxPluginOptions, McpxRequestContext, McpxResolvedCapabilities, McpxTool, McpxToolExtra, defineMcpxTool };
+export { McpxAuthResult, McpxCollectionCapabilities, McpxCollectionOptions, McpxGlobalOptions, McpxPluginOptions, McpxRequestContext, McpxResolvedCapabilities, McpxTool, McpxToolExtra, defineMcpxTool };

package/dist/write/draft-guard.mjs

@@ -27,9 +27,7 @@ import { hasDraftsEnabled } from "payload/shared";
 * 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.
-*/ const forceDraftWrite = (hookArgs) => {
-	const { args, operation, req } = hookArgs;
-	if (!isMcpxRequest(req) || operation !== "create" && operation !== "update") return args;
+*/ const scrubWriteArgs = (args) => {
 	const next = Object.fromEntries(Object.entries(args).filter(([key]) => !STRIPPED_ARGS.has(key)));
 	if (next["data"] && typeof next["data"] === "object") {
 		const { _status: _ignoredStatus, deletedAt: _ignoredDeletedAt, ...data } = next["data"];
@@ -41,18 +39,50 @@ import { hasDraftsEnabled } from "payload/shared";
 	next["trash"] = false;
 	return next;
 };
+const forceDraftWrite = (hookArgs) => {
+	const { args, operation, req } = hookArgs;
+	if (!isMcpxRequest(req) || operation !== "create" && operation !== "update") return args;
+	return scrubWriteArgs(args);
+};
+/**
+* The global counterpart of {@link forceDraftWrite}. Payload invokes a global's
+* `beforeOperation` with the whole argument bag and assigns the result back,
+* exactly as the collection path does and before it reads `draft`,
+* `publishAllLocales` or `data._status`, so the guard has the same reach here:
+* every MCP write to a global, builtin tool or custom.
+*
+* The global operation union has no `create` member because a global always
+* exists, so only `update` is intercepted. `STRIPPED_ARGS` covers the three
+* publish vectors `updateGlobal` accepts; the rest of the set does not exist on
+* that signature and filtering it is a harmless no-op. `slug` survives the
+* filter, so the operation still knows what it is updating.
+*/ const forceDraftWriteGlobal = (hookArgs) => {
+	const { operation, req } = hookArgs;
+	const args = hookArgs.args;
+	if (!isMcpxRequest(req) || operation !== "update") return args;
+	return scrubWriteArgs(args);
+};
 /**
 * Refuses an MCP write that would still not land as a draft. An alarm rather
 * than the guarantee: `forceDraftWrite` should make it unreachable. It throws
 * instead of correcting `_status` because Payload has already chosen the write
 * branch by the time a `beforeChange` hook runs.
-*/ const refusePublish = ({ collection, data, req }) => {
-	if (!isMcpxRequest(req)) return data;
+*/ const refuseUnlessDraft = (req, slug, data) => {
+	if (!isMcpxRequest(req)) return;
 	const status = data._status;
-	if (status === "draft") return data;
-	req.payload.logger.warn(`[payloadcms-mcpx] Refused a write to ${collection.slug} that would not have been a draft (_status: ${String(status)}).`);
+	if (status === "draft") return;
+	req.payload.logger.warn(`[payloadcms-mcpx] Refused a write to ${slug} that would not have been a draft (_status: ${String(status)}).`);
 	throw new APIError("MCP clients may only write drafts. This write was refused because it would not have been saved as one.", 403);
 };
+const refusePublish = ({ collection, data, req }) => {
+	refuseUnlessDraft(req, collection.slug, data);
+	return data;
+};
+/** The global counterpart of {@link refusePublish}. */ const refusePublishGlobal = ({ data, global, req }) => {
+	const next = data;
+	refuseUnlessDraft(req, global.slug, next);
+	return next;
+};
 /**
 * Attaches the draft guard to every collection: `forceDraftWrite` everywhere
 * (it is a no-op outside MCP requests) and `refusePublish` wherever drafts
@@ -66,5 +96,18 @@ import { hasDraftsEnabled } from "payload/shared";
 		...hasDraftsEnabled(collection) ? { beforeChange: [...collection.hooks?.beforeChange ?? [], refusePublish] } : {}
 	}
 }));
+/**
+* Attaches the guard to every global, exposed or not, for the same reason
+* `installDraftGuards` covers every collection: a custom tool running on an MCP
+* request must not be able to publish through a global the plugin config never
+* mentioned.
+*/ const installGlobalDraftGuards = (globals) => globals.map((global) => ({
+	...global,
+	hooks: {
+		...global.hooks,
+		beforeOperation: [...global.hooks?.beforeOperation ?? [], forceDraftWriteGlobal],
+		...hasDraftsEnabled(global) ? { beforeChange: [...global.hooks?.beforeChange ?? [], refusePublishGlobal] } : {}
+	}
+}));
 //#endregion
-export { forceDraftWrite, installDraftGuards, isMcpxRequest, refusePublish };
+export { forceDraftWrite, forceDraftWriteGlobal, installDraftGuards, installGlobalDraftGuards, isMcpxRequest, refusePublish, refusePublishGlobal };

package/dist/write/patch.mjs

@@ -126,9 +126,9 @@ const isPlainObject = (value) => typeof value === "object" && value !== null &&
 		for (const pointer of pointers) {
 			const resolution = resolveDataPointer(config, {
 				addedValue: value ?? moved,
-				collection: target.collection,
 				doc: target.doc,
-				pointer
+				pointer,
+				ref: target.ref
 			});
 			if (pointer === operation.path && value !== void 0) return validateWriteValue(config, {
 				pointer,
@@ -208,9 +208,9 @@ const isPlainObject = (value) => typeof value === "object" && value !== null &&
 /**
 * 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, collection, doc) => {
+*/ const buildWriteData = (config, target, doc) => {
 	return pickDescribed(config, doc, {
-		fields: collection.flattenedFields,
+		fields: target.flattenedFields,
 		prefix: [],
 		isRow: false
 	});

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

@@ -1,3 +1,4 @@
+import "../tools/target.mjs";
 import { PayloadRequest } from "payload";
 //#region src/write/publish-blockers.d.ts
 /**