@focus-reactive/payload-plugin-translator 0.4.0 → 0.5.0

package/dist/server/features/get-collection-status/route.js

@@ -1,12 +1,12 @@
-import { withErrorHandler, withAccessCheck } from '../../shared';
-import { GetCollectionStatusHandler } from './handler';
+import { withErrorHandler, withAccessCheck } from "../../shared";
+import { GetCollectionStatusHandler } from "./handler";
 /**
  * Creates the get collection status endpoint
- */ export function createGetCollectionStatusRoute(config, taskRunnerFactory, access, basePath = '/translate') {
+ */ export function createGetCollectionStatusRoute(config, taskRunnerFactory, access, basePath = "/translate") {
     const handler = new GetCollectionStatusHandler(config, taskRunnerFactory);
     return {
         path: `${basePath}/collection/:collection_slug`,
-        method: 'get',
+        method: "get",
         handler: withAccessCheck(withErrorHandler(handler.handle.bind(handler)), access)
     };
 }

package/dist/server/features/get-document-status/handler.d.ts

@@ -1,12 +1,12 @@
 import type { PayloadRequest } from "payload";
-import type { TaskRunnerProvider } from "../../modules/task-runner";
-import type { GetDocumentStatusConfig } from './model';
+import type { TaskRunnerFactory } from "../../modules/task-runner";
+import type { GetDocumentStatusConfig } from "./model";
 /**
  * Gets the translation status for a specific document
  */
 export declare class GetDocumentStatusHandler {
     private readonly config;
     private readonly taskRunnerFactory;
-    constructor(config: GetDocumentStatusConfig, taskRunnerFactory: TaskRunnerProvider);
+    constructor(config: GetDocumentStatusConfig, taskRunnerFactory: TaskRunnerFactory);
     handle(req: PayloadRequest): Promise<Response>;
 }

package/dist/server/features/get-document-status/handler.js

@@ -1,6 +1,6 @@
 import { ServerResponse } from "../../shared";
 import { isCollectionAvailable } from "../_lib/collection-utils";
-import { GetDocumentStatusInputSchema, taskToJobStatusOutput } from './model';
+import { GetDocumentStatusInputSchema, taskToJobStatusOutput } from "./model";
 /**
  * Gets the translation status for a specific document
  */ export class GetDocumentStatusHandler {

package/dist/server/features/get-document-status/route.d.ts

@@ -1,8 +1,8 @@
-import type { Endpoint } from 'payload';
-import type { AccessGuard } from '../../shared';
-import type { TaskRunnerProvider } from '../../modules/task-runner';
-import type { GetDocumentStatusConfig } from './model';
+import type { Endpoint } from "payload";
+import type { AccessGuard } from "../../shared";
+import type { TaskRunnerFactory } from "../../modules/task-runner";
+import type { GetDocumentStatusConfig } from "./model";
 /**
  * Creates the get document status endpoint
  */
-export declare function createGetDocumentStatusRoute(config: GetDocumentStatusConfig, taskRunnerFactory: TaskRunnerProvider, access?: AccessGuard, basePath?: string): Endpoint;
+export declare function createGetDocumentStatusRoute(config: GetDocumentStatusConfig, taskRunnerFactory: TaskRunnerFactory, access?: AccessGuard, basePath?: string): Endpoint;

package/dist/server/features/get-document-status/route.js

@@ -1,12 +1,12 @@
-import { withErrorHandler, withAccessCheck } from '../../shared';
-import { GetDocumentStatusHandler } from './handler';
+import { withErrorHandler, withAccessCheck } from "../../shared";
+import { GetDocumentStatusHandler } from "./handler";
 /**
  * Creates the get document status endpoint
- */ export function createGetDocumentStatusRoute(config, taskRunnerFactory, access, basePath = '/translate') {
+ */ export function createGetDocumentStatusRoute(config, taskRunnerFactory, access, basePath = "/translate") {
     const handler = new GetDocumentStatusHandler(config, taskRunnerFactory);
     return {
         path: `${basePath}/document/:collection_slug/:collection_id`,
-        method: 'get',
+        method: "get",
         handler: withAccessCheck(withErrorHandler(handler.handle.bind(handler)), access)
     };
 }

package/dist/server/features/index.d.ts

@@ -1,6 +1,7 @@
-export * from './translate-document';
-export * from './enqueue-translation';
-export * from './run-translation';
-export * from './cancel';
-export * from './get-document-status';
-export * from './get-collection-status';
+export * from "./createTranslationRoutes";
+export * from "./translate-document";
+export * from "./enqueue-translation";
+export * from "./run-translation";
+export * from "./cancel";
+export * from "./get-document-status";
+export * from "./get-collection-status";

package/dist/server/features/index.js

@@ -1,8 +1,9 @@
-export * from './translate-document';
-export * from './enqueue-translation';
-export * from './run-translation';
-export * from './cancel';
-export * from './get-document-status';
-export * from './get-collection-status';
+export * from "./createTranslationRoutes";
+export * from "./translate-document";
+export * from "./enqueue-translation";
+export * from "./run-translation";
+export * from "./cancel";
+export * from "./get-document-status";
+export * from "./get-collection-status";
 
 //# sourceMappingURL=index.js.map

package/dist/server/features/run-translation/handler.d.ts

@@ -1,10 +1,10 @@
 import type { PayloadRequest } from "payload";
-import type { TaskRunnerProvider } from "../../modules/task-runner";
+import type { TaskRunnerFactory } from "../../modules/task-runner";
 /**
  * Runs a translation task by ID
  */
 export declare class RunTranslationHandler {
     private readonly taskRunnerFactory;
-    constructor(taskRunnerFactory: TaskRunnerProvider);
+    constructor(taskRunnerFactory: TaskRunnerFactory);
     handle(req: PayloadRequest): Promise<Response>;
 }

package/dist/server/features/run-translation/route.d.ts

@@ -1,7 +1,7 @@
-import type { Endpoint } from 'payload';
-import type { AccessGuard } from '../../shared';
-import type { TaskRunnerProvider } from '../../modules/task-runner';
+import type { Endpoint } from "payload";
+import type { AccessGuard } from "../../shared";
+import type { TaskRunnerFactory } from "../../modules/task-runner";
 /**
  * Creates the run translation endpoint
  */
-export declare function createRunRoute(taskRunnerFactory: TaskRunnerProvider, access?: AccessGuard, basePath?: string): Endpoint;
+export declare function createRunRoute(taskRunnerFactory: TaskRunnerFactory, access?: AccessGuard, basePath?: string): Endpoint;

package/dist/server/features/run-translation/route.js

@@ -1,12 +1,12 @@
-import { withErrorHandler, withAccessCheck } from '../../shared';
-import { RunTranslationHandler } from './handler';
+import { withErrorHandler, withAccessCheck } from "../../shared";
+import { RunTranslationHandler } from "./handler";
 /**
  * Creates the run translation endpoint
- */ export function createRunRoute(taskRunnerFactory, access, basePath = '/translate') {
+ */ export function createRunRoute(taskRunnerFactory, access, basePath = "/translate") {
     const handler = new RunTranslationHandler(taskRunnerFactory);
     return {
         path: `${basePath}/run/:id`,
-        method: 'post',
+        method: "post",
         handler: withAccessCheck(withErrorHandler(handler.handle.bind(handler)), access)
     };
 }

package/dist/server/features/translate-document/handler.js

@@ -1,6 +1,5 @@
 import { APIError } from "payload";
-import { TranslationPipeline } from "../../modules/translation-pipeline";
-import { createTranslationStrategy } from "../../modules/translation-pipeline/strategies";
+import { translateContent } from "../../modules/translation-pipeline";
 /**
  * Translates a single document from source language to target language
  */ export class TranslateDocumentHandler {
@@ -28,23 +27,20 @@ import { createTranslationStrategy } from "../../modules/translation-pipeline/st
             fallbackLocale: false,
             depth: 0
         });
-        const translationStrategy = createTranslationStrategy(strategy);
-        const pipeline = new TranslationPipeline({
-            translationProvider: this.translationProvider,
-            translationStrategy
-        });
-        const result = await pipeline.execute({
+        const translatedData = await translateContent({
             schema,
             sourceData,
             targetData,
             sourceLng,
-            targetLng
+            targetLng,
+            translationProvider: this.translationProvider,
+            strategy
         });
-        if (!result) return {
+        if (!translatedData) return {
             success: true
         };
         const collectionConfig = payload.collections[collection].config;
-        await this.saveTranslatedDocument(payload, collection, collectionId, result.translatedData, targetLng, sourceLng, collectionConfig, publishOnTranslation);
+        await this.saveTranslatedDocument(payload, collection, collectionId, translatedData, targetLng, sourceLng, collectionConfig, publishOnTranslation);
         return {
             success: true
         };

package/dist/server/modules/task-runner/TaskRunnerProvider.interface.d.ts

@@ -24,6 +24,16 @@ export type TaskRunnerContext = {
     handler: TaskHandler;
     collections: CollectionSlug[];
 };
+/**
+ * The runtime half of a runner: produces a `TaskRunner` for one request.
+ *
+ * Routes depend on this narrow surface — they only ever `create()`, never
+ * `configure()`. The plugin binds the {@link TaskRunnerContext} once at build
+ * time and hands routes a factory, so a `create()` call needs no ambient state.
+ */
+export type TaskRunnerFactory = {
+    create(payload: Payload): TaskRunner;
+};
 /**
  * Main interface for pluggable task runner providers.
  *
@@ -36,8 +46,15 @@ export type TaskRunnerContext = {
 export interface TaskRunnerProvider {
     /**
      * Creates a TaskRunner instance for runtime operations (enqueue, cancel, find).
+     *
+     * `handler` is supplied by the caller at create time (the plugin binds it
+     * into a {@link TaskRunnerFactory}) — so providers hold no mutable per-instance
+     * state and `create()` does not depend on `configure()` having run. It is the
+     * only runtime dependency (collection metadata is a `configure()`-time concern).
+     * `PayloadJobsRunner` ignores it (the handler is baked into the registered
+     * task at configure time); `SyncRunner` uses it to run translations inline.
      */
-    create(payload: Payload): TaskRunner;
+    create(payload: Payload, handler: TaskHandler): TaskRunner;
     /**
      * Configures the runner and returns a Payload config modifier.
      * The modifier adds necessary tasks, jobs, queues to Payload config.

package/dist/server/modules/task-runner/index.d.ts

@@ -1,6 +1,6 @@
-export type { TaskRunnerProvider } from './TaskRunnerProvider.interface';
-export type { Task, TaskStatus } from './types';
-export { createPayloadJobsRunner } from './payload-jobs-runner';
-export type { PayloadJobsRunnerOptions } from './payload-jobs-runner';
-export { createSyncRunner } from './sync-runner';
-export type { TaskRunner } from './TaskRunner.interface';
+export type { TaskRunnerProvider, TaskRunnerFactory, TaskRunnerContext } from "./TaskRunnerProvider.interface";
+export type { Task, TaskStatus } from "./types";
+export { createPayloadJobsRunner } from "./payload-jobs-runner";
+export type { PayloadJobsRunnerOptions } from "./payload-jobs-runner";
+export { createSyncRunner } from "./sync-runner";
+export type { TaskRunner } from "./TaskRunner.interface";

package/dist/server/modules/task-runner/index.js

@@ -1,4 +1,4 @@
-export { createPayloadJobsRunner } from './payload-jobs-runner';
-export { createSyncRunner } from './sync-runner';
+export { createPayloadJobsRunner } from "./payload-jobs-runner";
+export { createSyncRunner } from "./sync-runner";
 
 //# sourceMappingURL=index.js.map

package/dist/server/modules/task-runner/payload-jobs-runner/PayloadJobsRunnerProvider.d.ts

@@ -14,6 +14,21 @@ export declare class PayloadJobsRunnerProvider implements TaskRunnerProvider {
     configure(context: TaskRunnerContext): (config: Config) => Config;
 }
 /**
- * Creates a TaskRunnerProvider that uses Payload Jobs for task execution.
+ * Creates the **recommended** task runner: translations run as Payload Jobs
+ * (queued, executed by autoRun cron or a manual run, with stale-lock recovery).
+ * Durable across restarts and suited to production/serverless. Pass the result
+ * as `translatorPlugin({ runner })`.
+ *
+ * @param options - Queue/task names, `autoRun` cron (or `false` to disable),
+ *   `staleJobTimeoutMs`, and retry policy. See {@link PayloadJobsRunnerOptions}.
+ * @returns A {@link TaskRunnerProvider} for the plugin's `runner` option.
+ * @example
+ * ```ts
+ * translatorPlugin({
+ *   collections: [Posts],
+ *   translationProvider: createOpenAIProvider({ apiKey: process.env.OPENAI_API_KEY! }),
+ *   runner: createPayloadJobsRunner({ autoRun: { cron: '* * * * *' } }),
+ * })
+ * ```
  */
 export declare function createPayloadJobsRunner(options?: PayloadJobsRunnerOptions): TaskRunnerProvider;

package/dist/server/modules/task-runner/payload-jobs-runner/PayloadJobsRunnerProvider.js

@@ -172,7 +172,22 @@ const defaultValues = {
     }
 }
 /**
- * Creates a TaskRunnerProvider that uses Payload Jobs for task execution.
+ * Creates the **recommended** task runner: translations run as Payload Jobs
+ * (queued, executed by autoRun cron or a manual run, with stale-lock recovery).
+ * Durable across restarts and suited to production/serverless. Pass the result
+ * as `translatorPlugin({ runner })`.
+ *
+ * @param options - Queue/task names, `autoRun` cron (or `false` to disable),
+ *   `staleJobTimeoutMs`, and retry policy. See {@link PayloadJobsRunnerOptions}.
+ * @returns A {@link TaskRunnerProvider} for the plugin's `runner` option.
+ * @example
+ * ```ts
+ * translatorPlugin({
+ *   collections: [Posts],
+ *   translationProvider: createOpenAIProvider({ apiKey: process.env.OPENAI_API_KEY! }),
+ *   runner: createPayloadJobsRunner({ autoRun: { cron: '* * * * *' } }),
+ * })
+ * ```
  */ export function createPayloadJobsRunner(options) {
     return new PayloadJobsRunnerProvider(options);
 }

package/dist/server/modules/task-runner/sync-runner/SyncRunnerProvider.d.ts

@@ -1,7 +1,7 @@
-import type { Config, Payload } from 'payload';
-import type { TaskRunner } from '../TaskRunner.interface';
-import type { TaskRunnerProvider, TaskRunnerContext } from '../TaskRunnerProvider.interface';
-import type { SyncRunnerOptions } from './types';
+import type { Config, Payload } from "payload";
+import type { TaskRunner } from "../TaskRunner.interface";
+import type { TaskRunnerProvider, TaskHandler } from "../TaskRunnerProvider.interface";
+import type { SyncRunnerOptions } from "./types";
 /**
  * Synchronous TaskRunnerProvider implementation.
  *
@@ -9,16 +9,24 @@ import type { SyncRunnerOptions } from './types';
  * Useful for development, testing, or simple use cases.
  */
 export declare class SyncRunnerProvider implements TaskRunnerProvider {
-    private handler?;
     private readonly tasks;
     constructor(options?: SyncRunnerOptions);
-    create(payload: Payload): TaskRunner;
-    configure(context: TaskRunnerContext): (config: Config) => Config;
+    create(payload: Payload, handler: TaskHandler): TaskRunner;
+    configure(): (config: Config) => Config;
 }
 /**
- * Creates a synchronous TaskRunnerProvider.
+ * Creates a synchronous task runner: translations execute inline on enqueue,
+ * with no Payload Jobs queue. Status is kept in an in-memory map (bounded by
+ * `maxSize`/`ttlMs`) and is **lost on server restart**, so this is best for
+ * development, tests, or simple single-process setups — not serverless. Pass the
+ * result as `translatorPlugin({ runner })`.
  *
- * Executes translations immediately without queuing.
- * Results are stored in memory and lost on server restart.
+ * @param options - In-memory store bounds: `maxSize` (default 100) and `ttlMs`
+ *   (default 1h) for completed/failed task records.
+ * @returns A {@link TaskRunnerProvider} for the plugin's `runner` option.
+ * @example
+ * ```ts
+ * translatorPlugin({ collections, translationProvider, runner: createSyncRunner() })
+ * ```
  */
 export declare function createSyncRunner(options?: SyncRunnerOptions): TaskRunnerProvider;

package/dist/server/modules/task-runner/sync-runner/SyncRunnerProvider.js

@@ -1,15 +1,13 @@
-import { SyncTaskRunner } from './SyncTaskRunner';
-import { LazyMap } from '../../../shared/utils';
+import { SyncTaskRunner } from "./SyncTaskRunner";
+import { LazyMap } from "../../../shared/utils";
 const DEFAULT_MAX_SIZE = 100;
-const DEFAULT_TTL_MS = 60 * 60 * 1000 // 1 hour
-;
+const DEFAULT_TTL_MS = 60 * 60 * 1000; // 1 hour
 /**
  * Synchronous TaskRunnerProvider implementation.
  *
  * Executes translations immediately without Payload Jobs.
  * Useful for development, testing, or simple use cases.
  */ export class SyncRunnerProvider {
-    handler;
     tasks;
     constructor(options){
         const maxSize = options?.maxSize ?? DEFAULT_MAX_SIZE;
@@ -17,24 +15,36 @@ const DEFAULT_TTL_MS = 60 * 60 * 1000 // 1 hour
         this.tasks = new LazyMap({
             maxSize,
             ttlMs,
-            isRemovable: (task)=>task.status === 'completed' || task.status === 'failed',
+            isRemovable: (task)=>task.status === "completed" || task.status === "failed",
             getTimestamp: (task)=>new Date(task.updatedAt).getTime()
         });
     }
-    create(payload) {
-        if (!this.handler) throw new Error('SyncRunnerProvider not configured. Call configure() first.');
-        return new SyncTaskRunner(payload, this.handler, this.tasks);
+    // SyncRunner executes the translation inline on enqueue, so it needs the
+    // handler at create time — taken from the caller-supplied argument rather than
+    // stashed on the instance during configure(). No ambient state, no ordering
+    // coupling: create() is a pure function of its arguments.
+    create(payload, handler) {
+        return new SyncTaskRunner(payload, handler, this.tasks);
     }
-    configure(context) {
-        this.handler = context.handler;
+    // No config changes needed — translations run synchronously, no Payload jobs.
+    configure() {
         return (config)=>config;
     }
 }
 /**
- * Creates a synchronous TaskRunnerProvider.
+ * Creates a synchronous task runner: translations execute inline on enqueue,
+ * with no Payload Jobs queue. Status is kept in an in-memory map (bounded by
+ * `maxSize`/`ttlMs`) and is **lost on server restart**, so this is best for
+ * development, tests, or simple single-process setups — not serverless. Pass the
+ * result as `translatorPlugin({ runner })`.
  *
- * Executes translations immediately without queuing.
- * Results are stored in memory and lost on server restart.
+ * @param options - In-memory store bounds: `maxSize` (default 100) and `ttlMs`
+ *   (default 1h) for completed/failed task records.
+ * @returns A {@link TaskRunnerProvider} for the plugin's `runner` option.
+ * @example
+ * ```ts
+ * translatorPlugin({ collections, translationProvider, runner: createSyncRunner() })
+ * ```
  */ export function createSyncRunner(options) {
     return new SyncRunnerProvider(options);
 }

package/dist/server/modules/translation-levels/PluginConfigBuilder.d.ts

@@ -0,0 +1,46 @@
+import type { CollectionConfig, Config, Endpoint } from "payload";
+import type { AccessGuard } from "../../../types/AccessGuard";
+import type { RawPayloadComponentExport } from "../../../client/shared/types/PayloadComponentExport";
+import type { TaskRunnerFactory } from "../task-runner";
+import type { CollectionAdminSlot, LevelContext } from "./types";
+type ConfigModifier = (config: Config) => Config;
+export type PluginConfigBuilderDeps = {
+    collections: CollectionConfig[];
+    basePath: string;
+    access?: AccessGuard;
+    taskRunnerFactory: TaskRunnerFactory;
+};
+/**
+ * The single place that mutates the Payload `config`. Levels (through the narrow
+ * {@link LevelContext}) and the plugin (through `addAdminProvider` /
+ * `addConfigModifier`) only *describe* their contributions; `applyTo(config)` is
+ * the one sink that writes them in. This keeps Payload's in-place-mutation style
+ * — including the lazy nested-config init — confined here, so `plugin.ts` and the
+ * levels stay free of direct config mutation.
+ *
+ * It implements {@link LevelContext}, so the same instance is what levels receive
+ * as their context (they see only `addEndpoints` / `addCollectionComponent`).
+ */
+export declare class PluginConfigBuilder implements LevelContext {
+    readonly collections: CollectionConfig[];
+    readonly basePath: string;
+    readonly access?: AccessGuard;
+    readonly taskRunnerFactory: TaskRunnerFactory;
+    private readonly endpoints;
+    private readonly collectionComponents;
+    private readonly adminProviders;
+    private readonly configModifiers;
+    constructor(deps: PluginConfigBuilderDeps);
+    addEndpoints(endpoints: Endpoint[]): void;
+    addCollectionComponent(slot: CollectionAdminSlot, make: (collection: CollectionConfig) => RawPayloadComponentExport): void;
+    /** Register a global admin provider (e.g. the client cache provider). */
+    addAdminProvider(provider: RawPayloadComponentExport): void;
+    /** Register a config modifier (e.g. the runner's jobs/autorun/onInit setup). */
+    addConfigModifier(modifier: ConfigModifier): void;
+    /** The one sink that writes every accumulated contribution into `config`. */
+    applyTo(config: Config): Config;
+    private attachAdminProviders;
+    private attachCollectionComponents;
+    private registerEndpoints;
+}
+export {};

package/dist/server/modules/translation-levels/PluginConfigBuilder.js

@@ -0,0 +1,108 @@
+const endpointKey = (endpoint)=>`${endpoint.method} ${endpoint.path}`;
+function attachToSlot(collection, slot, component) {
+    if (!collection.admin) collection.admin = {};
+    if (!collection.admin.components) collection.admin.components = {};
+    const components = collection.admin.components;
+    if (slot === "beforeDocumentControls") {
+        if (!components.edit) components.edit = {};
+        if (!components.edit.beforeDocumentControls) components.edit.beforeDocumentControls = [];
+        components.edit.beforeDocumentControls.push(component);
+        return;
+    }
+    if (slot === "beforeListTable") {
+        if (!components.beforeListTable) components.beforeListTable = [];
+        components.beforeListTable.push(component);
+        return;
+    }
+    // Exhaustiveness: a new CollectionAdminSlot must be handled above, not fall through.
+    slot;
+}
+/**
+ * The single place that mutates the Payload `config`. Levels (through the narrow
+ * {@link LevelContext}) and the plugin (through `addAdminProvider` /
+ * `addConfigModifier`) only *describe* their contributions; `applyTo(config)` is
+ * the one sink that writes them in. This keeps Payload's in-place-mutation style
+ * — including the lazy nested-config init — confined here, so `plugin.ts` and the
+ * levels stay free of direct config mutation.
+ *
+ * It implements {@link LevelContext}, so the same instance is what levels receive
+ * as their context (they see only `addEndpoints` / `addCollectionComponent`).
+ */ export class PluginConfigBuilder {
+    collections;
+    basePath;
+    access;
+    taskRunnerFactory;
+    endpoints = [];
+    collectionComponents = [];
+    adminProviders = [];
+    configModifiers = [];
+    constructor(deps){
+        this.collections = deps.collections;
+        this.basePath = deps.basePath;
+        this.access = deps.access;
+        this.taskRunnerFactory = deps.taskRunnerFactory;
+    }
+    addEndpoints(endpoints) {
+        this.endpoints.push(...endpoints);
+    }
+    addCollectionComponent(slot, make) {
+        this.collectionComponents.push({
+            slot,
+            make
+        });
+    }
+    /** Register a global admin provider (e.g. the client cache provider). */ addAdminProvider(provider) {
+        this.adminProviders.push(provider);
+    }
+    /** Register a config modifier (e.g. the runner's jobs/autorun/onInit setup). */ addConfigModifier(modifier) {
+        this.configModifiers.push(modifier);
+    }
+    /** The one sink that writes every accumulated contribution into `config`. */ applyTo(config) {
+        // Config modifiers first — a runner's modifier may return a fresh config
+        // object, so everything else must be applied to its result.
+        let result = config;
+        for (const modify of this.configModifiers)result = modify(result);
+        this.attachAdminProviders(result);
+        this.attachCollectionComponents(result);
+        this.registerEndpoints(result);
+        return result;
+    }
+    attachAdminProviders(config) {
+        if (this.adminProviders.length === 0) return;
+        if (!config.admin) config.admin = {};
+        if (!config.admin.components) config.admin.components = {};
+        if (!config.admin.components.providers) config.admin.components.providers = [];
+        // Not deduplicated. Unlike a duplicate endpoint (a route conflict), a
+        // duplicate admin provider is harmless, and providers have no reliable
+        // identity key across their shapes (`string | { path } | false`, with
+        // distinguishing `serverProps`). The single CacheProvider is added once per
+        // plugin instance.
+        config.admin.components.providers.push(...this.adminProviders);
+    }
+    attachCollectionComponents(config) {
+        if (this.collectionComponents.length === 0) return;
+        const managed = new Set(this.collections.map((collection)=>collection.slug));
+        config.collections?.forEach((collection)=>{
+            if (!managed.has(collection.slug)) return;
+            for (const { slot, make } of this.collectionComponents){
+                attachToSlot(collection, slot, make(collection));
+            }
+        });
+    }
+    registerEndpoints(config) {
+        if (this.endpoints.length === 0) return;
+        if (!config.endpoints) config.endpoints = [];
+        // Seed from endpoints already on the config so each (method, path) registers
+        // once — across the levels' contributions AND anything already present (e.g.
+        // the plugin registered twice, or a host route at the same path).
+        const seen = new Set(config.endpoints.map(endpointKey));
+        for (const endpoint of this.endpoints){
+            const key = endpointKey(endpoint);
+            if (seen.has(key)) continue;
+            seen.add(key);
+            config.endpoints.push(endpoint);
+        }
+    }
+}
+
+//# sourceMappingURL=PluginConfigBuilder.js.map

package/dist/server/modules/translation-levels/collectionLevel.d.ts

@@ -0,0 +1,15 @@
+import type { TranslationLevel } from "./types";
+/**
+ * Bulk collection translation: a dashboard on the list view (translate many
+ * documents at once), backed by the same shared document-translation API as
+ * {@link documentLevel}.
+ *
+ * @since 0.5.0
+ * @returns An opaque {@link TranslationLevel} to list in `translatorPlugin({ levels })`.
+ * @example
+ * ```ts
+ * // Enable only bulk collection translation (no per-document popup):
+ * translatorPlugin({ collections: [Posts], translationProvider, runner, levels: [collectionLevel()] })
+ * ```
+ */
+export declare function collectionLevel(): TranslationLevel;

package/dist/server/modules/translation-levels/collectionLevel.js

@@ -0,0 +1,24 @@
+import { BulkDocumentTranslationDashboard } from "../../../client/widgets/bulk-translation-dashboard/ui/BulkTranslationDashboard.export";
+import { useDocTranslationApi } from "./useDocTranslationApi";
+/**
+ * Bulk collection translation: a dashboard on the list view (translate many
+ * documents at once), backed by the same shared document-translation API as
+ * {@link documentLevel}.
+ *
+ * @since 0.5.0
+ * @returns An opaque {@link TranslationLevel} to list in `translatorPlugin({ levels })`.
+ * @example
+ * ```ts
+ * // Enable only bulk collection translation (no per-document popup):
+ * translatorPlugin({ collections: [Posts], translationProvider, runner, levels: [collectionLevel()] })
+ * ```
+ */ export function collectionLevel() {
+    return {
+        extend (ctx) {
+            useDocTranslationApi(ctx);
+            ctx.addCollectionComponent("beforeListTable", ()=>new BulkDocumentTranslationDashboard(ctx.access));
+        }
+    };
+}
+
+//# sourceMappingURL=collectionLevel.js.map

package/dist/server/modules/translation-levels/documentLevel.d.ts

@@ -0,0 +1,19 @@
+import type { TranslationLevel } from "./types";
+/**
+ * Per-document translation: a popup control on the document edit view, backed by
+ * the shared document-translation API (async/job by default; synchronous if the
+ * configured `runner` is a sync runner).
+ *
+ * @since 0.5.0
+ * @returns An opaque {@link TranslationLevel} to list in `translatorPlugin({ levels })`.
+ * @example
+ * ```ts
+ * translatorPlugin({
+ *   collections: [Posts],
+ *   translationProvider,
+ *   runner: createPayloadJobsRunner(),
+ *   levels: [documentLevel(), collectionLevel()], // this is the default — omit for the same result
+ * })
+ * ```
+ */
+export declare function documentLevel(): TranslationLevel;