@mvriu5/payload-ai 1.6.2 → 1.6.4

package/dist/{ai/providerRuntime.d.ts → features/providers/runtime.d.ts}

@@ -1,5 +1,5 @@
 import type { LanguageModel } from "ai";
-import { type AIProvider, type AIModelConfig } from "./providerOptions.js";
+import { type AIProvider, type AIModelConfig } from "./options.js";
 type ProviderConfig = {
     apiKey?: string | null;
     defaultModels?: AIModelConfig["defaults"];

package/dist/{ai/providerRuntime.js → features/providers/runtime.js}

@@ -1,4 +1,4 @@
-import { defaultAIModels } from "./providerOptions.js";
+import { defaultAIModels } from "./options.js";
 export const getProviderConfig = ({ apiKey, defaultModels, model, provider })=>{
     const defaultModel = defaultModels?.[provider] || defaultAIModels[provider];
     if (provider === "claude") {

package/dist/features/schema/context.d.ts

@@ -0,0 +1,7 @@
+export { collectBlocks, describeCollectionLikeConfig, describeCollectionLikeSummary, type CollectionLikeConfig, type FieldConfig } from "./description.js";
+export { getAllowedCollectionSlugs, getMentionContext, type ChatMention } from "./mentions.js";
+export { createSchemaContextRegistry, type SchemaContextRegistry } from "./registry.js";
+export declare const buildPromptWithMentionContext: ({ mentionContext, prompt }: {
+    mentionContext: Record<string, unknown>[];
+    prompt: string;
+}) => string;

package/dist/features/schema/context.js

@@ -0,0 +1,11 @@
+export { collectBlocks, describeCollectionLikeConfig, describeCollectionLikeSummary } from "./description.js";
+export { getAllowedCollectionSlugs, getMentionContext } from "./mentions.js";
+export { createSchemaContextRegistry } from "./registry.js";
+export const buildPromptWithMentionContext = ({ mentionContext, prompt })=>{
+    if (mentionContext.length === 0) return prompt;
+    return [
+        "Selected Payload references JSON. Treat inline reference labels as these entities:",
+        JSON.stringify(mentionContext),
+        prompt
+    ].join("\n\n");
+};

package/dist/{payload/schemaContext.d.ts → features/schema/description.d.ts}

@@ -1,14 +1,5 @@
-import type { PayloadHandler } from "payload";
-import { type ResolvedCollectionPermissionMap } from "./collectionPermissions.js";
-import { type CollectionConfig as NormalizeCollectionConfig } from "./normalizeData.js";
-export type ChatMention = {
-    collection?: string;
-    id?: string;
-    label?: string;
-    parent?: string;
-    slug?: string;
-    type?: "block" | "collection" | "doc" | "global" | "locale";
-};
+import { type ResolvedCollectionPermissionMap } from "../collectionPermissions.js";
+import { type CollectionConfig as NormalizeCollectionConfig } from "./normalize.js";
 export type FieldConfig = {
     admin?: Record<string, unknown>;
     blocks?: BlockConfig[];
@@ -26,7 +17,7 @@ export type FieldConfig = {
     required?: boolean;
     type?: string;
 };
-type BlockConfig = {
+export type BlockConfig = {
     fields?: FieldConfig[];
     labels?: {
         plural?: unknown;
@@ -34,7 +25,7 @@ type BlockConfig = {
     };
     slug: string;
 };
-type CollectionLikeConfig = {
+export type CollectionLikeConfig = {
     admin?: {
         useAsTitle?: string;
     };
@@ -49,24 +40,13 @@ type CollectionLikeConfig = {
     slug: string;
     versions?: NormalizeCollectionConfig["versions"];
 };
-type MentionContext = {
-    blockContexts: (Record<string, unknown> & {
-        parent: string;
-        slug: string;
-    })[];
-    collectionSlugs: string[];
-    collections?: ResolvedCollectionPermissionMap;
-    globalSlugs: string[];
-    mentions?: ChatMention[];
-    req: Parameters<PayloadHandler>[0];
-};
 export declare const describeCollectionLikeSummary: ({ config, permissions, type, }: {
     config: CollectionLikeConfig;
     permissions?: ResolvedCollectionPermissionMap;
     type: "collection" | "global";
 }) => {
     access: {
-        aiPermissions: Record<import("./collectionPermissions.js").CollectionAction, boolean> | {
+        aiPermissions: Record<import("../collectionPermissions.js").CollectionAction, boolean> | {
             read: boolean;
             update: boolean;
         };
@@ -88,7 +68,7 @@ export declare const describeCollectionLikeConfig: ({ config, permissions, type,
 }) => {
     fields: Record<string, unknown>[];
     access: {
-        aiPermissions: Record<import("./collectionPermissions.js").CollectionAction, boolean> | {
+        aiPermissions: Record<import("../collectionPermissions.js").CollectionAction, boolean> | {
             read: boolean;
             update: boolean;
         };
@@ -110,10 +90,3 @@ export declare const collectBlocks: ({ fields, parent }: {
     parent: string;
     slug: string;
 })[];
-export declare const getAllowedCollectionSlugs: (req: Parameters<PayloadHandler>[0], collections?: ResolvedCollectionPermissionMap) => string[];
-export declare const getMentionContext: ({ blockContexts, collectionSlugs, collections, globalSlugs, mentions, req }: MentionContext) => Promise<Record<string, unknown>[]>;
-export declare const buildPromptWithMentionContext: ({ mentionContext, prompt }: {
-    mentionContext: Record<string, unknown>[];
-    prompt: string;
-}) => string;
-export {};

package/dist/{payload/schemaContext.js → features/schema/description.js}

@@ -1,6 +1,6 @@
-import { getCollectionPermissions, getCollectionSlugsForAction } from "./collectionPermissions.js";
-import { getSchemaFields as getNormalizeSchemaFields, hasDrafts, isAuthCollection } from "./normalizeData.js";
-import { getSerializableLabel, isInternalCollection, isRecord } from "./shared.js";
+import { getCollectionPermissions } from "../collectionPermissions.js";
+import { getSchemaFields as getNormalizeSchemaFields, hasDrafts, isAuthCollection } from "./normalize.js";
+import { getSerializableLabel, isRecord } from "../../utils/data.js";
 const getSerializableRelationTo = (relationTo)=>{
     if (typeof relationTo === "string") return relationTo;
     if (Array.isArray(relationTo) && relationTo.every((item)=>typeof item === "string")) {
@@ -11,37 +11,6 @@ const getSerializableRelationTo = (relationTo)=>{
 const fieldDescriptionCache = new WeakMap();
 const blockDescriptionCache = new WeakMap();
 const collectionDescriptionCache = new WeakMap();
-const getLocaleConfigs = (req)=>{
-    const localization = req.payload.config.localization;
-    const defaultLocale = localization?.defaultLocale;
-    const locales = localization?.locales || [];
-    return locales.flatMap((locale)=>{
-        if (typeof locale === "string") {
-            return [
-                {
-                    code: locale,
-                    ...locale === defaultLocale ? {
-                        isDefault: true
-                    } : {},
-                    label: locale
-                }
-            ];
-        }
-        if (!isRecord(locale)) return [];
-        const code = "code" in locale && typeof locale.code === "string" ? locale.code : "label" in locale && typeof locale.label === "string" ? locale.label : undefined;
-        if (!code) return [];
-        const label = "label" in locale ? getSerializableLabel(locale.label, code) : code;
-        return [
-            {
-                code,
-                ...code === defaultLocale ? {
-                    isDefault: true
-                } : {},
-                label
-            }
-        ];
-    });
-};
 const getSerializableOptions = (options)=>{
     if (!Array.isArray(options)) return undefined;
     const serializedOptions = options.flatMap((option)=>{
@@ -280,176 +249,3 @@ export const collectBlocks = ({ fields, parent })=>{
     }
     return blocks;
 };
-export const getAllowedCollectionSlugs = (req, collections)=>{
-    return getCollectionSlugsForAction({
-        action: "read",
-        permissions: collections,
-        req
-    });
-};
-export const getMentionContext = async ({ blockContexts, collectionSlugs, collections, globalSlugs, mentions, req })=>{
-    if (!mentions || mentions.length === 0) return [];
-    const context = [];
-    const seen = new Set();
-    const localeConfigs = getLocaleConfigs(req);
-    const localeConfigsByCode = new Map(localeConfigs.map((locale)=>[
-            locale.code,
-            locale
-        ]));
-    const collectionSlugSet = new Set(collectionSlugs);
-    const globalSlugSet = new Set(globalSlugs);
-    const collectionConfigsBySlug = new Map(req.payload.config.collections.map((collection)=>[
-            collection.slug,
-            collection
-        ]));
-    const globalConfigsBySlug = new Map(req.payload.config.globals?.map((global)=>[
-            global.slug,
-            global
-        ]));
-    const blockContextsBySlug = new Map();
-    for (const block of blockContexts){
-        const blocks = blockContextsBySlug.get(block.slug) || [];
-        blocks.push(block);
-        blockContextsBySlug.set(block.slug, blocks);
-    }
-    const selectedLocales = [];
-    const selectedLocaleSet = new Set();
-    for (const mention of mentions){
-        if (mention.type !== "locale" || !mention.slug || selectedLocaleSet.has(mention.slug)) continue;
-        selectedLocaleSet.add(mention.slug);
-        selectedLocales.push(mention.slug);
-    }
-    const activeLocale = selectedLocales.at(-1);
-    const mentionDocResults = await Promise.all(mentions.slice(0, 8).map(async (mention)=>{
-        if (mention.type === "global" && mention.slug) {
-            const slug = mention.slug;
-            if (!globalSlugSet.has(slug)) return null;
-            const globalConfig = globalConfigsBySlug.get(slug);
-            if (!globalConfig) return null;
-            return {
-                doc: await req.payload.findGlobal({
-                    depth: 2,
-                    ...activeLocale ? {
-                        locale: activeLocale
-                    } : {},
-                    overrideAccess: false,
-                    req,
-                    slug: slug
-                }).catch(()=>null),
-                key: `global:${slug}`
-            };
-        }
-        if (mention.type === "doc" && mention.collection && mention.id) {
-            const slug = mention.collection;
-            if (isInternalCollection(slug) || !collectionSlugSet.has(slug)) return null;
-            return {
-                doc: await req.payload.findByID({
-                    collection: slug,
-                    depth: 2,
-                    id: mention.id,
-                    ...activeLocale ? {
-                        locale: activeLocale
-                    } : {},
-                    overrideAccess: false,
-                    req
-                }).catch(()=>null),
-                key: `doc:${slug}:${mention.id}`
-            };
-        }
-        return null;
-    }));
-    const docsByMentionKey = new Map();
-    for (const result of mentionDocResults){
-        if (result) docsByMentionKey.set(result.key, result.doc);
-    }
-    if (localeConfigs.length > 0) {
-        context.push({
-            activeLocale,
-            defaultLocale: localeConfigs.find((locale)=>locale.isDefault)?.code,
-            locales: localeConfigs,
-            selectedLocales,
-            type: "locales"
-        });
-    }
-    for (const mention of mentions.slice(0, 8)){
-        if (mention.type === "locale" && mention.slug) {
-            const locale = localeConfigsByCode.get(mention.slug);
-            if (!locale) continue;
-            const key = `locale:${locale.code}`;
-            if (seen.has(key)) continue;
-            seen.add(key);
-            context.push({
-                ...locale,
-                type: "locale"
-            });
-        }
-        if (mention.type === "collection" && mention.slug) {
-            const slug = mention.slug;
-            const key = `collection:${slug}`;
-            if (seen.has(key) || isInternalCollection(slug) || !collectionSlugSet.has(slug)) continue;
-            const collectionConfig = collectionConfigsBySlug.get(slug);
-            if (!collectionConfig) continue;
-            seen.add(key);
-            context.push(describeCollectionLikeConfig({
-                config: collectionConfig,
-                permissions: collections,
-                type: "collection"
-            }));
-        }
-        if (mention.type === "global" && mention.slug) {
-            const slug = mention.slug;
-            const key = `global:${slug}`;
-            if (seen.has(key) || !globalSlugSet.has(slug)) continue;
-            const globalConfig = globalConfigsBySlug.get(slug);
-            if (!globalConfig) continue;
-            const globalDoc = docsByMentionKey.get(key) ?? null;
-            seen.add(key);
-            context.push({
-                ...describeCollectionLikeConfig({
-                    config: globalConfig,
-                    type: "global"
-                }),
-                doc: globalDoc
-            });
-        }
-        if (mention.type === "block" && mention.slug) {
-            const matchingBlocks = (blockContextsBySlug.get(mention.slug) || []).filter((block)=>!mention.parent || block.parent === mention.parent);
-            for (const block of matchingBlocks){
-                const key = `block:${block.parent}:${block.slug}`;
-                if (seen.has(key)) continue;
-                seen.add(key);
-                context.push({
-                    ...block,
-                    type: "block"
-                });
-            }
-        }
-        if (mention.type === "doc" && mention.collection && mention.id) {
-            const slug = mention.collection;
-            const key = `doc:${slug}:${mention.id}`;
-            if (seen.has(key) || isInternalCollection(slug) || !collectionSlugSet.has(slug)) continue;
-            const doc = docsByMentionKey.get(key);
-            if (!doc) continue;
-            seen.add(key);
-            context.push({
-                collection: slug,
-                doc,
-                id: mention.id,
-                label: mention.label || mention.id,
-                ...activeLocale ? {
-                    locale: activeLocale
-                } : {},
-                type: "doc"
-            });
-        }
-    }
-    return context;
-};
-export const buildPromptWithMentionContext = ({ mentionContext, prompt })=>{
-    if (mentionContext.length === 0) return prompt;
-    return [
-        "Selected Payload references JSON. Treat inline reference labels as these entities:",
-        JSON.stringify(mentionContext),
-        prompt
-    ].join("\n\n");
-};

package/dist/{payload/toolFieldSelection.d.ts → features/schema/fieldSelection.d.ts}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type CollectionConfig } from "./normalizeData.js";
+import { type CollectionConfig } from "./normalize.js";
 export declare const maxToolSelectedFields = 12;
 export type ReadCollectionConfig = CollectionConfig & {
     admin?: {

package/dist/{payload/toolFieldSelection.js → features/schema/fieldSelection.js}

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { isSensitiveKey } from "../ai/sensitiveData.js";
-import { getSchemaFields } from "./normalizeData.js";
+import { isSensitiveKey } from "../sensitiveData.js";
+import { getSchemaFields } from "./normalize.js";
 export const maxToolSelectedFields = 12;
 const cheapFieldTypes = new Set([
     "checkbox",

package/dist/features/schema/mentionDocuments.d.ts

@@ -0,0 +1,15 @@
+import type { PayloadHandler } from "payload";
+import type { SchemaContextRegistry } from "./registry.js";
+type MentionDocumentReference = {
+    collection?: string;
+    id?: string;
+    slug?: string;
+    type?: string;
+};
+export declare const loadMentionDocuments: ({ activeLocale, mentions, registry, req, }: {
+    activeLocale?: string;
+    mentions: MentionDocumentReference[];
+    registry: Pick<SchemaContextRegistry, "collectionSlugSet" | "globalSlugSet">;
+    req: Parameters<PayloadHandler>[0];
+}) => Promise<Map<string, unknown>>;
+export {};

package/dist/features/schema/mentionDocuments.js

@@ -0,0 +1,50 @@
+import { isInternalCollection } from "../../utils/data.js";
+export const loadMentionDocuments = async ({ activeLocale, mentions, registry, req })=>{
+    const requests = new Map();
+    for (const mention of mentions){
+        if (mention.type === "global" && mention.slug && registry.globalSlugSet.has(mention.slug)) {
+            const request = {
+                key: `global:${mention.slug}`,
+                slug: mention.slug,
+                type: "global"
+            };
+            requests.set(request.key, request);
+        }
+        if (mention.type === "doc" && mention.collection && mention.id && !isInternalCollection(mention.collection) && registry.collectionSlugSet.has(mention.collection)) {
+            const request = {
+                collection: mention.collection,
+                id: mention.id,
+                key: `doc:${mention.collection}:${mention.id}`,
+                type: "doc"
+            };
+            requests.set(request.key, request);
+        }
+    }
+    const results = await Promise.all([
+        ...requests.values()
+    ].map(async (request)=>{
+        const doc = request.type === "global" ? await req.payload.findGlobal({
+            depth: 2,
+            ...activeLocale ? {
+                locale: activeLocale
+            } : {},
+            overrideAccess: false,
+            req,
+            slug: request.slug
+        }).catch(()=>null) : await req.payload.findByID({
+            collection: request.collection,
+            depth: 2,
+            id: request.id,
+            ...activeLocale ? {
+                locale: activeLocale
+            } : {},
+            overrideAccess: false,
+            req
+        }).catch(()=>null);
+        return [
+            request.key,
+            doc
+        ];
+    }));
+    return new Map(results);
+};

package/dist/features/schema/mentions.d.ts

@@ -0,0 +1,18 @@
+import type { PayloadHandler } from "payload";
+import { type ResolvedCollectionPermissionMap } from "../collectionPermissions.js";
+import type { SchemaContextRegistry, SchemaRegistrySource } from "./registry.js";
+export type ChatMention = {
+    collection?: string;
+    id?: string;
+    label?: string;
+    parent?: string;
+    slug?: string;
+    type?: "block" | "collection" | "doc" | "global" | "locale";
+};
+export declare const getAllowedCollectionSlugs: (req: Parameters<PayloadHandler>[0], collections?: ResolvedCollectionPermissionMap) => string[];
+export declare const getMentionContext: <Collection extends SchemaRegistrySource, Global extends SchemaRegistrySource>({ collections, mentions, registry, req, }: {
+    collections?: ResolvedCollectionPermissionMap;
+    mentions?: ChatMention[];
+    registry: SchemaContextRegistry<Collection, Global>;
+    req: Parameters<PayloadHandler>[0];
+}) => Promise<Record<string, unknown>[]>;

package/dist/features/schema/mentions.js

@@ -0,0 +1,100 @@
+import { getCollectionSlugsForAction } from "../collectionPermissions.js";
+import { isInternalCollection } from "../../utils/data.js";
+import { describeCollectionLikeConfig } from "./description.js";
+import { loadMentionDocuments } from "./mentionDocuments.js";
+export const getAllowedCollectionSlugs = (req, collections)=>getCollectionSlugsForAction({
+        action: "read",
+        permissions: collections,
+        req
+    });
+export const getMentionContext = async ({ collections, mentions, registry, req })=>{
+    if (!mentions?.length) return [];
+    const context = [];
+    const seen = new Set();
+    const selectedLocales = [
+        ...new Set(mentions.flatMap((mention)=>mention.type === "locale" && mention.slug ? [
+                mention.slug
+            ] : []))
+    ];
+    const activeLocale = selectedLocales.at(-1);
+    const limitedMentions = mentions.slice(0, 8);
+    const docsByMentionKey = await loadMentionDocuments({
+        activeLocale,
+        mentions: limitedMentions,
+        registry,
+        req
+    });
+    if (registry.localeConfigs.length > 0) {
+        context.push({
+            activeLocale,
+            defaultLocale: registry.localeConfigs.find((locale)=>locale.isDefault)?.code,
+            locales: registry.localeConfigs,
+            selectedLocales,
+            type: "locales"
+        });
+    }
+    for (const mention of limitedMentions){
+        if (mention.type === "locale" && mention.slug) {
+            const locale = registry.localeConfigsByCode.get(mention.slug);
+            if (!locale || seen.has(`locale:${locale.code}`)) continue;
+            seen.add(`locale:${locale.code}`);
+            context.push({
+                ...locale,
+                type: "locale"
+            });
+        }
+        if (mention.type === "collection" && mention.slug) {
+            const key = `collection:${mention.slug}`;
+            const config = registry.collectionConfigsBySlug.get(mention.slug);
+            if (seen.has(key) || isInternalCollection(mention.slug) || !config) continue;
+            seen.add(key);
+            context.push(describeCollectionLikeConfig({
+                config: config,
+                permissions: collections,
+                type: "collection"
+            }));
+        }
+        if (mention.type === "global" && mention.slug) {
+            const key = `global:${mention.slug}`;
+            const config = registry.globalConfigsBySlug.get(mention.slug);
+            if (seen.has(key) || !config) continue;
+            seen.add(key);
+            context.push({
+                ...describeCollectionLikeConfig({
+                    config: config,
+                    type: "global"
+                }),
+                doc: docsByMentionKey.get(key) ?? null
+            });
+        }
+        if (mention.type === "block" && mention.slug) {
+            const matchingBlocks = (registry.blocksBySlug.get(mention.slug) || []).filter((block)=>!mention.parent || block.parent === mention.parent);
+            for (const block of matchingBlocks){
+                const key = `block:${block.parent}:${block.slug}`;
+                if (seen.has(key)) continue;
+                seen.add(key);
+                context.push({
+                    ...block,
+                    type: "block"
+                });
+            }
+        }
+        if (mention.type === "doc" && mention.collection && mention.id) {
+            const key = `doc:${mention.collection}:${mention.id}`;
+            const doc = docsByMentionKey.get(key);
+            if (seen.has(key) || isInternalCollection(mention.collection) || !registry.collectionSlugSet.has(mention.collection) || !doc) continue;
+            seen.add(key);
+            context.push({
+                collection: mention.collection,
+                doc,
+                id: mention.id,
+                label: mention.label || mention.id,
+                ...activeLocale ? {
+                    locale: activeLocale
+                } : {},
+                type: "doc"
+            });
+        }
+    }
+    return context;
+};

package/dist/{payload/normalizeData.js → features/schema/normalize.js}

@@ -1,4 +1,4 @@
-import { isRecord } from "./shared.js";
+import { isRecord } from "../../utils/data.js";
 const SKIP_FIELD = Symbol("skipField");
 const getNamedFields = (fields)=>{
     return fields.filter((field)=>Boolean(field.name));

package/dist/features/schema/registry.d.ts

@@ -0,0 +1,30 @@
+import type { PayloadHandler } from "payload";
+import { type CollectionLikeConfig } from "./description.js";
+export type LocaleConfig = {
+    code: string;
+    isDefault?: boolean;
+    label: string;
+};
+export type SchemaBlockContext = Record<string, unknown> & {
+    parent: string;
+    slug: string;
+};
+export type SchemaRegistrySource = {
+    fields?: unknown[];
+    slug: string;
+};
+export type SchemaContextRegistry<Collection extends SchemaRegistrySource = CollectionLikeConfig, Global extends SchemaRegistrySource = CollectionLikeConfig> = {
+    blocks: SchemaBlockContext[];
+    blocksBySlug: Map<string, SchemaBlockContext[]>;
+    collectionConfigsBySlug: Map<string, Collection>;
+    collectionSlugSet: Set<string>;
+    globalConfigsBySlug: Map<string, Global>;
+    globalSlugSet: Set<string>;
+    localeConfigs: LocaleConfig[];
+    localeConfigsByCode: Map<string, LocaleConfig>;
+};
+export declare const createSchemaContextRegistry: <Collection extends SchemaRegistrySource, Global extends SchemaRegistrySource>({ collections, globals, req, }: {
+    collections: Collection[];
+    globals: Global[];
+    req: Parameters<PayloadHandler>[0];
+}) => SchemaContextRegistry<Collection, Global>;

package/dist/features/schema/registry.js

@@ -0,0 +1,73 @@
+import { getSerializableLabel, isRecord } from "../../utils/data.js";
+import { collectBlocks } from "./description.js";
+const getLocaleConfigs = (req)=>{
+    const localization = req.payload.config.localization;
+    const defaultLocale = localization?.defaultLocale;
+    return (localization?.locales || []).flatMap((locale)=>{
+        if (typeof locale === "string") {
+            return [
+                {
+                    code: locale,
+                    ...locale === defaultLocale ? {
+                        isDefault: true
+                    } : {},
+                    label: locale
+                }
+            ];
+        }
+        if (!isRecord(locale)) return [];
+        const code = typeof locale.code === "string" ? locale.code : typeof locale.label === "string" ? locale.label : undefined;
+        if (!code) return [];
+        return [
+            {
+                code,
+                ...code === defaultLocale ? {
+                    isDefault: true
+                } : {},
+                label: "label" in locale ? getSerializableLabel(locale.label, code) : code
+            }
+        ];
+    });
+};
+export const createSchemaContextRegistry = ({ collections, globals, req })=>{
+    const collectionConfigs = collections;
+    const globalConfigs = globals;
+    const blocks = [
+        ...collectionConfigs.flatMap((collection)=>collectBlocks({
+                fields: collection.fields || [],
+                parent: collection.slug
+            })),
+        ...globalConfigs.flatMap((global)=>collectBlocks({
+                fields: global.fields || [],
+                parent: global.slug
+            }))
+    ];
+    const blocksBySlug = new Map();
+    for (const block of blocks){
+        const matchingBlocks = blocksBySlug.get(block.slug) || [];
+        matchingBlocks.push(block);
+        blocksBySlug.set(block.slug, matchingBlocks);
+    }
+    const collectionConfigsBySlug = new Map(collections.map((collection)=>[
+            collection.slug,
+            collection
+        ]));
+    const globalConfigsBySlug = new Map(globals.map((global)=>[
+            global.slug,
+            global
+        ]));
+    const localeConfigs = getLocaleConfigs(req);
+    return {
+        blocks,
+        blocksBySlug,
+        collectionConfigsBySlug,
+        collectionSlugSet: new Set(collectionConfigsBySlug.keys()),
+        globalConfigsBySlug,
+        globalSlugSet: new Set(globalConfigsBySlug.keys()),
+        localeConfigs,
+        localeConfigsByCode: new Map(localeConfigs.map((locale)=>[
+                locale.code,
+                locale
+            ]))
+    };
+};

package/dist/{payload → features/schema}/toolSchemas.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type CollectionConfig } from "./normalizeData.js";
+import { type CollectionConfig } from "./normalize.js";
 export declare const genericPayloadDataSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 export declare const createPayloadDataSchema: (config?: CollectionConfig | null) => z.ZodRecord<z.ZodString, z.ZodUnknown> | z.ZodObject<{
     [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;

package/dist/{payload → features/schema}/toolSchemas.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { getSchemaFields } from "./normalizeData.js";
+import { getSchemaFields } from "./normalize.js";
 const relationshipIDSchema = z.union([
     z.string().min(1),
     z.number()