@payloadcms/plugin-mcp 4.0.0-internal.a0ef1b8 → 4.0.0-internal.a1317b2

package/dist/utils/localAPIDefaults.js

@@ -1,19 +0,0 @@
-/**
- * Returns the `user` and `overrideAccess` arguments every Payload local API call
- * should receive when initiated from an MCP request. Spread the result into the
- * call's arg object so the two pieces of caller state can't drift apart.
- *
- * @example
- * ```ts
- * await req.payload.create({
- *   collection: 'posts',
- *   data,
- *   ...localAPIDefaults(authorizedMCP),
- * })
- * ```
- */ export const localAPIDefaults = (authorizedMCP)=>({
-        overrideAccess: authorizedMCP.overrideAccess,
-        user: authorizedMCP.user
-    });
-
-//# sourceMappingURL=localAPIDefaults.js.map

package/dist/utils/localAPIDefaults.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/localAPIDefaults.ts"],"sourcesContent":["import type { AuthorizedMCP } from '../types.js'\n\n/**\n * Returns the `user` and `overrideAccess` arguments every Payload local API call\n * should receive when initiated from an MCP request. Spread the result into the\n * call's arg object so the two pieces of caller state can't drift apart.\n *\n * @example\n * ```ts\n * await req.payload.create({\n *   collection: 'posts',\n *   data,\n *   ...localAPIDefaults(authorizedMCP),\n * })\n * ```\n */\nexport const localAPIDefaults = (\n  authorizedMCP: AuthorizedMCP,\n): { overrideAccess: boolean; user: AuthorizedMCP['user'] } => ({\n  overrideAccess: authorizedMCP.overrideAccess,\n  user: authorizedMCP.user,\n})\n"],"names":["localAPIDefaults","authorizedMCP","overrideAccess","user"],"mappings":"AAEA;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMA,mBAAmB,CAC9BC,gBAC8D,CAAA;QAC9DC,gBAAgBD,cAAcC,cAAc;QAC5CC,MAAMF,cAAcE,IAAI;IAC1B,CAAA,EAAE"}

package/dist/utils/schemaConversion/buildToolInput.d.ts

@@ -1,29 +0,0 @@
-import type { StandardSchemaWithJSON } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-import type { JsonSchemaType } from '../../types.js';
-/**
- * Builds a create/update tool's `input`: a `data` field (the document's fields) plus controls like
- * `depth` and `draft`. Using just `z.fromJSONSchema(ourJSONSchema)` has a few problems which are mitigated
- * in this function. z.fromJSONSchema is both bigger and lossier (≈40% larger on the lexical schema).
- * Each example below is `what we publish` => `what a plain zod round-trip would publish instead`.
- *
- * @example
- * Bigger - zod inlines shared defs instead of keeping our `$ref`s (and adds junk integer bounds), so a
- * reused def is duplicated at every use:
- * `{ $ref: '#/$defs/author' }` => `{ type: 'object', properties: { id, name }, additionalProperties: false }`
- *
- * @example
- * Lossier - zod drops the `description` on `enum`/`const` fields:
- * `{ enum: ['draft', 'published'], description: 'Publish state' }` → `{ enum: ['draft', 'published'] }`
- */
-export declare const buildToolInput: <TControls extends z.ZodRawShape>({ controls, dataDescription, dataSchema, }: {
-    /** Tool options alongside `data` (depth, draft, where, …) as plain zod - inferred into `input`. */
-    controls: TControls;
-    dataDescription: string;
-    dataSchema: JsonSchemaType;
-}) => StandardSchemaWithJSON<{
-    data: Record<string, unknown>;
-} & Omit<z.output<z.ZodObject<{
-    data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-} & TControls extends infer T ? { -readonly [P in keyof T]: T[P]; } : never, z.core.$strip>>, "data">>;
-//# sourceMappingURL=buildToolInput.d.ts.map

package/dist/utils/schemaConversion/buildToolInput.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildToolInput.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/buildToolInput.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AAE1E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,SAAS,CAAC,CAAC,WAAW,EAAE,4CAI7D;IACD,mGAAmG;IACnG,QAAQ,EAAE,SAAS,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,UAAU,EAAE,cAAc,CAAA;CAC3B,KAkCM,sBAAsB,CACzB;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM;;4FAAe,EAAE,MAAM,CAAC,CAE5E,CAAA"}

package/dist/utils/schemaConversion/buildToolInput.js

@@ -1,51 +0,0 @@
-import { z } from 'zod';
-/**
- * Builds a create/update tool's `input`: a `data` field (the document's fields) plus controls like
- * `depth` and `draft`. Using just `z.fromJSONSchema(ourJSONSchema)` has a few problems which are mitigated
- * in this function. z.fromJSONSchema is both bigger and lossier (≈40% larger on the lexical schema).
- * Each example below is `what we publish` => `what a plain zod round-trip would publish instead`.
- *
- * @example
- * Bigger - zod inlines shared defs instead of keeping our `$ref`s (and adds junk integer bounds), so a
- * reused def is duplicated at every use:
- * `{ $ref: '#/$defs/author' }` => `{ type: 'object', properties: { id, name }, additionalProperties: false }`
- *
- * @example
- * Lossier - zod drops the `description` on `enum`/`const` fields:
- * `{ enum: ['draft', 'published'], description: 'Publish state' }` → `{ enum: ['draft', 'published'] }`
- */ export const buildToolInput = ({ controls, dataDescription, dataSchema })=>{
-    // `sanitizeEntitySchema` already emits draft 2020-12 with `$defs`, which is what zod's `fromJSONSchema`
-    // and MCP clients both expect. Drop only the root `$schema` keyword, redundant once it's a sub-schema.
-    const { $schema: _schema, ...entitySchema } = dataSchema;
-    const schema = z.object({
-        data: z.fromJSONSchema(entitySchema),
-        ...controls
-    });
-    const standard = schema['~standard'];
-    return {
-        '~standard': {
-            ...standard,
-            jsonSchema: {
-                ...standard.jsonSchema,
-                input: (options)=>{
-                    // Start from zod's JSON Schema for the whole input, then replace its lossy `data` schema with
-                    // the sanitized entity schema. The entity's `$defs` move to the root so the `$ref`s resolve.
-                    const generated = standard.jsonSchema.input(options);
-                    const { $defs, ...entityBody } = entitySchema;
-                    generated.properties.data = {
-                        ...entityBody,
-                        description: dataDescription
-                    };
-                    if ($defs) {
-                        generated.$defs = $defs;
-                    } else {
-                        delete generated.$defs;
-                    }
-                    return generated;
-                }
-            }
-        }
-    };
-};
-
-//# sourceMappingURL=buildToolInput.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/buildToolInput.ts"],"sourcesContent":["import type { StandardSchemaWithJSON } from '@modelcontextprotocol/server'\n\nimport { z } from 'zod'\n\nimport type { JsonSchemaType } from '../../types.js'\n\n/**\n * Builds a create/update tool's `input`: a `data` field (the document's fields) plus controls like\n * `depth` and `draft`. Using just `z.fromJSONSchema(ourJSONSchema)` has a few problems which are mitigated\n * in this function. z.fromJSONSchema is both bigger and lossier (≈40% larger on the lexical schema).\n * Each example below is `what we publish` => `what a plain zod round-trip would publish instead`.\n *\n * @example\n * Bigger - zod inlines shared defs instead of keeping our `$ref`s (and adds junk integer bounds), so a\n * reused def is duplicated at every use:\n * `{ $ref: '#/$defs/author' }` => `{ type: 'object', properties: { id, name }, additionalProperties: false }`\n *\n * @example\n * Lossier - zod drops the `description` on `enum`/`const` fields:\n * `{ enum: ['draft', 'published'], description: 'Publish state' }` → `{ enum: ['draft', 'published'] }`\n */\nexport const buildToolInput = <TControls extends z.ZodRawShape>({\n  controls,\n  dataDescription,\n  dataSchema,\n}: {\n  /** Tool options alongside `data` (depth, draft, where, …) as plain zod - inferred into `input`. */\n  controls: TControls\n  dataDescription: string\n  dataSchema: JsonSchemaType\n}) => {\n  // `sanitizeEntitySchema` already emits draft 2020-12 with `$defs`, which is what zod's `fromJSONSchema`\n  // and MCP clients both expect. Drop only the root `$schema` keyword, redundant once it's a sub-schema.\n  const { $schema: _schema, ...entitySchema } = dataSchema as Record<string, unknown>\n\n  const schema = z.object({\n    data: z.fromJSONSchema(entitySchema as unknown as z.core.JSONSchema.JSONSchema),\n    ...controls,\n  })\n  const standard = (schema as unknown as StandardSchemaWithJSON)['~standard']\n\n  return {\n    '~standard': {\n      ...standard,\n      jsonSchema: {\n        ...standard.jsonSchema,\n        input: (options) => {\n          // Start from zod's JSON Schema for the whole input, then replace its lossy `data` schema with\n          // the sanitized entity schema. The entity's `$defs` move to the root so the `$ref`s resolve.\n          const generated = standard.jsonSchema.input(options)\n          const { $defs, ...entityBody } = entitySchema\n          ;(generated.properties as Record<string, unknown>).data = {\n            ...entityBody,\n            description: dataDescription,\n          }\n          if ($defs) {\n            generated.$defs = $defs as object\n          } else {\n            delete generated.$defs\n          }\n          return generated\n        },\n      },\n    },\n  } as StandardSchemaWithJSON<\n    { data: Record<string, unknown> } & Omit<z.output<typeof schema>, 'data'>\n  >\n}\n"],"names":["z","buildToolInput","controls","dataDescription","dataSchema","$schema","_schema","entitySchema","schema","object","data","fromJSONSchema","standard","jsonSchema","input","options","generated","$defs","entityBody","properties","description"],"mappings":"AAEA,SAASA,CAAC,QAAQ,MAAK;AAIvB;;;;;;;;;;;;;;CAcC,GACD,OAAO,MAAMC,iBAAiB,CAAkC,EAC9DC,QAAQ,EACRC,eAAe,EACfC,UAAU,EAMX;IACC,wGAAwG;IACxG,uGAAuG;IACvG,MAAM,EAAEC,SAASC,OAAO,EAAE,GAAGC,cAAc,GAAGH;IAE9C,MAAMI,SAASR,EAAES,MAAM,CAAC;QACtBC,MAAMV,EAAEW,cAAc,CAACJ;QACvB,GAAGL,QAAQ;IACb;IACA,MAAMU,WAAW,AAACJ,MAA4C,CAAC,YAAY;IAE3E,OAAO;QACL,aAAa;YACX,GAAGI,QAAQ;YACXC,YAAY;gBACV,GAAGD,SAASC,UAAU;gBACtBC,OAAO,CAACC;oBACN,8FAA8F;oBAC9F,6FAA6F;oBAC7F,MAAMC,YAAYJ,SAASC,UAAU,CAACC,KAAK,CAACC;oBAC5C,MAAM,EAAEE,KAAK,EAAE,GAAGC,YAAY,GAAGX;oBAC/BS,UAAUG,UAAU,CAA6BT,IAAI,GAAG;wBACxD,GAAGQ,UAAU;wBACbE,aAAajB;oBACf;oBACA,IAAIc,OAAO;wBACTD,UAAUC,KAAK,GAAGA;oBACpB,OAAO;wBACL,OAAOD,UAAUC,KAAK;oBACxB;oBACA,OAAOD;gBACT;YACF;QACF;IACF;AAGF,EAAC"}

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.d.ts

@@ -1,7 +0,0 @@
-import type { JsonSchemaType } from '../../types.js';
-/**
- * Removes virtual fields from a JSON Schema by name so they don't appear
- * in the generated MCP tool input schema.
- */
-export declare function removeVirtualFieldsFromSchema(schema: JsonSchemaType, virtualFieldNames: string[]): JsonSchemaType;
-//# sourceMappingURL=removeVirtualFieldsFromSchema.d.ts.map

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"removeVirtualFieldsFromSchema.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/removeVirtualFieldsFromSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,cAAc,EACtB,iBAAiB,EAAE,MAAM,EAAE,GAC1B,cAAc,CAiBhB"}

package/dist/utils/schemaConversion/removeVirtualFieldsFromSchema.js

@@ -1,20 +0,0 @@
-/**
- * Removes virtual fields from a JSON Schema by name so they don't appear
- * in the generated MCP tool input schema.
- */ export function removeVirtualFieldsFromSchema(schema, virtualFieldNames) {
-    if (virtualFieldNames.length === 0) {
-        return schema;
-    }
-    for (const name of virtualFieldNames){
-        delete schema?.properties?.[name];
-    }
-    if (Array.isArray(schema.required)) {
-        schema.required = schema.required.filter((field)=>!virtualFieldNames.includes(field));
-        if (schema.required.length === 0) {
-            delete schema.required;
-        }
-    }
-    return schema;
-}
-
-//# sourceMappingURL=removeVirtualFieldsFromSchema.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/utils/schemaConversion/removeVirtualFieldsFromSchema.ts"],"sourcesContent":["import type { JsonSchemaType } from '../../types.js'\n\n/**\n * Removes virtual fields from a JSON Schema by name so they don't appear\n * in the generated MCP tool input schema.\n */\nexport function removeVirtualFieldsFromSchema(\n  schema: JsonSchemaType,\n  virtualFieldNames: string[],\n): JsonSchemaType {\n  if (virtualFieldNames.length === 0) {\n    return schema\n  }\n\n  for (const name of virtualFieldNames) {\n    delete schema?.properties?.[name]\n  }\n\n  if (Array.isArray(schema.required)) {\n    schema.required = schema.required.filter((field) => !virtualFieldNames.includes(field))\n    if (schema.required.length === 0) {\n      delete schema.required\n    }\n  }\n\n  return schema\n}\n"],"names":["removeVirtualFieldsFromSchema","schema","virtualFieldNames","length","name","properties","Array","isArray","required","filter","field","includes"],"mappings":"AAEA;;;CAGC,GACD,OAAO,SAASA,8BACdC,MAAsB,EACtBC,iBAA2B;IAE3B,IAAIA,kBAAkBC,MAAM,KAAK,GAAG;QAClC,OAAOF;IACT;IAEA,KAAK,MAAMG,QAAQF,kBAAmB;QACpC,OAAOD,QAAQI,YAAY,CAACD,KAAK;IACnC;IAEA,IAAIE,MAAMC,OAAO,CAACN,OAAOO,QAAQ,GAAG;QAClCP,OAAOO,QAAQ,GAAGP,OAAOO,QAAQ,CAACC,MAAM,CAAC,CAACC,QAAU,CAACR,kBAAkBS,QAAQ,CAACD;QAChF,IAAIT,OAAOO,QAAQ,CAACL,MAAM,KAAK,GAAG;YAChC,OAAOF,OAAOO,QAAQ;QACxB;IACF;IAEA,OAAOP;AACT"}

package/dist/utils/schemaConversion/sanitizeEntitySchema.d.ts

@@ -1,15 +0,0 @@
-import type { JsonSchemaType } from '../../types.js';
-/**
- * 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 declare const sanitizeEntitySchema: (schema: JsonSchemaType) => JsonSchemaType;
-//# sourceMappingURL=sanitizeEntitySchema.d.ts.map

package/dist/utils/schemaConversion/sanitizeEntitySchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sanitizeEntitySchema.d.ts","sourceRoot":"","sources":["../../../src/utils/schemaConversion/sanitizeEntitySchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,GAAI,QAAQ,cAAc,KAAG,cA6B7D,CAAA"}

package/dist/utils/schemaConversion/sanitizeEntitySchema.js

@@ -1,464 +0,0 @@
-/**
- * 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