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

package/dist/schema/lexical.mjs

@@ -1,25 +1,15 @@
+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) => {
 	const registered = (featuresOf(field)?.nodes ?? []).flatMap((entry) => {
@@ -52,10 +42,7 @@ const lexicalSubSchema = (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 = {
+const KINDS = {
 	array: {
 		accepts: (value) => Array.isArray(value),
 		needs: "an array"
@@ -69,11 +56,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 +75,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 +96,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 +144,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 +175,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 +211,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,22 @@
+//#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 };

package/dist/schema/pointer.mjs

@@ -1,39 +1,33 @@
-import { blockOf, blockSlugsOf, describeAddressableFields, findBlocksField, findRichTextField, isIndexSegment, joinPath, splitPath, targetOf } from "./walk.mjs";
+import { isIndexSegment, joinPath, splitPath } from "./path.mjs";
+import { blockOf, blockSlugsOf, describeAddressableFields, findBlocksField, findRichTextField, schemaOf } from "./walk.mjs";
+import { SchemaError } from "./errors.mjs";
 import { resolveLexicalPointer } from "./lexical-pointer.mjs";
 //#region src/schema/pointer.ts
 const partMatches = (part, segment) => segment !== void 0 && (part === "*" ? isIndexSegment(segment) : part === segment);
-/**
-* Longest descriptor whose path is fully consumed by the leading segments.
-*/ const longestMatch = (descriptors, segments) => descriptors.map((descriptor) => ({
+const matchPointerSegments = (descriptors, segments) => descriptors.map((descriptor) => ({
 	consumed: splitPath(descriptor.path).length,
 	descriptor,
 	parts: splitPath(descriptor.path)
 })).filter(({ parts }) => parts.every((part, offset) => partMatches(part, segments[offset]))).sort((left, right) => right.consumed - left.consumed)[0];
-/** Stopping part-way through a descriptor's path means a subtree, not a field. */ const isSubtreePrefix = (descriptors, segments) => descriptors.some((descriptor) => {
+const isSubtreePrefix = (descriptors, segments) => descriptors.some((descriptor) => {
 	const parts = splitPath(descriptor.path);
 	return parts.length > segments.length && segments.every((segment, offset) => {
 		const part = parts[offset];
 		return part !== void 0 && partMatches(part, segment);
 	});
 });
-/**
-* Unlike a descriptor path, the segments carry real indices, so intervening
-* array fields are descended through rather than skipped.
-*/ const valueAtSegments = (data, segments) => segments.reduce((current, segment) => current === null || typeof current !== "object" ? void 0 : current[segment], data);
-/**
-* The stored row decides which block sits at an index, since a blocks field
-* admits many shapes at the same position. A row the document does not have
-* yet takes its slug from the value being added.
-*/ const stepIntoBlock = (at) => {
+const valueAtSegments = (data, segments) => segments.reduce((current, segment) => current === null || typeof current !== "object" ? void 0 : current[segment], data);
+const stepIntoBlock = (at) => {
 	const { addedValue, config, descriptor, rows } = at;
 	const [index, ...remaining] = at.rest;
-	if (!isIndexSegment(index)) throw new Error(`"${descriptor.path}" is an array; "${index}" is not an index.`);
+	if (!isIndexSegment(index)) throw new SchemaError(`"${descriptor.path}" is an array; "${index}" is not an index.`);
 	const field = findBlocksField(at.fields, splitPath(descriptor.path));
 	const existing = Array.isArray(rows) && index !== "-" ? rows[Number(index)] : void 0;
 	const slug = existing?.blockType ?? addedValue?.blockType;
-	if (!field || slug === void 0) throw new Error(`Cannot tell which block "${descriptor.path}/${index}" is. Supply a "blockType" on the value, one of: ${field ? blockSlugsOf(field).join(", ") : ""}`);
+	if (!field || slug === void 0) throw new SchemaError(`Cannot tell which block "${descriptor.path}/${index}" is. Supply a "blockType" on the value, one of: ${field ? blockSlugsOf(field).join(", ") : ""}`);
+	if (typeof slug !== "string") throw new SchemaError(`"blockType" must be a string naming a block at "${descriptor.path}". Allowed: ${blockSlugsOf(field).join(", ")}`);
 	const block = blockOf(config, field, slug);
-	if (!block) throw new Error(`"${slug}" is not allowed at "${descriptor.path}". Allowed: ${blockSlugsOf(field).join(", ")}`);
+	if (!block) throw new SchemaError(`"${slug}" is not allowed at "${descriptor.path}". Allowed: ${blockSlugsOf(field).join(", ")}`);
 	return {
 		blockType: slug,
 		data: existing,
@@ -42,12 +36,11 @@ const partMatches = (part, segment) => segment !== void 0 && (part === "*" ? isI
 	};
 };
 /**
-* The stored document chooses the branch at every blocks element, and is
-* required rather than optional: `/layout/sections/3/modules/1`
-* can only be resolved by reading `blockType` off `sections[3]`, since a blocks
-* field admits many shapes at the same index.
+* The stored document is required because it chooses the branch at every blocks
+* element: `/layout/sections/3/modules/1` can only be resolved by reading
+* `blockType` off `sections[3]`.
 */ const resolveDataPointer = (config, target) => {
-	let fields = targetOf(config, target.ref).flattenedFields;
+	let fields = schemaOf(config, target.ref).flattenedFields;
 	let data = target.doc;
 	let blockType;
 	let segments = splitPath(target.pointer);
@@ -55,14 +48,14 @@ const partMatches = (part, segment) => segment !== void 0 && (part === "*" ? isI
 	let inLexical;
 	while (segments.length > 0) {
 		const descriptors = describeAddressableFields(fields);
-		const match = longestMatch(descriptors, segments);
+		const match = matchPointerSegments(descriptors, segments);
 		if (!match) {
 			if (isSubtreePrefix(descriptors, segments)) return {
 				...blockType === void 0 ? {} : { blockType },
 				fields,
 				prefix: segments.map((segment) => isIndexSegment(segment) ? "*" : segment)
 			};
-			throw new Error(`"${joinPath(segments)}" is not a field here. Available: ${descriptors.map((descriptor) => descriptor.path).join(", ")}`);
+			throw new SchemaError(`"${joinPath(segments)}" is not a field here. Available: ${descriptors.map((descriptor) => descriptor.path).join(", ")}`);
 		}
 		const rest = segments.slice(match.consumed);
 		if (rest.length === 0) return {
@@ -100,7 +93,7 @@ const partMatches = (part, segment) => segment !== void 0 && (part === "*" ? isI
 			segments = step.rest;
 			continue;
 		}
-		if (match.descriptor.type !== "blocks") throw new Error(`"${match.descriptor.path}" is a ${match.descriptor.type} field and has no "${joinPath(rest)}" beneath it.`);
+		if (match.descriptor.type !== "blocks") throw new SchemaError(`"${match.descriptor.path}" is a ${match.descriptor.type} field and has no "${joinPath(rest)}" beneath it.`);
 		const step = stepIntoBlock({
 			addedValue: target.addedValue,
 			descriptor: match.descriptor,

package/dist/schema/shape.mjs

@@ -1,22 +1,19 @@
+import { isPlainObject, ownValue } from "../guards.mjs";
 import { ROOT_PROPERTIES, constrainsFields, lexicalSubSchema, nodeProblems, propertyProblem, rootProblems } from "./lexical.mjs";
-import { blockOf, blockSlugsOf, describeAddressableFields, findBlocksField, findRichTextField, isPlainObject, splitPath } from "./walk.mjs";
+import { splitPath } from "./path.mjs";
+import { ROW_KEYS, blockOf, blockSlugsOf, descriptorsUnder, findBlocksField, findRichTextField } from "./walk.mjs";
 //#region src/schema/shape.ts
-const TOLERATED_VALUE_KEYS = /* @__PURE__ */ new Set([
-	"blockName",
-	"blockType",
-	"id"
-]);
 /**
-* Lexical refuses to hydrate a state whose root holds nothing: `isEmpty` is a
-* node map of one, and the editor throws on it rather than rendering nothing.
-* An empty field is stored as null instead, so this is only ever reached by
-* emptying one that was there.
+* Lexical throws when it hydrates a state whose root holds nothing. An empty
+* field is stored as null, so this is reached only by emptying one that had
+* content.
 */ const EMPTY_ROOT = "an editor state needs at least one node. Clear the field with null instead.";
 const quoted = (properties) => properties.map((property) => `"${property}"`).join(", ");
-/**
-* A node with nothing to declare, and one whose sub-fields cannot be named at a
-* position, are both left alone.
-*/ const checkNodeFields = (scope, field, node) => {
+const refusedSlug = (slug) => {
+	if (slug === void 0) return `a row needs a "blockType"`;
+	return typeof slug === "string" ? `"${slug}" is not allowed here` : `"blockType" must be a string naming a block`;
+};
+const checkNodeFields = (scope, field, node) => {
 	const sub = lexicalSubSchema(field, node.type);
 	if (!sub) return;
 	const data = node.fields;
@@ -39,7 +36,7 @@ const quoted = (properties) => properties.map((property) => `"${property}"`).joi
 	const slug = data["blockType"];
 	const block = typeof slug === "string" ? blockOf(scope.config, sub.blocksField, slug) : void 0;
 	if (!block) {
-		scope.problems.push(`${scope.pointer}/fields: "${String(slug)}" is not allowed here. Allowed: ${blockSlugsOf(sub.blocksField).join(", ")}`);
+		scope.problems.push(`${scope.pointer}/fields: ${refusedSlug(slug)}. Allowed: ${blockSlugsOf(sub.blocksField).join(", ")}`);
 		return;
 	}
 	checkValue({
@@ -47,28 +44,10 @@ const quoted = (properties) => properties.map((property) => `"${property}"`).joi
 		fields: block.flattenedFields
 	}, data);
 };
-/**
-* An absent property is already reported as missing. Anything else present is
-* checked, not just a string: Lexical stores a heading tag of 3 as readily as
-* one of "h3".
-*/ const checkNarrowedProperty = (scope, at, value) => {
+const checkNarrowedProperty = (scope, at, value) => {
 	if (value !== void 0 && !(typeof value === "string" && at.values.includes(value))) scope.problems.push(`${at.pointer}: ${JSON.stringify(value)} is not available for a "${at.type}" node in this field's editor. Allowed: ${at.values.join(", ")}`);
 };
-/**
-* One node, wherever it came from. `pointer` addresses the node itself, so a
-* node written at a position and a node written inside a whole editor state
-* are held to the same rules and report them the same way.
-*
-* Payload does not check any of this: the Lexical validator runs node
-* validations only for the few node types that register one, so a `heading`
-* inside a field whose editor has no heading feature is stored without
-* complaint and only fails later, at render or when the document is reopened
-* in the admin editor. A key a node's fields do not declare is dropped just as
-* silently. The same holds one level down, for the node properties a feature
-* narrows: an `h3` in an editor restricted to `h4` is stored as readily as an
-* `h4`, and a node written without the properties its class hydrates from is
-* stored and then throws when the editor opens it.
-*/ const checkNode = (scope, editor, node, pointer) => {
+const checkNode = (scope, editor, node, pointer) => {
 	if (!isPlainObject(node) || typeof node["type"] !== "string") {
 		scope.problems.push(`${pointer}: every node needs a "type".`);
 		return;
@@ -81,7 +60,7 @@ const quoted = (properties) => properties.map((property) => `"${property}"`).joi
 	const problems = nodeProblems(node);
 	if (problems.missing.length > 0) scope.problems.push(`${pointer}: a "${type}" node is missing ${quoted(problems.missing)}. Write nodes as Lexical serializes them.`);
 	for (const problem of problems.rejected) scope.problems.push(`${pointer}/${problem.property}: a "${type}" node needs ${problem.needs} here.`);
-	for (const [property, values] of Object.entries(editor.nodeOptions?.[type] ?? {})) checkNarrowedProperty(scope, {
+	for (const [property, values] of Object.entries(ownValue(editor.nodeOptions, type) ?? {})) checkNarrowedProperty(scope, {
 		pointer: `${pointer}/${property}`,
 		type,
 		values
@@ -95,7 +74,7 @@ const quoted = (properties) => properties.map((property) => `"${property}"`).joi
 	});
 	checkNodes(scope, editor, node["children"], `${pointer}/children`);
 };
-/** `pointer` addresses the list. A node holding none is left alone. */ const checkNodes = (scope, editor, nodes, pointer) => {
+const checkNodes = (scope, editor, nodes, pointer) => {
 	if (!Array.isArray(nodes)) return;
 	nodes.forEach((node, index) => {
 		checkNode(scope, editor, node, `${pointer}/${String(index)}`);
@@ -114,34 +93,26 @@ const checkRichText = (scope, editor, value) => {
 	if (Array.isArray(root["children"]) && root["children"].length === 0) scope.problems.push(`${scope.pointer}/root/children: ${EMPTY_ROOT}`);
 	checkNodes(scope, editor, root["children"], `${scope.pointer}/root/children`);
 };
-/**
-* `type` decides how every other property on a node is read, so replacing it
-* alone would leave a heading shaped like a text node. Everything else is held
-* to the constraint the node walk holds it to and nothing more, since a
-* feature may put any property on a node.
-*/ const checkNodeProperty = (scope, editor, position, value) => {
+const checkNodeProperty = (scope, editor, position, value) => {
 	const { nodeType: type, property } = position;
 	if (property === "type") {
 		scope.problems.push(`${scope.pointer}: a node's "type" cannot be replaced on its own. Replace the whole node.`);
 		return;
 	}
-	if (position.isRoot && !(property in ROOT_PROPERTIES)) {
+	if (position.isRoot && !Object.hasOwn(ROOT_PROPERTIES, property)) {
 		scope.problems.push(`${scope.pointer}: no such property on the root node. Available: ${Object.keys(ROOT_PROPERTIES).join(", ")}`);
 		return;
 	}
 	const problem = propertyProblem(type, property, value);
 	if (problem) scope.problems.push(`${scope.pointer}: a "${type}" node needs ${problem.needs} here.`);
-	const values = editor.nodeOptions?.[type]?.[property];
+	const values = ownValue(ownValue(editor.nodeOptions, type), property);
 	if (values) checkNarrowedProperty(scope, {
 		pointer: scope.pointer,
 		type,
 		values
 	}, value);
 };
-/**
-* A value written at a position inside an editor state rather than as the
-* whole state.
-*/ const checkLexicalWrite = (scope, position, value) => {
+const checkLexicalWrite = (scope, position, value) => {
 	const editor = {
 		allowed: position.descriptor.nodes ?? [],
 		field: position.field,
@@ -193,7 +164,7 @@ const checkLeafValue = (scope, descriptor, value) => {
 		const slug = isPlainObject(row) ? row["blockType"] : void 0;
 		const block = typeof slug === "string" ? blockOf(scope.config, field, slug) : void 0;
 		if (!block) {
-			scope.problems.push(`${scope.pointer}/${String(index)}: "${String(slug)}" is not allowed here. Allowed: ${blockSlugsOf(field).join(", ")}`);
+			scope.problems.push(`${scope.pointer}/${String(index)}: ${refusedSlug(slug)}. Allowed: ${blockSlugsOf(field).join(", ")}`);
 			return;
 		}
 		checkValue({
@@ -204,27 +175,12 @@ const checkLeafValue = (scope, descriptor, value) => {
 		}, row);
 	});
 };
-/**
-* Reports every shape problem rather than the first.
-*
-* Shape only: unknown field names, unknown block slugs, read-only fields, and
-* rich text nodes or node properties the field's editor cannot produce.
-* Required-ness, row counts, lengths, enum membership and relationship
-* existence stay with Payload, which already checks them and reports them per
-* field. Without this pass a misspelled field inside a new block would be
-* stripped in silence.
-*/ const checkValue = (scope, value) => {
+const checkValue = (scope, value) => {
 	if (!isPlainObject(value)) return;
 	const prefixParts = scope.prefix;
-	const relative = describeAddressableFields(scope.fields).flatMap((descriptor) => {
-		const parts = splitPath(descriptor.path);
-		return prefixParts.every((part, offset) => part === parts[offset]) ? [{
-			descriptor,
-			parts: parts.slice(prefixParts.length)
-		}] : [];
-	});
+	const relative = descriptorsUnder(scope.fields, prefixParts);
 	for (const [key, entry] of Object.entries(value)) {
-		if (TOLERATED_VALUE_KEYS.has(key)) continue;
+		if (ROW_KEYS.has(key)) continue;
 		const candidates = relative.filter(({ parts }) => parts[0] === key);
 		const pointer = `${scope.pointer}/${key}`;
 		if (candidates.length === 0) {
@@ -264,9 +220,7 @@ const checkLeafValue = (scope, descriptor, value) => {
 		}, entry);
 	}
 };
-/**
-* Shape problems with a value about to be written at a resolved pointer.
-*/ const validateWriteValue = (config, target, value) => {
+/** Shape problems with a value about to be written at a resolved pointer. */ const validateWriteValue = (config, target, value) => {
 	const problems = [];
 	const scope = {
 		config,