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

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.14",
   "description": "Payload CMS plugin exposing a fixed, schema-aware MCP tool surface with draft-only writes and per-API-key capabilities.",
   "keywords": [
     "payload",