@payloadcms/plugin-mcp 3.86.0-internal.ac46214 → 4.0.0-canary.1

package/dist/utils/schemaConversion/sanitizeEntitySchema.js

@@ -0,0 +1,464 @@
+/**
+ * Turns the JSON Schema that Payload generates for a collection or global into the input schema for
+ * an MCP create/update tool. In short, it:
+ *
+ * - drops fields a client can't set (`id`, `createdAt`, the draft `_status`, …),
+ * - rewrites Payload-specific field shapes (points, relationships) into plain JSON the model can fill,
+ * - and shrinks the result so it's cheaper for the model to read,
+ *
+ * while keeping every node valid JSON Schema draft 2020-12. Each step below is tagged with why it runs -
+ * **Correctness** (valid input the API accepts), **Size** (equivalence-preserving shrink), or **LLM
+ * ergonomics** (easier for the model to read/fill) - and carries a before/after example on its definition.
+ */ export const sanitizeEntitySchema = (schema)=>{
+    // Work on a copy — the caller reuses the original schema elsewhere (e.g. when listing tools).
+    let result = structuredClone(schema);
+    // Correctness — drop the fields a client can't set (id, createdAt, updatedAt, draft _status) + collapse nullable types.
+    result = removeManagedFields(result);
+    // LLM ergonomics — rewrite point fields from a `[number, number]` tuple into a `{ longitude, latitude }` object.
+    result = pointFieldsToObjects(result);
+    // Correctness — a relationship value can be an ID or a populated doc; on input only the ID is valid, so keep that.
+    result = relationshipsToIds(result);
+    // Size — strip inert type-gen leftovers that only bloat the schema (`tsType`, block-collision notes).
+    result = removeTypeGenArtifacts(result);
+    // Size — where a `const` already pins a value, the sibling `type` is redundant; remove it.
+    result = dropRedundantConstType(result);
+    // Size — fold per-collection relationship/upload variants (identical but for `relationTo`) into one `enum`.
+    result = mergeConstDiscriminatedUnions(result);
+    // Size — pull any subschema that appears more than once into a single shared `$defs` entry.
+    result = deduplicateIntoDefinitions(result);
+    // LLM ergonomics — give `$defs` short, readable names (`Code`, `paragraph`, `node`) so the `$ref`s read nicely.
+    result = shortenDefinitionNames(result);
+    return result;
+};
+/**
+ * Rebuilds a schema bottom-up, calling `visit` on each node after its children. Shared by the
+ * transforms that need to touch every node in the tree.
+ */ const mapNodes = (node, visit)=>{
+    if (Array.isArray(node)) {
+        return node.map((child)=>mapNodes(child, visit));
+    }
+    if (!node || typeof node !== 'object') {
+        return node;
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(node)){
+        out[key] = mapNodes(value, visit);
+    }
+    return visit(out);
+};
+// Payload sets these on every document, so an MCP client never provides them when creating/updating.
+const PAYLOAD_MANAGED_FIELDS = new Set([
+    '_status',
+    'createdAt',
+    'id',
+    'updatedAt'
+]);
+/**
+ * **Correctness.** Removes the fields a client can't set on create/update - `id`, `createdAt`, `updatedAt`, and the draft
+ * `_status` - from every field object's `properties` and `required` (recursing into nested objects and
+ * array items). Along the way it also collapses optional array/object types via {@link collapseNullableType}.
+ *
+ * @example
+ * { properties: { id: { type: 'string' }, tags: { type: ['array', 'null'], items: {} } }, required: ['id', 'tags'] }
+ * → { properties: { tags: { type: 'array', items: {} } }, required: ['tags'] }
+ */ const removeManagedFields = (schema)=>{
+    if (schema.properties && typeof schema.properties === 'object') {
+        for (const field of PAYLOAD_MANAGED_FIELDS){
+            delete schema.properties[field];
+        }
+        for (const key of Object.keys(schema.properties)){
+            const prop = schema.properties[key];
+            if (!prop || typeof prop !== 'object') {
+                continue;
+            }
+            const isRequired = Array.isArray(schema.required) && schema.required.includes(key);
+            collapseNullableType(prop, isRequired);
+            if (prop.properties) {
+                removeManagedFields(prop);
+            }
+            if (prop.items && typeof prop.items === 'object' && !Array.isArray(prop.items)) {
+                removeManagedFields(prop.items);
+            }
+        }
+    }
+    if (Array.isArray(schema.required)) {
+        schema.required = schema.required.filter((name)=>!PAYLOAD_MANAGED_FIELDS.has(name));
+        if (schema.required.length === 0) {
+            delete schema.required;
+        }
+    }
+    return schema;
+};
+/**
+ * Drops the `'null'` from an optional array/object type (`['array', 'null']` → `'array'`, likewise
+ * `'object'`). Payload marks a field optional by unioning its type with `'null'`, but a create/update
+ * tool already conveys "optional" through the `required` list - the client just omits the field - so the
+ * `'null'` is redundant here. Dropping it shows the model a plain `type: 'array'` instead of implying it
+ * should send a literal `null`.
+ *
+ * We never touch the `required` list, so this can't change whether a field is required. And we skip fields
+ * that ARE required (`isRequired`): there a `'null'` is a value the field genuinely accepts, not optionality
+ * encoding. Nullable scalars (`['string', 'null']`) are also left alone - they read fine as `string | null`.
+ *
+ * @example
+ * optional { type: ['array', 'null'] } → { type: 'array' }   (still optional, just no longer null-valued)
+ * required { type: ['array', 'null'] } → unchanged
+ * { type: ['string', 'null'] } → unchanged
+ */ const collapseNullableType = (schema, isRequired)=>{
+    if (isRequired || !Array.isArray(schema.type)) {
+        return;
+    }
+    const nonNullTypes = schema.type.filter((t)=>t !== 'null');
+    if (nonNullTypes.length === 1 && (nonNullTypes[0] === 'array' || nonNullTypes[0] === 'object')) {
+        schema.type = nonNullTypes[0];
+    }
+};
+/**
+ * **LLM ergonomics.** Rewrites a point field (stored as a two-number tuple) into a `{ longitude, latitude }` object, which
+ * is far easier for the model to fill in than a positional array. This is input-only and lossless: the
+ * create/update handler converts the object back to the `[longitude, latitude]` tuple Payload stores,
+ * via `transformPointDataToPayload`.
+ *
+ * @example
+ * { type: 'array', items: [{ type: 'number' }, { type: 'number' }] }
+ * → { type: 'object', properties: { longitude: { type: 'number' }, latitude: { type: 'number' } }, required: ['longitude', 'latitude'] }
+ */ const pointFieldsToObjects = (schema)=>{
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    const transformed = {
+        ...schema
+    };
+    if (transformed.properties && typeof transformed.properties === 'object') {
+        transformed.properties = Object.fromEntries(Object.entries(transformed.properties).map(([key, value])=>{
+            if (!value || typeof value !== 'object') {
+                return [
+                    key,
+                    value
+                ];
+            }
+            const isArrayType = value.type === 'array' || Array.isArray(value.type) && value.type.includes('array');
+            const isPointField = isArrayType && Array.isArray(value.items) && value.items.length === 2 && value.items.every((item)=>item && typeof item === 'object' && item.type === 'number');
+            if (isPointField) {
+                const isNullable = Array.isArray(value.type) && value.type.includes('null');
+                return [
+                    key,
+                    {
+                        type: isNullable ? [
+                            'object',
+                            'null'
+                        ] : 'object',
+                        description: value.description || 'Geographic coordinates (longitude, latitude)',
+                        properties: {
+                            latitude: {
+                                type: 'number',
+                                description: 'Latitude coordinate'
+                            },
+                            longitude: {
+                                type: 'number',
+                                description: 'Longitude coordinate'
+                            }
+                        },
+                        required: [
+                            'longitude',
+                            'latitude'
+                        ]
+                    }
+                ];
+            }
+            return [
+                key,
+                pointFieldsToObjects(value)
+            ];
+        }));
+    }
+    if (transformed.items && typeof transformed.items === 'object' && !Array.isArray(transformed.items)) {
+        transformed.items = pointFieldsToObjects(transformed.items);
+    }
+    return transformed;
+};
+/**
+ * **Correctness.** Reduces relationship/upload fields to the IDs a client actually sends. Payload types the value as
+ * "an ID or the full related document" - but the populated-document form only appears in read responses;
+ * on create/update you always reference a relationship by its ID. So we drop that `$ref` option, leaving
+ * the bare ID. A single remaining target collapses inline (with a description naming the target
+ * collection); several targets become an `anyOf` of IDs.
+ *
+ * @example
+ * { oneOf: [{ type: 'string' }, { $ref: '#/$defs/posts' }] }
+ * → { type: 'string', description: 'The ID of the related "posts" document.' }
+ */ const relationshipsToIds = (schema)=>{
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    const processed = {
+        ...schema
+    };
+    if (Array.isArray(processed.oneOf)) {
+        const isRelatedDocRef = (option)=>!!option && typeof option === 'object' && '$ref' in option;
+        if (processed.oneOf.some(isRelatedDocRef)) {
+            // A relationship value is "an ID, or the populated related document". Keep the ID option(s) and
+            // drop the `$ref`s to the related collections, since a client only ever sends the ID.
+            const idOptions = processed.oneOf.filter((option)=>!isRelatedDocRef(option)).map((option)=>typeof option === 'object' ? relationshipsToIds(option) : option);
+            const targetCollections = processed.oneOf.filter(isRelatedDocRef).map((option)=>option.$ref.replace('#/$defs/', ''));
+            if (idOptions.length === 1) {
+                delete processed.oneOf;
+                Object.assign(processed, idOptions[0]);
+                if (targetCollections.length > 0 && !processed.description) {
+                    processed.description = `The ID of the related "${targetCollections.join('" or "')}" document.`;
+                }
+            } else if (idOptions.length > 1) {
+                delete processed.oneOf;
+                processed.anyOf = idOptions;
+            }
+        } else {
+            processed.oneOf = processed.oneOf.map((option)=>typeof option === 'object' ? relationshipsToIds(option) : option);
+        }
+    }
+    if (processed.properties && typeof processed.properties === 'object') {
+        processed.properties = Object.fromEntries(Object.entries(processed.properties).map(([key, value])=>[
+                key,
+                typeof value === 'object' ? relationshipsToIds(value) : value
+            ]));
+    }
+    if (processed.items && typeof processed.items === 'object' && !Array.isArray(processed.items)) {
+        processed.items = relationshipsToIds(processed.items);
+    }
+    // Lexical node unions and blocks live under `$defs` and have their own relationship fields, so walk
+    // those too — otherwise their `$ref`s would dangle once we don't bundle the related collections.
+    if (processed.$defs && typeof processed.$defs === 'object') {
+        processed.$defs = Object.fromEntries(Object.entries(processed.$defs).map(([key, value])=>[
+                key,
+                typeof value === 'object' ? relationshipsToIds(value) : value
+            ]));
+    }
+    return processed;
+};
+/**
+ * **Size.** Strips type-generation leftovers that bloat the schema without helping the model: the `tsType`
+ * hint (a `json-schema-to-typescript` extension; JSON Schema validators just ignore it, they don't reject it)
+ * and the block-interface-collision note Payload adds to some block descriptions (the
+ * `block-interface-name-collisions` docs link set in `registerBlockInterface`, see configToJSONSchema.ts).
+ * Both are inert here - removing them only shrinks the schema (and spares the model irrelevant noise).
+ *
+ * @example
+ * { type: 'object', tsType: 'SerializedBlockNode', description: 'see …#block-interface-name-collisions' }
+ * → { type: 'object' }
+ */ const removeTypeGenArtifacts = (schema)=>mapNodes(schema, (node)=>{
+        delete node.tsType;
+        const { description } = node;
+        if (typeof description === 'string' && description.includes('block-interface-name-collisions')) {
+            delete node.description;
+        }
+        return node;
+    });
+/**
+ * **Size.** Removes `type` whenever a `const` sits next to it — the constant already fixes the value.
+ *
+ * @example
+ * { type: 'string', const: 'paragraph' } → { const: 'paragraph' }
+ */ const dropRedundantConstType = (schema)=>mapNodes(schema, (node)=>{
+        if ('const' in node && 'type' in node) {
+            delete node.type;
+        }
+        return node;
+    });
+/**
+ * **Size.** Merges the members of a `oneOf`/`anyOf` that are identical except for one `const`-valued property
+ * into a single member with that property as an `enum`. Since the members differ only by that one
+ * constant, the `enum` form accepts exactly the same values - it's just smaller. This folds the
+ * per-collection relationship and upload variants, which differ only in their `relationTo` constant.
+ *
+ * @example
+ * { oneOf: [
+ *   { properties: { relationTo: { const: 'posts' }, value: { type: 'string' } } },
+ *   { properties: { relationTo: { const: 'pages' }, value: { type: 'string' } } },
+ * ] }
+ * → { properties: { relationTo: { enum: ['posts', 'pages'] }, value: { type: 'string' } } }
+ */ const mergeConstDiscriminatedUnions = (schema)=>mapNodes(schema, (node)=>{
+        for (const keyword of [
+            'oneOf',
+            'anyOf'
+        ]){
+            const members = node[keyword];
+            if (Array.isArray(members) && members.length > 1) {
+                const merged = mergeMembersByConst(members);
+                if (merged) {
+                    delete node[keyword];
+                    Object.assign(node, merged);
+                }
+            }
+        }
+        return node;
+    });
+/** Returns the merged member for {@link mergeConstDiscriminatedUnions}, or `null` if they can't merge. */ const mergeMembersByConst = (members)=>{
+    const objects = members.filter((member)=>typeof member === 'object' && member !== null && typeof member.properties === 'object');
+    if (objects.length < 2 || objects.length !== members.length) {
+        return null;
+    }
+    for (const discriminator of Object.keys(objects[0].properties)){
+        // Each member must pin this property to a `const`...
+        const constValues = [];
+        const everyMemberPinsConst = objects.every((member)=>{
+            const prop = member.properties[discriminator];
+            if (prop && typeof prop === 'object' && 'const' in prop) {
+                constValues.push(prop.const);
+                return true;
+            }
+            return false;
+        });
+        if (!everyMemberPinsConst) {
+            continue;
+        }
+        // ...and be otherwise identical (compare each member with the discriminator removed).
+        const fingerprintWithoutDiscriminator = (member)=>{
+            const { [discriminator]: _discriminator, ...otherProperties } = member.properties;
+            return JSON.stringify({
+                ...member,
+                properties: otherProperties
+            });
+        };
+        if (new Set(objects.map(fingerprintWithoutDiscriminator)).size !== 1) {
+            continue;
+        }
+        const uniqueConstValues = [
+            ...new Set(constValues)
+        ];
+        if (uniqueConstValues.length < 2) {
+            continue;
+        }
+        // Replace the per-member `const` with a single `enum` of every value.
+        const merged = structuredClone(objects[0]);
+        const discriminatorProp = merged.properties[discriminator];
+        if (discriminatorProp && typeof discriminatorProp === 'object') {
+            delete discriminatorProp.const;
+            discriminatorProp.enum = uniqueConstValues;
+        }
+        return merged;
+    }
+    return null;
+};
+// A `$ref` costs ~30 characters once names are shortened, so sharing a subschema only pays off when
+// it's larger than that and appears more than once.
+const MIN_SHARED_SIZE = 64;
+/** A subschema worth sharing: a standalone object/union/described schema, not a `$ref` or a primitive. */ const isShareable = (node)=>{
+    if (!node || typeof node !== 'object' || Array.isArray(node) || '$ref' in node) {
+        return false;
+    }
+    const schema = node;
+    return Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf) || Boolean(schema.properties) || Boolean(schema.items) || typeof schema.description === 'string';
+};
+/**
+ * **Size.** Replaces any subschema that appears more than once with a single shared `$defs` entry referenced by
+ * `$ref`. Lossless — only the serialized size shrinks. A collection with several rich-text fields, for
+ * example, inlines the same large lexical node schema once per field; this collapses them into one.
+ *
+ * @example
+ * { properties: { billing: address, shipping: address } }
+ * → { properties: { billing: { $ref: '#/$defs/shared_0' }, shipping: { $ref: '#/$defs/shared_0' } }, $defs: { shared_0: address } }
+ */ const deduplicateIntoDefinitions = (schema)=>{
+    // Count how often each shareable subschema appears, keyed by its serialized form.
+    const counts = new Map();
+    const count = (node)=>{
+        if (isShareable(node)) {
+            const key = JSON.stringify(node);
+            if (key.length >= MIN_SHARED_SIZE) {
+                counts.set(key, (counts.get(key) ?? 0) + 1);
+            }
+        }
+        if (Array.isArray(node)) {
+            node.forEach(count);
+        } else if (node && typeof node === 'object') {
+            Object.values(node).forEach(count);
+        }
+    };
+    count(schema);
+    if (![
+        ...counts.values()
+    ].some((n)=>n >= 2)) {
+        return schema;
+    }
+    // Replace each subschema seen 2+ times with a `$ref`. The first time we meet one it becomes a shared
+    // entry; we never descend into a stored entry, so shared entries never reference one another.
+    const sharedEntries = {};
+    const nameByKey = new Map();
+    const share = (node)=>{
+        if (isShareable(node)) {
+            const key = JSON.stringify(node);
+            if ((counts.get(key) ?? 0) >= 2) {
+                let name = nameByKey.get(key);
+                if (!name) {
+                    name = `shared_${nameByKey.size}`;
+                    nameByKey.set(key, name);
+                    sharedEntries[name] = node;
+                }
+                return {
+                    $ref: `#/$defs/${name}`
+                };
+            }
+        }
+        if (Array.isArray(node)) {
+            return node.map(share);
+        }
+        if (node && typeof node === 'object') {
+            return Object.fromEntries(Object.entries(node).map(([childKey, value])=>[
+                    childKey,
+                    share(value)
+                ]));
+        }
+        return node;
+    };
+    const result = share(schema);
+    result.$defs = {
+        ...result.$defs,
+        ...sharedEntries
+    };
+    return result;
+};
+/**
+ * **LLM ergonomics.** Renames `$defs` entries to short, readable names so the `$ref`s stay legible to the model: a block's
+ * `blockType` (`Code`), a node's `type` (`paragraph`), `node` for a rich-text node union, otherwise the
+ * generated name with its disambiguating hash dropped. A numeric suffix keeps collisions unique.
+ *
+ * @example
+ * { properties: { body: { $ref: '#/$defs/LexicalNodes_9FBEC708' } }, $defs: { LexicalNodes_9FBEC708: {} } }
+ * → { properties: { body: { $ref: '#/$defs/node' } }, $defs: { node: {} } }
+ */ const shortenDefinitionNames = (schema)=>{
+    const definitions = schema.$defs;
+    if (!definitions || Object.keys(definitions).length === 0) {
+        return schema;
+    }
+    const shortNameFor = (name, definition)=>{
+        const properties = typeof definition === 'object' && definition.properties || {};
+        const constString = (key)=>{
+            const prop = properties[key];
+            return prop && typeof prop === 'object' && typeof prop.const === 'string' ? prop.const : undefined;
+        };
+        const members = typeof definition === 'object' ? definition.anyOf ?? definition.oneOf : undefined;
+        const isNodeUnion = Array.isArray(members) && members.some((m)=>typeof m === 'object' && Boolean(m.$ref || m.properties?.type));
+        return constString('blockType') ?? constString('type') ?? (isNodeUnion ? 'node' : undefined) ?? name.replace(/_[0-9A-F]{6,}$/i, '');
+    };
+    const prefix = '#/$defs/';
+    const usedNames = new Map();
+    const rename = new Map();
+    for (const [name, definition] of Object.entries(definitions)){
+        const shortName = shortNameFor(name, definition);
+        const used = usedNames.get(shortName) ?? 0;
+        usedNames.set(shortName, used + 1);
+        rename.set(name, used === 0 ? shortName : `${shortName}${used + 1}`);
+    }
+    const result = mapNodes(schema, (node)=>{
+        if (typeof node.$ref === 'string' && node.$ref.startsWith(prefix)) {
+            const name = node.$ref.slice(prefix.length);
+            node.$ref = `${prefix}${rename.get(name) ?? name}`;
+        }
+        return node;
+    });
+    result.$defs = Object.fromEntries(Object.entries(result.$defs).map(([name, body])=>[
+            rename.get(name) ?? name,
+            body
+        ]));
+    return result;
+};
+
+//# sourceMappingURL=sanitizeEntitySchema.js.map

package/dist/utils/schemaConversion/sanitizeEntitySchema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/schemaConversion/sanitizeEntitySchema.ts"],"sourcesContent":["import type { JsonSchemaType } from '../../types.js'\n\n/**\n * Turns the JSON Schema that Payload generates for a collection or global into the input schema for\n * an MCP create/update tool. In short, it:\n *\n * - drops fields a client can't set (`id`, `createdAt`, the draft `_status`, …),\n * - rewrites Payload-specific field shapes (points, relationships) into plain JSON the model can fill,\n * - and shrinks the result so it's cheaper for the model to read,\n *\n * while keeping every node valid JSON Schema draft 2020-12. Each step below is tagged with why it runs -\n * **Correctness** (valid input the API accepts), **Size** (equivalence-preserving shrink), or **LLM\n * ergonomics** (easier for the model to read/fill) - and carries a before/after example on its definition.\n */\nexport const sanitizeEntitySchema = (schema: JsonSchemaType): JsonSchemaType => {\n  // Work on a copy — the caller reuses the original schema elsewhere (e.g. when listing tools).\n  let result = structuredClone(schema)\n\n  // Correctness — drop the fields a client can't set (id, createdAt, updatedAt, draft _status) + collapse nullable types.\n  result = removeManagedFields(result)\n\n  // LLM ergonomics — rewrite point fields from a `[number, number]` tuple into a `{ longitude, latitude }` object.\n  result = pointFieldsToObjects(result)\n\n  // Correctness — a relationship value can be an ID or a populated doc; on input only the ID is valid, so keep that.\n  result = relationshipsToIds(result)\n\n  // Size — strip inert type-gen leftovers that only bloat the schema (`tsType`, block-collision notes).\n  result = removeTypeGenArtifacts(result)\n\n  // Size — where a `const` already pins a value, the sibling `type` is redundant; remove it.\n  result = dropRedundantConstType(result)\n\n  // Size — fold per-collection relationship/upload variants (identical but for `relationTo`) into one `enum`.\n  result = mergeConstDiscriminatedUnions(result)\n\n  // Size — pull any subschema that appears more than once into a single shared `$defs` entry.\n  result = deduplicateIntoDefinitions(result)\n\n  // LLM ergonomics — give `$defs` short, readable names (`Code`, `paragraph`, `node`) so the `$ref`s read nicely.\n  result = shortenDefinitionNames(result)\n\n  return result\n}\n\n/**\n * Rebuilds a schema bottom-up, calling `visit` on each node after its children. Shared by the\n * transforms that need to touch every node in the tree.\n */\nconst mapNodes = (node: unknown, visit: (node: JsonSchemaType) => JsonSchemaType): unknown => {\n  if (Array.isArray(node)) {\n    return node.map((child) => mapNodes(child, visit))\n  }\n  if (!node || typeof node !== 'object') {\n    return node\n  }\n  const out: Record<string, unknown> = {}\n  for (const [key, value] of Object.entries(node)) {\n    out[key] = mapNodes(value, visit)\n  }\n  return visit(out as JsonSchemaType)\n}\n\n// Payload sets these on every document, so an MCP client never provides them when creating/updating.\nconst PAYLOAD_MANAGED_FIELDS = new Set(['_status', 'createdAt', 'id', 'updatedAt'])\n\n/**\n * **Correctness.** Removes the fields a client can't set on create/update - `id`, `createdAt`, `updatedAt`, and the draft\n * `_status` - from every field object's `properties` and `required` (recursing into nested objects and\n * array items). Along the way it also collapses optional array/object types via {@link collapseNullableType}.\n *\n * @example\n * { properties: { id: { type: 'string' }, tags: { type: ['array', 'null'], items: {} } }, required: ['id', 'tags'] }\n * → { properties: { tags: { type: 'array', items: {} } }, required: ['tags'] }\n */\nconst removeManagedFields = (schema: JsonSchemaType): JsonSchemaType => {\n  if (schema.properties && typeof schema.properties === 'object') {\n    for (const field of PAYLOAD_MANAGED_FIELDS) {\n      delete schema.properties[field]\n    }\n    for (const key of Object.keys(schema.properties)) {\n      const prop = schema.properties[key] as JsonSchemaType\n      if (!prop || typeof prop !== 'object') {\n        continue\n      }\n      const isRequired = Array.isArray(schema.required) && schema.required.includes(key)\n      collapseNullableType(prop, isRequired)\n      if (prop.properties) {\n        removeManagedFields(prop)\n      }\n      if (prop.items && typeof prop.items === 'object' && !Array.isArray(prop.items)) {\n        removeManagedFields(prop.items)\n      }\n    }\n  }\n\n  if (Array.isArray(schema.required)) {\n    schema.required = schema.required.filter((name) => !PAYLOAD_MANAGED_FIELDS.has(name))\n    if (schema.required.length === 0) {\n      delete schema.required\n    }\n  }\n\n  return schema\n}\n\n/**\n * Drops the `'null'` from an optional array/object type (`['array', 'null']` → `'array'`, likewise\n * `'object'`). Payload marks a field optional by unioning its type with `'null'`, but a create/update\n * tool already conveys \"optional\" through the `required` list - the client just omits the field - so the\n * `'null'` is redundant here. Dropping it shows the model a plain `type: 'array'` instead of implying it\n * should send a literal `null`.\n *\n * We never touch the `required` list, so this can't change whether a field is required. And we skip fields\n * that ARE required (`isRequired`): there a `'null'` is a value the field genuinely accepts, not optionality\n * encoding. Nullable scalars (`['string', 'null']`) are also left alone - they read fine as `string | null`.\n *\n * @example\n * optional { type: ['array', 'null'] } → { type: 'array' }   (still optional, just no longer null-valued)\n * required { type: ['array', 'null'] } → unchanged\n * { type: ['string', 'null'] } → unchanged\n */\nconst collapseNullableType = (schema: JsonSchemaType, isRequired: boolean): void => {\n  if (isRequired || !Array.isArray(schema.type)) {\n    return\n  }\n  const nonNullTypes = schema.type.filter((t) => t !== 'null')\n  if (nonNullTypes.length === 1 && (nonNullTypes[0] === 'array' || nonNullTypes[0] === 'object')) {\n    schema.type = nonNullTypes[0]\n  }\n}\n\n/**\n * **LLM ergonomics.** Rewrites a point field (stored as a two-number tuple) into a `{ longitude, latitude }` object, which\n * is far easier for the model to fill in than a positional array. This is input-only and lossless: the\n * create/update handler converts the object back to the `[longitude, latitude]` tuple Payload stores,\n * via `transformPointDataToPayload`.\n *\n * @example\n * { type: 'array', items: [{ type: 'number' }, { type: 'number' }] }\n * → { type: 'object', properties: { longitude: { type: 'number' }, latitude: { type: 'number' } }, required: ['longitude', 'latitude'] }\n */\nconst pointFieldsToObjects = (schema: JsonSchemaType): JsonSchemaType => {\n  if (!schema || typeof schema !== 'object') {\n    return schema\n  }\n\n  const transformed = { ...schema }\n\n  if (transformed.properties && typeof transformed.properties === 'object') {\n    transformed.properties = Object.fromEntries(\n      Object.entries(transformed.properties).map(([key, value]) => {\n        if (!value || typeof value !== 'object') {\n          return [key, value]\n        }\n        const isArrayType =\n          value.type === 'array' || (Array.isArray(value.type) && value.type.includes('array'))\n        const isPointField =\n          isArrayType &&\n          Array.isArray(value.items) &&\n          value.items.length === 2 &&\n          value.items.every((item) => item && typeof item === 'object' && item.type === 'number')\n\n        if (isPointField) {\n          const isNullable = Array.isArray(value.type) && value.type.includes('null')\n          return [\n            key,\n            {\n              type: isNullable ? ['object', 'null'] : 'object',\n              description: value.description || 'Geographic coordinates (longitude, latitude)',\n              properties: {\n                latitude: { type: 'number', description: 'Latitude coordinate' },\n                longitude: { type: 'number', description: 'Longitude coordinate' },\n              },\n              required: ['longitude', 'latitude'],\n            },\n          ]\n        }\n\n        return [key, pointFieldsToObjects(value)]\n      }),\n    )\n  }\n\n  if (\n    transformed.items &&\n    typeof transformed.items === 'object' &&\n    !Array.isArray(transformed.items)\n  ) {\n    transformed.items = pointFieldsToObjects(transformed.items)\n  }\n\n  return transformed\n}\n\n/**\n * **Correctness.** Reduces relationship/upload fields to the IDs a client actually sends. Payload types the value as\n * \"an ID or the full related document\" - but the populated-document form only appears in read responses;\n * on create/update you always reference a relationship by its ID. So we drop that `$ref` option, leaving\n * the bare ID. A single remaining target collapses inline (with a description naming the target\n * collection); several targets become an `anyOf` of IDs.\n *\n * @example\n * { oneOf: [{ type: 'string' }, { $ref: '#/$defs/posts' }] }\n * → { type: 'string', description: 'The ID of the related \"posts\" document.' }\n */\nconst relationshipsToIds = (schema: JsonSchemaType): JsonSchemaType => {\n  if (!schema || typeof schema !== 'object') {\n    return schema\n  }\n\n  const processed = { ...schema }\n\n  if (Array.isArray(processed.oneOf)) {\n    const isRelatedDocRef = (option: unknown): option is { $ref: string } =>\n      !!option && typeof option === 'object' && '$ref' in option\n\n    if (processed.oneOf.some(isRelatedDocRef)) {\n      // A relationship value is \"an ID, or the populated related document\". Keep the ID option(s) and\n      // drop the `$ref`s to the related collections, since a client only ever sends the ID.\n      const idOptions = processed.oneOf\n        .filter((option) => !isRelatedDocRef(option))\n        .map((option) => (typeof option === 'object' ? relationshipsToIds(option) : option))\n      const targetCollections = processed.oneOf\n        .filter(isRelatedDocRef)\n        .map((option) => option.$ref.replace('#/$defs/', ''))\n\n      if (idOptions.length === 1) {\n        delete processed.oneOf\n        Object.assign(processed, idOptions[0])\n        if (targetCollections.length > 0 && !processed.description) {\n          processed.description = `The ID of the related \"${targetCollections.join('\" or \"')}\" document.`\n        }\n      } else if (idOptions.length > 1) {\n        delete processed.oneOf\n        processed.anyOf = idOptions\n      }\n    } else {\n      processed.oneOf = processed.oneOf.map((option) =>\n        typeof option === 'object' ? relationshipsToIds(option) : option,\n      )\n    }\n  }\n\n  if (processed.properties && typeof processed.properties === 'object') {\n    processed.properties = Object.fromEntries(\n      Object.entries(processed.properties).map(([key, value]) => [\n        key,\n        typeof value === 'object' ? relationshipsToIds(value) : value,\n      ]),\n    )\n  }\n\n  if (processed.items && typeof processed.items === 'object' && !Array.isArray(processed.items)) {\n    processed.items = relationshipsToIds(processed.items)\n  }\n\n  // Lexical node unions and blocks live under `$defs` and have their own relationship fields, so walk\n  // those too — otherwise their `$ref`s would dangle once we don't bundle the related collections.\n  if (processed.$defs && typeof processed.$defs === 'object') {\n    processed.$defs = Object.fromEntries(\n      Object.entries(processed.$defs).map(([key, value]) => [\n        key,\n        typeof value === 'object' ? relationshipsToIds(value) : value,\n      ]),\n    )\n  }\n\n  return processed\n}\n\n/**\n * **Size.** Strips type-generation leftovers that bloat the schema without helping the model: the `tsType`\n * hint (a `json-schema-to-typescript` extension; JSON Schema validators just ignore it, they don't reject it)\n * and the block-interface-collision note Payload adds to some block descriptions (the\n * `block-interface-name-collisions` docs link set in `registerBlockInterface`, see configToJSONSchema.ts).\n * Both are inert here - removing them only shrinks the schema (and spares the model irrelevant noise).\n *\n * @example\n * { type: 'object', tsType: 'SerializedBlockNode', description: 'see …#block-interface-name-collisions' }\n * → { type: 'object' }\n */\nconst removeTypeGenArtifacts = (schema: JsonSchemaType): JsonSchemaType =>\n  mapNodes(schema, (node) => {\n    delete (node as { tsType?: unknown }).tsType\n    const { description } = node as { description?: string }\n    if (\n      typeof description === 'string' &&\n      description.includes('block-interface-name-collisions')\n    ) {\n      delete (node as { description?: unknown }).description\n    }\n    return node\n  }) as JsonSchemaType\n\n/**\n * **Size.** Removes `type` whenever a `const` sits next to it — the constant already fixes the value.\n *\n * @example\n * { type: 'string', const: 'paragraph' } → { const: 'paragraph' }\n */\nconst dropRedundantConstType = (schema: JsonSchemaType): JsonSchemaType =>\n  mapNodes(schema, (node) => {\n    if ('const' in node && 'type' in node) {\n      delete (node as { type?: unknown }).type\n    }\n    return node\n  }) as JsonSchemaType\n\n/**\n * **Size.** Merges the members of a `oneOf`/`anyOf` that are identical except for one `const`-valued property\n * into a single member with that property as an `enum`. Since the members differ only by that one\n * constant, the `enum` form accepts exactly the same values - it's just smaller. This folds the\n * per-collection relationship and upload variants, which differ only in their `relationTo` constant.\n *\n * @example\n * { oneOf: [\n *   { properties: { relationTo: { const: 'posts' }, value: { type: 'string' } } },\n *   { properties: { relationTo: { const: 'pages' }, value: { type: 'string' } } },\n * ] }\n * → { properties: { relationTo: { enum: ['posts', 'pages'] }, value: { type: 'string' } } }\n */\nconst mergeConstDiscriminatedUnions = (schema: JsonSchemaType): JsonSchemaType =>\n  mapNodes(schema, (node) => {\n    for (const keyword of ['oneOf', 'anyOf'] as const) {\n      const members = node[keyword]\n      if (Array.isArray(members) && members.length > 1) {\n        const merged = mergeMembersByConst(members)\n        if (merged) {\n          delete node[keyword]\n          Object.assign(node, merged)\n        }\n      }\n    }\n    return node\n  }) as JsonSchemaType\n\n/** Returns the merged member for {@link mergeConstDiscriminatedUnions}, or `null` if they can't merge. */\nconst mergeMembersByConst = (members: Array<boolean | JsonSchemaType>): JsonSchemaType | null => {\n  const objects = members.filter(\n    (member): member is JsonSchemaType =>\n      typeof member === 'object' && member !== null && typeof member.properties === 'object',\n  )\n  if (objects.length < 2 || objects.length !== members.length) {\n    return null\n  }\n\n  for (const discriminator of Object.keys(objects[0]!.properties!)) {\n    // Each member must pin this property to a `const`...\n    const constValues: unknown[] = []\n    const everyMemberPinsConst = objects.every((member) => {\n      const prop = member.properties![discriminator]\n      if (prop && typeof prop === 'object' && 'const' in prop) {\n        constValues.push(prop.const)\n        return true\n      }\n      return false\n    })\n    if (!everyMemberPinsConst) {\n      continue\n    }\n\n    // ...and be otherwise identical (compare each member with the discriminator removed).\n    const fingerprintWithoutDiscriminator = (member: JsonSchemaType): string => {\n      const { [discriminator]: _discriminator, ...otherProperties } = member.properties!\n      return JSON.stringify({ ...member, properties: otherProperties })\n    }\n    if (new Set(objects.map(fingerprintWithoutDiscriminator)).size !== 1) {\n      continue\n    }\n\n    const uniqueConstValues = [...new Set(constValues)]\n    if (uniqueConstValues.length < 2) {\n      continue\n    }\n\n    // Replace the per-member `const` with a single `enum` of every value.\n    const merged = structuredClone(objects[0]!)\n    const discriminatorProp = merged.properties![discriminator]\n    if (discriminatorProp && typeof discriminatorProp === 'object') {\n      delete discriminatorProp.const\n      discriminatorProp.enum = uniqueConstValues as NonNullable<typeof discriminatorProp.enum>\n    }\n    return merged\n  }\n  return null\n}\n\n// A `$ref` costs ~30 characters once names are shortened, so sharing a subschema only pays off when\n// it's larger than that and appears more than once.\nconst MIN_SHARED_SIZE = 64\n\n/** A subschema worth sharing: a standalone object/union/described schema, not a `$ref` or a primitive. */\nconst isShareable = (node: unknown): node is Record<string, unknown> => {\n  if (!node || typeof node !== 'object' || Array.isArray(node) || '$ref' in node) {\n    return false\n  }\n  const schema = node as JsonSchemaType\n  return (\n    Array.isArray(schema.oneOf) ||\n    Array.isArray(schema.anyOf) ||\n    Boolean(schema.properties) ||\n    Boolean(schema.items) ||\n    typeof schema.description === 'string'\n  )\n}\n\n/**\n * **Size.** Replaces any subschema that appears more than once with a single shared `$defs` entry referenced by\n * `$ref`. Lossless — only the serialized size shrinks. A collection with several rich-text fields, for\n * example, inlines the same large lexical node schema once per field; this collapses them into one.\n *\n * @example\n * { properties: { billing: address, shipping: address } }\n * → { properties: { billing: { $ref: '#/$defs/shared_0' }, shipping: { $ref: '#/$defs/shared_0' } }, $defs: { shared_0: address } }\n */\nconst deduplicateIntoDefinitions = (schema: JsonSchemaType): JsonSchemaType => {\n  // Count how often each shareable subschema appears, keyed by its serialized form.\n  const counts = new Map<string, number>()\n  const count = (node: unknown): void => {\n    if (isShareable(node)) {\n      const key = JSON.stringify(node)\n      if (key.length >= MIN_SHARED_SIZE) {\n        counts.set(key, (counts.get(key) ?? 0) + 1)\n      }\n    }\n    if (Array.isArray(node)) {\n      node.forEach(count)\n    } else if (node && typeof node === 'object') {\n      Object.values(node).forEach(count)\n    }\n  }\n  count(schema)\n\n  if (![...counts.values()].some((n) => n >= 2)) {\n    return schema\n  }\n\n  // Replace each subschema seen 2+ times with a `$ref`. The first time we meet one it becomes a shared\n  // entry; we never descend into a stored entry, so shared entries never reference one another.\n  const sharedEntries: Record<string, JsonSchemaType> = {}\n  const nameByKey = new Map<string, string>()\n  const share = (node: unknown): unknown => {\n    if (isShareable(node)) {\n      const key = JSON.stringify(node)\n      if ((counts.get(key) ?? 0) >= 2) {\n        let name = nameByKey.get(key)\n        if (!name) {\n          name = `shared_${nameByKey.size}`\n          nameByKey.set(key, name)\n          sharedEntries[name] = node as JsonSchemaType\n        }\n        return { $ref: `#/$defs/${name}` }\n      }\n    }\n    if (Array.isArray(node)) {\n      return node.map(share)\n    }\n    if (node && typeof node === 'object') {\n      return Object.fromEntries(\n        Object.entries(node).map(([childKey, value]) => [childKey, share(value)]),\n      )\n    }\n    return node\n  }\n\n  const result = share(schema) as JsonSchemaType\n  result.$defs = { ...result.$defs, ...sharedEntries }\n  return result\n}\n\n/**\n * **LLM ergonomics.** Renames `$defs` entries to short, readable names so the `$ref`s stay legible to the model: a block's\n * `blockType` (`Code`), a node's `type` (`paragraph`), `node` for a rich-text node union, otherwise the\n * generated name with its disambiguating hash dropped. A numeric suffix keeps collisions unique.\n *\n * @example\n * { properties: { body: { $ref: '#/$defs/LexicalNodes_9FBEC708' } }, $defs: { LexicalNodes_9FBEC708: {} } }\n * → { properties: { body: { $ref: '#/$defs/node' } }, $defs: { node: {} } }\n */\nconst shortenDefinitionNames = (schema: JsonSchemaType): JsonSchemaType => {\n  const definitions = schema.$defs\n  if (!definitions || Object.keys(definitions).length === 0) {\n    return schema\n  }\n\n  const shortNameFor = (name: string, definition: boolean | JsonSchemaType): string => {\n    const properties = (typeof definition === 'object' && definition.properties) || {}\n    const constString = (key: string): string | undefined => {\n      const prop = properties[key]\n      return prop && typeof prop === 'object' && typeof prop.const === 'string'\n        ? prop.const\n        : undefined\n    }\n    const members =\n      typeof definition === 'object' ? (definition.anyOf ?? definition.oneOf) : undefined\n    const isNodeUnion =\n      Array.isArray(members) &&\n      members.some((m) => typeof m === 'object' && Boolean(m.$ref || m.properties?.type))\n    return (\n      constString('blockType') ??\n      constString('type') ??\n      (isNodeUnion ? 'node' : undefined) ??\n      name.replace(/_[0-9A-F]{6,}$/i, '')\n    )\n  }\n\n  const prefix = '#/$defs/'\n  const usedNames = new Map<string, number>()\n  const rename = new Map<string, string>()\n  for (const [name, definition] of Object.entries(definitions)) {\n    const shortName = shortNameFor(name, definition)\n    const used = usedNames.get(shortName) ?? 0\n    usedNames.set(shortName, used + 1)\n    rename.set(name, used === 0 ? shortName : `${shortName}${used + 1}`)\n  }\n\n  const result = mapNodes(schema, (node) => {\n    if (typeof node.$ref === 'string' && node.$ref.startsWith(prefix)) {\n      const name = node.$ref.slice(prefix.length)\n      node.$ref = `${prefix}${rename.get(name) ?? name}`\n    }\n    return node\n  }) as JsonSchemaType\n  result.$defs = Object.fromEntries(\n    Object.entries(result.$defs!).map(([name, body]) => [rename.get(name) ?? name, body]),\n  )\n  return result\n}\n"],"names":["sanitizeEntitySchema","schema","result","structuredClone","removeManagedFields","pointFieldsToObjects","relationshipsToIds","removeTypeGenArtifacts","dropRedundantConstType","mergeConstDiscriminatedUnions","deduplicateIntoDefinitions","shortenDefinitionNames","mapNodes","node","visit","Array","isArray","map","child","out","key","value","Object","entries","PAYLOAD_MANAGED_FIELDS","Set","properties","field","keys","prop","isRequired","required","includes","collapseNullableType","items","filter","name","has","length","type","nonNullTypes","t","transformed","fromEntries","isArrayType","isPointField","every","item","isNullable","description","latitude","longitude","processed","oneOf","isRelatedDocRef","option","some","idOptions","targetCollections","$ref","replace","assign","join","anyOf","$defs","tsType","keyword","members","merged","mergeMembersByConst","objects","member","discriminator","constValues","everyMemberPinsConst","push","const","fingerprintWithoutDiscriminator","_discriminator","otherProperties","JSON","stringify","size","uniqueConstValues","discriminatorProp","enum","MIN_SHARED_SIZE","isShareable","Boolean","counts","Map","count","set","get","forEach","values","n","sharedEntries","nameByKey","share","childKey","definitions","shortNameFor","definition","constString","undefined","isNodeUnion","m","prefix","usedNames","rename","shortName","used","startsWith","slice","body"],"mappings":"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"}