@abinnovision/payloadcms-mcpx 1.1.0-beta.6 → 2.0.0-beta.12

package/dist/schema/admin-hidden.mjs

@@ -0,0 +1,91 @@
+import { isPlainObject } from "../guards.mjs";
+import { RESERVED_FIELD_NAMES, ROW_KEYS, blockOf, blockSlugsOf, isAdminHidden, schemaOf } from "./walk.mjs";
+//#region src/schema/admin-hidden.ts
+const UPLOAD_BASE_FIELDS = /* @__PURE__ */ new Set([
+	"filename",
+	"filesize",
+	"focalX",
+	"focalY",
+	"height",
+	"mimeType",
+	"sizes",
+	"thumbnailURL",
+	"url",
+	"width"
+]);
+const NONE = /* @__PURE__ */ new Set();
+const isPayloadKey = (name) => RESERVED_FIELD_NAMES.has(name) || ROW_KEYS.has(name);
+const collectionOf = (config, slug) => config.collections.find((collection) => collection.slug === slug);
+const exemptOf = (collection) => collection?.upload ? UPLOAD_BASE_FIELDS : NONE;
+const mapEach = (value, one) => Array.isArray(value) ? value.map(one) : one(value);
+const stripFields = (config, fields, doc, exempt = NONE) => {
+	const result = { ...doc };
+	for (const field of fields) {
+		if (!("name" in field) || exempt.has(field.name) || isPayloadKey(field.name) || !Object.hasOwn(result, field.name)) continue;
+		if (isAdminHidden(field)) Reflect.deleteProperty(result, field.name);
+		else result[field.name] = stripValue(config, field, result[field.name]);
+	}
+	return result;
+};
+const stripRelated = (config, relationTo, value) => {
+	if (!isPlainObject(value)) return value;
+	if (Array.isArray(relationTo)) {
+		const slug = value["relationTo"];
+		return typeof slug === "string" && isPlainObject(value["value"]) ? {
+			...value,
+			value: stripRelated(config, slug, value["value"])
+		} : value;
+	}
+	const collection = collectionOf(config, relationTo);
+	return collection ? stripFields(config, collection.flattenedFields, value, exemptOf(collection)) : value;
+};
+const stripValue = (config, field, value) => {
+	switch (field.type) {
+		case "group":
+		case "tab": return isPlainObject(value) ? stripFields(config, field.flattenedFields, value) : value;
+		case "array": return mapEach(value, (row) => isPlainObject(row) ? stripFields(config, field.flattenedFields, row) : row);
+		case "blocks": return mapEach(value, (row) => {
+			const block = isPlainObject(row) && typeof row["blockType"] === "string" ? blockOf(config, field, row["blockType"]) : void 0;
+			return block && isPlainObject(row) ? stripFields(config, block.flattenedFields, row) : row;
+		});
+		case "relationship":
+		case "upload": return mapEach(value, (item) => stripRelated(config, field.relationTo, item));
+		case "join": return isPlainObject(value) && Array.isArray(value["docs"]) ? {
+			...value,
+			docs: value["docs"].map((item) => stripRelated(config, field.collection, item))
+		} : value;
+		default: return value;
+	}
+};
+/**
+* The document without its `admin.hidden` fields, at every depth, including
+* populated documents, which are read against their own collection. Payload's
+* upload fields stay. Rich text is not walked.
+*/ const stripAdminHidden = (config, ref, doc) => stripFields(config, schemaOf(config, ref).flattenedFields, doc, ref.kind === "collection" ? exemptOf(collectionOf(config, ref.slug)) : NONE);
+/**
+* Whether a query path inside one collection names an `admin.hidden` field or
+* a field under one. The path is dotted, with a locale segment allowed after a
+* localized field. Hops into other collections are the caller's to follow.
+*/ const addressesAdminHidden = (config, collectionSlug, path) => {
+	const collection = collectionOf(config, collectionSlug);
+	if (!collection) return false;
+	const locales = config.localization ? config.localization.localeCodes : [];
+	const walk = (fields, segments) => {
+		const [segment, ...rest] = segments;
+		if (segment === void 0 || isPayloadKey(segment)) return false;
+		const matches = fields.filter((field) => "name" in field && field.name === segment);
+		if (matches.length === 0) return locales.includes(segment) ? walk(fields, rest) : false;
+		return matches.some((field) => {
+			if (isAdminHidden(field)) return true;
+			if (field.type === "group" || field.type === "tab" || field.type === "array") return walk(field.flattenedFields, rest);
+			return field.type === "blocks" && blockSlugsOf(field).some((slug) => {
+				const block = blockOf(config, field, slug);
+				return block !== void 0 && walk(block.flattenedFields, rest);
+			});
+		});
+	};
+	const segments = path.split(".");
+	return !exemptOf(collection).has(segments[0] ?? "") && walk(collection.flattenedFields, segments);
+};
+//#endregion
+export { addressesAdminHidden, stripAdminHidden };

package/dist/schema/describe.mjs

@@ -1,68 +1,55 @@
 import { lexicalSubSchema, subSchemaNodeTypes } from "./lexical.mjs";
+import { joinPath, splitPath } from "./path.mjs";
 import { translateAny } from "../i18n.mjs";
-import { blockOf, blockSlugsOf, describeFields, findBlocksField, findRichTextField, joinPath, splitPath, targetOf } from "./walk.mjs";
+import { blockOf, blockSlugsOf, describeFields, findBlocksField, findRichTextField, schemaOf } from "./walk.mjs";
+import { SchemaError } from "./errors.mjs";
 //#region src/schema/describe.ts
-/** Blocks and rich text are both leaves of the walk, so at most one matches. */ const longestMatch = (descriptors, remaining) => descriptors.map((descriptor) => splitPath(descriptor.path)).filter((parts) => parts.every((part, offset) => part === remaining[offset])).sort((left, right) => right.length - left.length)[0];
+const matchSchemaSegments = (descriptors, remaining) => descriptors.map((descriptor) => splitPath(descriptor.path)).filter((parts) => parts.every((part, offset) => part === remaining[offset])).sort((left, right) => right.length - left.length)[0];
 const stepThroughBlocks = ({ config, fields, match, remaining }) => {
 	const field = findBlocksField(fields, match);
 	if (!field) throw new Error(`"${joinPath(match)}" could not be resolved.`);
 	const slug = remaining.at(match.length);
-	if (slug === void 0) throw new Error(`"${joinPath(match)}" is a blocks field; append one of: ${blockSlugsOf(field).join(", ")}`);
+	if (slug === void 0) throw new SchemaError(`"${joinPath(match)}" is a blocks field; append one of: ${blockSlugsOf(field).join(", ")}`);
 	const block = blockOf(config, field, slug);
-	if (!block) throw new Error(`"${slug}" is not allowed at "${joinPath(match)}". Allowed: ${blockSlugsOf(field).join(", ")}`);
+	if (!block) throw new SchemaError(`"${slug}" is not allowed at "${joinPath(match)}". Allowed: ${blockSlugsOf(field).join(", ")}`);
 	return {
 		blockType: slug,
 		fields: block.flattenedFields,
 		rest: remaining.slice(match.length + 1)
 	};
 };
-/**
-* A node that picks a block by slug takes one segment more, so `/content/block`
-* addresses the choice and `/content/block/callout` the definition. Everything
-* else, a link node being the usual case, resolves in a single segment.
-*/ const stepThroughLexical = ({ config, fields, match, remaining }) => {
+const stepThroughLexical = ({ config, fields, match, remaining }) => {
 	const field = findRichTextField(fields, match);
 	if (!field) throw new Error(`"${joinPath(match)}" could not be resolved.`);
 	const available = subSchemaNodeTypes(field).join(", ") || "none";
 	const nodeType = remaining.at(match.length);
-	if (nodeType === void 0) throw new Error(`"${joinPath(match)}" is a rich text field; append one of: ${available}`);
+	if (nodeType === void 0) throw new SchemaError(`"${joinPath(match)}" is a rich text field; append one of: ${available}`);
 	const sub = lexicalSubSchema(field, nodeType);
 	const reached = joinPath([...match, nodeType]);
-	if (!sub) throw new Error(`"${nodeType}" carries no fields in this field's editor. Node types with fields here: ${available}`);
+	if (!sub) throw new SchemaError(`"${nodeType}" carries no fields in this field's editor. Node types with fields here: ${available}`);
 	if (sub.kind === "fields") return {
 		fields: sub.fields,
 		rest: remaining.slice(match.length + 1)
 	};
 	const slug = remaining.at(match.length + 1);
 	const slugs = blockSlugsOf(sub.blocksField).join(", ");
-	if (slug === void 0) throw new Error(`"${reached}" selects a block; append one of: ${slugs}`);
+	if (slug === void 0) throw new SchemaError(`"${reached}" selects a block; append one of: ${slugs}`);
 	const block = blockOf(config, sub.blocksField, slug);
-	if (!block) throw new Error(`"${slug}" is not allowed at "${reached}". Allowed: ${slugs}`);
+	if (!block) throw new SchemaError(`"${slug}" is not allowed at "${reached}". Allowed: ${slugs}`);
 	return {
 		blockType: slug,
 		fields: block.flattenedFields,
 		rest: remaining.slice(match.length + 2)
 	};
 };
-/**
-* A schema path alternates a blocks field's own path with the slug of one of
-* the blocks it accepts, so `/layout/sections/sectionWrapper/modules/hero`
-* reaches `hero` as it exists under `pages` specifically. The slug sits where
-* a pointer into a document would carry the element's index. A rich text
-* field's path continues the same way, naming a Lexical node type and, for the
-* block nodes, the slug it holds.
-*/ const fieldsAtSchemaPath = (config, target, schemaPath) => {
+const fieldsAtSchemaPath = (config, target, schemaPath) => {
 	let fields = target.flattenedFields;
 	let blockType;
 	let remaining = splitPath(schemaPath);
 	while (remaining.length > 0) {
 		const descendable = describeFields(fields).filter((descriptor) => descriptor.type === "blocks" || descriptor.type === "richText");
-		/**
-		* A field's own path may span several segments (`/layout/sections`), so
-		* the longest matching one is taken. Blocks and rich text fields are both
-		* leaves of the walk, so no two of these paths overlap.
-		*/ const match = longestMatch(descendable, remaining);
-		if (!match) throw new Error(`"${joinPath(remaining)}" does not address a blocks or rich text field. Available here: ${descendable.map((descriptor) => descriptor.path).join(", ") || "none"}`);
+		const match = matchSchemaSegments(descendable, remaining);
+		if (!match) throw new SchemaError(`"${joinPath(remaining)}" does not address a blocks or rich text field. Available here: ${descendable.map((descriptor) => descriptor.path).join(", ") || "none"}`);
 		const at = {
 			config,
 			fields,
@@ -79,10 +66,7 @@ const stepThroughBlocks = ({ config, fields, match, remaining }) => {
 		fields
 	};
 };
-/**
-* Where a descriptor can be drilled into: one branch per block a blocks field
-* accepts, and one per Lexical node type that carries fields.
-*/ const branchesOf = (fields, descriptor, schemaPath) => {
+const branchesOf = (fields, descriptor, schemaPath) => {
 	const base = `${schemaPath}${descriptor.path}`;
 	if (descriptor.type === "richText") {
 		const field = findRichTextField(fields, splitPath(descriptor.path));
@@ -108,7 +92,7 @@ const stepThroughBlocks = ({ config, fields, match, remaining }) => {
 * Curried on the translator that resolves each `admin.description`, so a
 * request binds its language once and the walk stays request-free.
 */ const nodeDescriber = (translate = translateAny) => (config, ref, schemaPath = "") => {
-	const { blockType, fields } = fieldsAtSchemaPath(config, targetOf(config, ref), schemaPath);
+	const { blockType, fields } = fieldsAtSchemaPath(config, schemaOf(config, ref), schemaPath);
 	const descriptors = describeFields(fields, translate);
 	const next = descriptors.flatMap((descriptor) => branchesOf(fields, descriptor, schemaPath).map((branch) => branch.path));
 	return {
@@ -132,7 +116,7 @@ const stepThroughBlocks = ({ config, fields, match, remaining }) => {
 			return;
 		}
 		seen.push(schemaPath);
-		const { fields } = fieldsAtSchemaPath(config, targetOf(config, ref), schemaPath);
+		const { fields } = fieldsAtSchemaPath(config, schemaOf(config, ref), schemaPath);
 		for (const descriptor of describeFields(fields)) for (const branch of branchesOf(fields, descriptor, schemaPath)) {
 			if (visited.includes(branch.token)) continue;
 			walk(branch.path, [...visited, branch.token]);

package/dist/schema/errors.mjs

@@ -0,0 +1,8 @@
+//#region src/schema/errors.ts
+/**
+* A schema lookup the client got wrong, such as a path no field answers to.
+* The message is written for the client and names what to send instead.
+*/ var SchemaError = class extends Error {};
+SchemaError.prototype.name = "SchemaError";
+//#endregion
+export { SchemaError };

package/dist/schema/index.mjs

@@ -1,8 +1,11 @@
 import { REQUIRED_NODE_PROPERTIES, ROOT_PROPERTIES, allowedNodeTypes, constrainsFields, lexicalSubSchema, nodeOptions, nodeProblems, nodePropertiesFor, propertyProblem, rootProblems, subSchemaNodeTypes } from "./lexical.mjs";
-import { JSON_POINTER_PATTERN, RESERVED_FIELD_NAMES, blockOf, blockSlugsOf, describeAddressableFields, describeFields, findBlocksField, findRichTextField, isIndexSegment, isPlainObject, joinPath, pointerFromPayloadPath, splitPath, targetOf } from "./walk.mjs";
+import { JSON_POINTER_PATTERN, isIndexSegment, joinPath, pointerFromPayloadPath, prototypeSegmentProblem, splitPath } from "./path.mjs";
+import { RESERVED_FIELD_NAMES, ROW_KEYS, blockOf, blockSlugsOf, describeAddressableFields, describeFields, descriptorsUnder, findBlocksField, findRichTextField, isAdminHidden, schemaOf } from "./walk.mjs";
+import { addressesAdminHidden, stripAdminHidden } from "./admin-hidden.mjs";
+import { SchemaError } from "./errors.mjs";
 import { nodeDescriber, reachableSchemaPaths } from "./describe.mjs";
 import { resolveLexicalPointer } from "./lexical-pointer.mjs";
 import { lexicalOutline } from "./outline.mjs";
 import { resolveDataPointer } from "./pointer.mjs";
 import { EMPTY_ROOT, validateWriteValue } from "./shape.mjs";
-export { EMPTY_ROOT, JSON_POINTER_PATTERN, REQUIRED_NODE_PROPERTIES, RESERVED_FIELD_NAMES, ROOT_PROPERTIES, allowedNodeTypes, blockOf, blockSlugsOf, constrainsFields, describeAddressableFields, describeFields, findBlocksField, findRichTextField, isIndexSegment, isPlainObject, joinPath, lexicalOutline, lexicalSubSchema, nodeDescriber, nodeOptions, nodeProblems, nodePropertiesFor, pointerFromPayloadPath, propertyProblem, reachableSchemaPaths, resolveDataPointer, resolveLexicalPointer, rootProblems, splitPath, subSchemaNodeTypes, targetOf, validateWriteValue };
+export { EMPTY_ROOT, JSON_POINTER_PATTERN, REQUIRED_NODE_PROPERTIES, RESERVED_FIELD_NAMES, ROOT_PROPERTIES, ROW_KEYS, SchemaError, addressesAdminHidden, allowedNodeTypes, blockOf, blockSlugsOf, constrainsFields, describeAddressableFields, describeFields, descriptorsUnder, findBlocksField, findRichTextField, isAdminHidden, isIndexSegment, joinPath, lexicalOutline, lexicalSubSchema, nodeDescriber, nodeOptions, nodeProblems, nodePropertiesFor, pointerFromPayloadPath, propertyProblem, prototypeSegmentProblem, reachableSchemaPaths, resolveDataPointer, resolveLexicalPointer, rootProblems, schemaOf, splitPath, stripAdminHidden, subSchemaNodeTypes, validateWriteValue };

package/dist/schema/lexical-pointer.mjs

@@ -1,14 +1,13 @@
+import { isPlainObject } from "../guards.mjs";
 import { lexicalSubSchema, subSchemaNodeTypes } from "./lexical.mjs";
-import { blockOf, blockSlugsOf, isIndexSegment, isPlainObject, joinPath } from "./walk.mjs";
+import { isIndexSegment, joinPath } from "./path.mjs";
+import { blockOf, blockSlugsOf } from "./walk.mjs";
+import { SchemaError } from "./errors.mjs";
 //#region src/schema/lexical-pointer.ts
-/**
-* A node's `fields` is ordinary Payload field-land, reached either through the
-* schema a feature declares for the node or, where the node picks a block by
-* slug, through that block.
-*/ const stepIntoFields = (at) => {
+const stepIntoFields = (at) => {
 	const { addedValue, config, field, node, nodeType, rest } = at;
 	const sub = lexicalSubSchema(field, nodeType);
-	if (!sub) throw new Error(`"${nodeType}" nodes carry no addressable fields in this field's editor. Node types with fields here: ${subSchemaNodeTypes(field).join(", ")}`);
+	if (!sub) throw new SchemaError(`"${nodeType}" nodes carry no addressable fields in this field's editor. Node types with fields here: ${subSchemaNodeTypes(field).join(", ")}`);
 	const data = node?.["fields"];
 	if (sub.kind === "fields") return {
 		data,
@@ -18,9 +17,10 @@ import { blockOf, blockSlugsOf, isIndexSegment, isPlainObject, joinPath } from "
 	};
 	const added = addedValue?.fields;
 	const slug = (isPlainObject(data) ? data["blockType"] : void 0) ?? (isPlainObject(added) ? added["blockType"] : void 0);
-	if (typeof slug !== "string") throw new Error(`Cannot tell which block a "${nodeType}" node holds. Supply a "blockType" on the value, one of: ${blockSlugsOf(sub.blocksField).join(", ")}`);
+	if (slug === void 0) throw new SchemaError(`Cannot tell which block a "${nodeType}" node holds. Supply a "blockType" on the value, one of: ${blockSlugsOf(sub.blocksField).join(", ")}`);
+	if (typeof slug !== "string") throw new SchemaError(`"blockType" must be a string naming a block in a "${nodeType}" node here. Allowed: ${blockSlugsOf(sub.blocksField).join(", ")}`);
 	const block = blockOf(config, sub.blocksField, slug);
-	if (!block) throw new Error(`"${slug}" is not allowed in a "${nodeType}" node here. Allowed: ${blockSlugsOf(sub.blocksField).join(", ")}`);
+	if (!block) throw new SchemaError(`"${slug}" is not allowed in a "${nodeType}" node here. Allowed: ${blockSlugsOf(sub.blocksField).join(", ")}`);
 	return {
 		blockType: slug,
 		data,
@@ -31,21 +31,19 @@ import { blockOf, blockSlugsOf, isIndexSegment, isPlainObject, joinPath } from "
 };
 /**
 * Walks the segments left over once a pointer has reached a rich text field.
-*
-* The stored state chooses the branch at every index, exactly as the stored
-* document chooses it at a blocks element: an editor state admits many node
-* shapes at the same position, and only what is there says which one it is.
-* A position the document does not have yet takes its type from the value
-* being added, and is addressable no further.
+* The stored state chooses the branch at every index, as the stored document
+* does at a blocks element: an editor state admits many node shapes at the same
+* position. A position the document does not have yet takes its type from the
+* value being added and is addressable no further.
 */ const resolveLexicalPointer = (at) => {
 	const { addedValue, config, descriptor, field, state } = at;
 	const base = {
 		descriptor,
 		field
 	};
-	if (!isPlainObject(state) || !isPlainObject(state["root"])) throw new Error(`"${descriptor.path}" holds no editor state yet. Write the whole field once, then address positions inside it.`);
+	if (!isPlainObject(state) || !isPlainObject(state["root"])) throw new SchemaError(`"${descriptor.path}" holds no editor state yet. Write the whole field once, then address positions inside it.`);
 	const [entry, ...rest] = at.segments;
-	if (entry !== "root") throw new Error(`"${String(entry)}" is not a position in a rich text field. An editor state is entered at "root", e.g. "${descriptor.path}/root/children/0". getDocument with "outline" lists every position this field holds.`);
+	if (entry !== "root") throw new SchemaError(`"${String(entry)}" is not a position in a rich text field. An editor state is entered at "root", e.g. "${descriptor.path}/root/children/0". getDocument with "outline" lists every position this field holds.`);
 	let node = state["root"];
 	let nodeType = "root";
 	let segments = rest;
@@ -72,7 +70,7 @@ import { blockOf, blockSlugsOf, isIndexSegment, isPlainObject, joinPath } from "
 				}
 			};
 			const [index, ...beyond] = remaining;
-			if (!isIndexSegment(index)) throw new Error(`"${descriptor.path}${joinPath([...walked, "children"])}" is a list; "${index}" is not an index. getDocument with "outline" reports the pointer of each node in it.`);
+			if (!isIndexSegment(index)) throw new SchemaError(`"${descriptor.path}${joinPath([...walked, "children"])}" is a list; "${index}" is not an index. getDocument with "outline" reports the pointer of each node in it.`);
 			const children = node?.["children"];
 			const child = Array.isArray(children) && index !== "-" ? children[Number(index)] : void 0;
 			const type = isPlainObject(child) ? child["type"] : addedValue?.type;
@@ -84,7 +82,7 @@ import { blockOf, blockSlugsOf, isIndexSegment, isPlainObject, joinPath } from "
 						kind: "node"
 					}
 				};
-				throw new Error(`Cannot tell which node "${descriptor.path}${joinPath([
+				throw new SchemaError(`Cannot tell which node "${descriptor.path}${joinPath([
 					...walked,
 					"children",
 					index
@@ -108,7 +106,7 @@ import { blockOf, blockSlugsOf, isIndexSegment, isPlainObject, joinPath } from "
 			nodeType,
 			rest: remaining
 		});
-		if (remaining.length > 0) throw new Error(`"${segment}" is a property of a "${nodeType}" node and nothing beneath it can be addressed.`);
+		if (remaining.length > 0) throw new SchemaError(`"${segment}" is a property of a "${nodeType}" node and nothing beneath it can be addressed.`);
 		return {
 			kind: "position",
 			position: {

package/dist/schema/lexical.mjs

@@ -1,27 +1,19 @@
+import { isPlainObject, ownValue } from "../guards.mjs";
 import { flattenAllFields } from "payload";
 //#region src/schema/lexical.ts
-/**
-* `editorConfig.features.nodes` lists only what a feature contributed, so a
-* field whose editor enables nothing but text formatting reports none at all.
-*/ const LEXICAL_CORE_NODES = [
+const LEXICAL_CORE_NODES = [
 	"root",
 	"paragraph",
 	"text",
 	"linebreak",
 	"tab"
 ];
-/**
-* Sub-fields exist but cannot be addressed by a schema path. Asked without a
-* node, `upload` answers with every enabled collection's upload fields
-* concatenated, so the result describes no single position.
-*/ const OPAQUE_NODE_TYPES = /* @__PURE__ */ new Set(["upload"]);
-/**
-* `null` records a node type that was asked and has nothing to describe, so it
-* is asked only once. Worth caching because describe and validate resolve the
-* same field repeatedly and the block features rebuild their answer every call.
-*/ const subSchemaCache = /* @__PURE__ */ new WeakMap();
+const OPAQUE_NODE_TYPES = /* @__PURE__ */ new Set(["upload"]);
+const subSchemaCache = /* @__PURE__ */ new WeakMap();
 const featuresOf = (field) => field.editor?.editorConfig?.features;
-/** Editors other than Lexical report only the core nodes. */ const allowedNodeTypes = (field) => {
+/**
+* Editors other than Lexical report only the core nodes.
+*/ const allowedNodeTypes = (field) => {
 	const registered = (featuresOf(field)?.nodes ?? []).flatMap((entry) => {
 		const type = entry.node?.getType?.();
 		return type ? [type] : [];
@@ -51,11 +43,10 @@ const lexicalSubSchema = (field, nodeType) => {
 	if (!cached.has(nodeType)) cached.set(nodeType, resolveSubSchema(field, nodeType));
 	return cached.get(nodeType) ?? void 0;
 };
-/** In the order their features registered them. */ const subSchemaNodeTypes = (field) => [...featuresOf(field)?.getSubFields?.keys() ?? []].filter((nodeType) => lexicalSubSchema(field, nodeType) !== void 0);
 /**
-* `direction` carries Payload's own declaration for it, `oneOf` the two
-* directions or null, rather than a looser "string or null".
-*/ const KINDS = {
+* In the order their features registered them.
+*/ const subSchemaNodeTypes = (field) => [...featuresOf(field)?.getSubFields?.keys() ?? []].filter((nodeType) => lexicalSubSchema(field, nodeType) !== void 0);
+const KINDS = {
 	array: {
 		accepts: (value) => Array.isArray(value),
 		needs: "an array"
@@ -69,11 +60,11 @@ const lexicalSubSchema = (field, nodeType) => {
 		needs: "a number"
 	},
 	object: {
-		accepts: (value) => typeof value === "object" && value !== null && !Array.isArray(value),
+		accepts: isPlainObject,
 		needs: "an object"
 	},
 	optionalObject: {
-		accepts: (value) => value === null || typeof value === "object" && !Array.isArray(value),
+		accepts: (value) => value === null || isPlainObject(value),
 		needs: "an object or null"
 	},
 	string: {
@@ -88,26 +79,17 @@ const ELEMENT_PROPERTIES = {
 	direction: "direction",
 	indent: "number"
 };
-/** A text node and everything built on one. */ const TEXT_PROPERTIES = {
+const TEXT_PROPERTIES = {
 	detail: "number",
 	format: "number",
 	mode: "string",
 	style: "string",
 	text: "string"
 };
+const UNIVERSAL_PROPERTIES = { version: "number" };
 /**
-* Carried by every node, whatever its type.
-*
-* Aligned with Payload rather than measured: its `outputSchema` declares `type`
-* and `version` required for every node in the tree, and that declaration is
-* what types the field in `payload-types.ts`. Lexical itself hydrates a node
-* without a `version`, or with the wrong kind of one, unchanged - but a
-* consumer reading the document through the generated types has been promised
-* an integer, and `BlockNode.importJSON` migrates on it.
-*/ const UNIVERSAL_PROPERTIES = { version: "number" };
-/**
-* The root, as Payload declares it and as an editor exports it: these six
-* properties, these kinds, and nothing else.
+* The root as Payload declares it and an editor exports it: these six
+* properties, these kinds, nothing else.
 */ const ROOT_PROPERTIES = {
 	children: "array",
 	direction: "direction",
@@ -118,20 +100,11 @@ const ELEMENT_PROPERTIES = {
 };
 /**
 * What a serialized node must carry beyond {@link UNIVERSAL_PROPERTIES}, keyed
-* by node type.
-*
-* Payload stores an editor state without hydrating it, so a node written
-* without these, or with the wrong kind of value, is accepted and only fails
-* later, in the admin editor. Payload declares nothing per node type, so this
-* table is measured instead: an entry belongs here only if breaking it makes
-* Lexical throw, or changes what the editor reads back. An element's `format`
-* and a paragraph's text defaults are absent for that reason.
-* `lexical.spec.ts` holds every entry to the rule against the node classes
-* `@payloadcms/richtext-lexical` ships, so extend that test first.
-*
-* A node type with no entry is checked for the universal properties only.
-* Guessing at the requirements of a project's own nodes would reject content
-* that works.
+* by node type. Payload stores a state without hydrating it, so a node missing
+* these fails only later, in the admin editor. Payload declares nothing per
+* node type, so the table is measured: an entry belongs only if breaking it
+* makes Lexical throw or changes what the editor reads back. A type with no
+* entry is not guessed at, since that would reject a project's working nodes.
 */ const REQUIRED_NODE_PROPERTIES = {
 	autolink: {
 		...ELEMENT_PROPERTIES,
@@ -175,31 +148,22 @@ const ELEMENT_PROPERTIES = {
 	}
 };
 /**
-* Whether the table already says what a node type's `fields` has to be, so the
-* sub-field walk does not report the same problem a second time.
-*/ const constrainsFields = (type) => "fields" in (REQUIRED_NODE_PROPERTIES[type] ?? {});
+* Whether the table already says what a node type's `fields` must be, so the
+* sub-field walk does not report the same problem twice.
+*/ const constrainsFields = (type) => "fields" in (ownValue(REQUIRED_NODE_PROPERTIES, type) ?? {});
 const describeConstraints = (constraints) => Object.fromEntries(Object.entries(constraints).map(([property, constraint]) => [property, needs(constraint)]).sort((left, right) => left[0].localeCompare(right[0])));
 /**
-* What each of the given node types has to carry, phrased the way the write
-* side phrases it when it refuses one, so the listing and the error message
-* never disagree. Read straight off the tables above, which is what keeps it
-* true: nothing here is stated a second time.
-*
-* Keyed by node type rather than reported per field, because that is what it
-* depends on. A field says which types it allows, in its `nodes`; what a `text`
-* node has to carry is the same wherever one is written, so a response that
-* describes twenty rich text fields still states it once.
-*
-* `type` is listed although {@link UNIVERSAL_PROPERTIES} omits it. The
-* validator never reports it missing, because a node's `type` is how it finds
-* the entry to check against, but a client assembling a node from this listing
-* still has to write one.
+* What each node type must carry, phrased as the write side phrases its
+* refusals so the two never disagree. Keyed by node type, since a `text` node
+* needs the same wherever it is written. `type` is listed although
+* {@link UNIVERSAL_PROPERTIES} omits it: the validator finds the entry by
+* `type` and so never reports it missing, but a client must still write one.
 */ const nodePropertiesFor = (types) => Object.fromEntries([...new Set(types)].sort().map((type) => [type, describeConstraints(type === "root" ? ROOT_PROPERTIES : {
-	...REQUIRED_NODE_PROPERTIES[type],
+	...ownValue(REQUIRED_NODE_PROPERTIES, type),
 	...UNIVERSAL_PROPERTIES,
 	type: "string"
 })]));
-/** Present but `null` counts as present: `direction` is serialized that way. */ const check = (node, constraints) => {
+const check = (node, constraints) => {
 	const problems = {
 		missing: [],
 		rejected: []
@@ -215,36 +179,29 @@ const describeConstraints = (constraints) => Object.fromEntries(Object.entries(c
 };
 const nodeProblems = (node) => check(node, {
 	...UNIVERSAL_PROPERTIES,
-	...REQUIRED_NODE_PROPERTIES[node["type"]] ?? {}
+	...ownValue(REQUIRED_NODE_PROPERTIES, node["type"])
 });
 /**
 * The root is the one node Payload describes itself, down to refusing an
-* unknown property, so it is checked against that description rather than
-* against the walk's table.
+* unknown property, so it is checked against that description instead of the
+* walk's table.
 */ const rootProblems = (root) => ({
 	...check(root, ROOT_PROPERTIES),
-	unexpected: Object.keys(root).filter((property) => !(property in ROOT_PROPERTIES))
+	unexpected: Object.keys(root).filter((property) => !Object.hasOwn(ROOT_PROPERTIES, property))
 });
 /**
-* What one serialized property has to be, for a write addressing a property
-* rather than a whole node.
-*
-* Absent where the table says nothing, which is the same tolerance the node
-* walk shows: a project's own node may carry any property, and guessing at one
-* would reject content that works.
+* What one serialized property must be, for a write addressing a property
+* instead of a whole node. Absent where the table says nothing, matching the
+* node walk: a project's own node may carry any property.
 */ const propertyProblem = (nodeType, property, value) => {
-	const constraint = (nodeType === "root" ? ROOT_PROPERTIES : {
+	const constraints = nodeType === "root" ? ROOT_PROPERTIES : {
 		...UNIVERSAL_PROPERTIES,
-		...REQUIRED_NODE_PROPERTIES[nodeType] ?? {}
-	})[property];
+		...ownValue(REQUIRED_NODE_PROPERTIES, nodeType)
+	};
+	const constraint = ownValue(constraints, property);
 	return constraint === void 0 || accepts(constraint, value) ? void 0 : { needs: needs(constraint) };
 };
-/**
-* Only properties a feature narrows and Lexical does not check on its own
-* belong here. Everything else a feature restricts is already visible: a
-* link's targets through its sub-schema, a block node's choices through the
-* slugs it accepts.
-*/ const NODE_OPTION_SOURCES = [{
+const NODE_OPTION_SOURCES = [{
 	defaults: [
 		"h1",
 		"h2",
@@ -258,13 +215,7 @@ const nodeProblems = (node) => check(node, {
 	nodeProp: "tag",
 	nodeType: "heading"
 }];
-/**
-* The props a feature was resolved with.
-*
-* Sanitizing the editor drops every feature's props from `editorConfig.features`
-* but leaves them on `resolvedFeatureMap`. A feature that declares no server
-* props keeps only the client ones, so both are tried.
-*/ const featurePropsOf = (field, featureKey) => {
+const featurePropsOf = (field, featureKey) => {
 	const resolved = field.editor?.editorConfig?.resolvedFeatureMap?.get(featureKey);
 	const props = resolved?.sanitizedServerFeatureProps ?? resolved?.clientFeatureProps;
 	return typeof props === "object" && props !== null ? props : void 0;

package/dist/schema/outline.mjs

@@ -1,24 +1,14 @@
+import { isPlainObject, ownValue } from "../guards.mjs";
 import { allowedNodeTypes, nodeOptions } from "./lexical.mjs";
-import { isPlainObject } from "./walk.mjs";
 //#region src/schema/outline.ts
-/**
-* Long enough to identify a paragraph, short enough that an outline of a real
-* document stays a fraction of the size of its editor state.
-*/ const TEXT_PREVIEW_LENGTH = 80;
-/**
-* Every descendant text node contributes, not only direct children, since a
-* link or a formatting mark nests the text a level deeper.
-*/ const collectText = (node) => {
+const TEXT_PREVIEW_LENGTH = 80;
+const collectText = (node) => {
 	if (node["type"] === "text") return typeof node["text"] === "string" ? node["text"] : "";
 	const children = node["children"];
 	return Array.isArray(children) ? children.filter(isPlainObject).map((child) => collectText(child)).join("") : "";
 };
 const preview = (text) => text.length > TEXT_PREVIEW_LENGTH ? `${text.slice(0, TEXT_PREVIEW_LENGTH)}…` : text;
-/**
-* Only the properties a feature actually narrows for this node type, and only
-* where the node carries a string for one. A node missing the property, or
-* carrying something the feature never produces, says nothing worth reporting.
-*/ const narrowedOptions = (node, narrowed) => {
+const narrowedOptions = (node, narrowed) => {
 	if (!narrowed) return;
 	const set = Object.keys(narrowed).flatMap((property) => {
 		const value = node[property];
@@ -31,7 +21,7 @@ const walk = (node, pointer, options, entries) => {
 	if (typeof type !== "string") return;
 	const version = node["version"];
 	const text = preview(collectText(node));
-	const nodeOptionsFound = narrowedOptions(node, options?.[type]);
+	const nodeOptionsFound = narrowedOptions(node, ownValue(options, type));
 	const children = node["children"];
 	const childCount = Array.isArray(children) ? children.length : 0;
 	entries.push({

package/dist/schema/path.mjs

@@ -0,0 +1,28 @@
+//#region src/schema/path.ts
+const JSON_POINTER_PATTERN = /^(\/([^~/]|~[01])*)*$/;
+/**
+* No segments is the root pointer, `""`.
+*/ const joinPath = (parts) => parts.map((part) => `/${part.replace(/~/g, "~0").replace(/\//g, "~1")}`).join("");
+/**
+* Unescapes `~1` and `~0`. The root pointer yields no segments.
+*/ const splitPath = (path) => path.split("/").slice(1).map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+const PROTOTYPE_SEGMENTS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/**
+* No field or node property has one of these names. rfc6902 skips them as
+* intermediate tokens but writes them as a final key, so a pointer containing
+* one is refused before anything resolves it.
+*/ const prototypeSegmentProblem = (pointer) => splitPath(pointer).some((segment) => PROTOTYPE_SEGMENTS.has(segment)) ? `"${pointer}" contains a segment named __proto__, constructor or prototype, which no field or node property uses.` : void 0;
+/**
+* `-` included, since RFC 6901 reads it as the position after the last.
+*/ const isIndexSegment = (segment) => segment === "-" || /^\d+$/.test(segment);
+/**
+* A path Payload reports on a validation error (`layout.0.title`) as a JSON
+* Pointer, so everything handed back addresses documents the same way. The
+* path already carries real indices, so it maps directly.
+*/ const pointerFromPayloadPath = (path) => path ? joinPath(path.split(".")) : "";
+//#endregion
+export { JSON_POINTER_PATTERN, isIndexSegment, joinPath, pointerFromPayloadPath, prototypeSegmentProblem, splitPath };