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

package/dist/server/features/cancel/route.js

@@ -1,12 +1,12 @@
-import { withErrorHandler, withAccessCheck } from '../../shared';
-import { CancelHandler } from './handler';
+import { withErrorHandler, withAccessCheck } from "../../shared";
+import { CancelHandler } from "./handler";
 /**
  * Creates the batch cancel endpoint
- */ export function createCancelRoute(taskRunnerFactory, access, basePath = '/translate') {
+ */ export function createCancelRoute(taskRunnerFactory, access, basePath = "/translate") {
     const handler = new CancelHandler(taskRunnerFactory);
     return {
         path: `${basePath}/cancel`,
-        method: 'delete',
+        method: "delete",
         handler: withAccessCheck(withErrorHandler(handler.handle.bind(handler)), access)
     };
 }

package/dist/server/features/cancel-by-collection/handler.d.ts

@@ -1,12 +1,12 @@
 import type { PayloadRequest } from "payload";
-import type { TaskRunnerProvider } from "../../modules/task-runner";
-import type { CancelConfig } from './model';
+import type { TaskRunnerFactory } from "../../modules/task-runner";
+import type { CancelConfig } from "./model";
 /**
  * Cancels all pending translation tasks for a collection
  */
 export declare class CancelByCollectionHandler {
     private readonly config;
     private readonly taskRunnerFactory;
-    constructor(config: CancelConfig, taskRunnerFactory: TaskRunnerProvider);
+    constructor(config: CancelConfig, taskRunnerFactory: TaskRunnerFactory);
     handle(req: PayloadRequest): Promise<Response>;
 }

package/dist/server/features/cancel-by-collection/handler.js

@@ -1,6 +1,6 @@
 import { ServerResponse } from "../../shared";
 import { isCollectionAvailable } from "../_lib/collection-utils";
-import { CancelByCollectionInputSchema } from './model';
+import { CancelByCollectionInputSchema } from "./model";
 /**
  * Cancels all pending translation tasks for a collection
  */ export class CancelByCollectionHandler {

package/dist/server/features/cancel-by-collection/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 { CancelConfig } from './model';
+import type { Endpoint } from "payload";
+import type { AccessGuard } from "../../shared";
+import type { TaskRunnerFactory } from "../../modules/task-runner";
+import type { CancelConfig } from "./model";
 /**
  * Creates the cancel by collection endpoint
  */
-export declare function createCancelByCollectionRoute(config: CancelConfig, taskRunnerFactory: TaskRunnerProvider, access?: AccessGuard, basePath?: string): Endpoint;
+export declare function createCancelByCollectionRoute(config: CancelConfig, taskRunnerFactory: TaskRunnerFactory, access?: AccessGuard, basePath?: string): Endpoint;

package/dist/server/features/cancel-by-collection/route.js

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

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

@@ -0,0 +1,23 @@
+import type { CollectionSlug, Endpoint } from "payload";
+import type { AccessGuard } from "../shared";
+import type { TaskRunnerFactory } from "../modules/task-runner";
+export type TranslationRoutesDeps = {
+    taskRunnerFactory: TaskRunnerFactory;
+    /** Collections the plugin manages — gates which slugs the routes accept. */
+    collectionConfig: {
+        availableCollections: Set<CollectionSlug>;
+    };
+    access?: AccessGuard;
+    basePath?: string;
+};
+/**
+ * The translator's HTTP surface as one shared bundle: the 6 job-API endpoints
+ * (enqueue / run / cancel / cancel-by-collection / document-status /
+ * collection-status), all wired to the same runner factory and access guard.
+ *
+ * Extracted from the plugin's `init()` so registration is a single unit. The
+ * document and collection levels each contribute this bundle via the level
+ * context; the plugin deduplicates by method + path, so it registers exactly
+ * once. Behaviour-preserving: same endpoints, same order, same wiring.
+ */
+export declare function createTranslationRoutes({ taskRunnerFactory, collectionConfig, access, basePath }: TranslationRoutesDeps): Endpoint[];

package/dist/server/features/createTranslationRoutes.js

@@ -0,0 +1,27 @@
+import { createEnqueueRoute } from "./enqueue-translation";
+import { createRunRoute } from "./run-translation";
+import { createCancelRoute } from "./cancel";
+import { createCancelByCollectionRoute } from "./cancel-by-collection";
+import { createGetDocumentStatusRoute } from "./get-document-status";
+import { createGetCollectionStatusRoute } from "./get-collection-status";
+/**
+ * The translator's HTTP surface as one shared bundle: the 6 job-API endpoints
+ * (enqueue / run / cancel / cancel-by-collection / document-status /
+ * collection-status), all wired to the same runner factory and access guard.
+ *
+ * Extracted from the plugin's `init()` so registration is a single unit. The
+ * document and collection levels each contribute this bundle via the level
+ * context; the plugin deduplicates by method + path, so it registers exactly
+ * once. Behaviour-preserving: same endpoints, same order, same wiring.
+ */ export function createTranslationRoutes({ taskRunnerFactory, collectionConfig, access, basePath }) {
+    return [
+        createEnqueueRoute(taskRunnerFactory, collectionConfig, access, basePath),
+        createRunRoute(taskRunnerFactory, access, basePath),
+        createCancelRoute(taskRunnerFactory, access, basePath),
+        createCancelByCollectionRoute(collectionConfig, taskRunnerFactory, access, basePath),
+        createGetDocumentStatusRoute(collectionConfig, taskRunnerFactory, access, basePath),
+        createGetCollectionStatusRoute(collectionConfig, taskRunnerFactory, access, basePath)
+    ];
+}
+
+//# sourceMappingURL=createTranslationRoutes.js.map

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

@@ -1,12 +1,12 @@
 import type { PayloadRequest } from "payload";
-import type { TaskRunnerProvider } from "../../modules/task-runner";
-import type { EnqueueConfig } from './model';
+import type { TaskRunnerFactory } from "../../modules/task-runner";
+import type { EnqueueConfig } from "./model";
 /**
  * Enqueues translation tasks for documents
  */
 export declare class EnqueueTranslationHandler {
     private readonly config;
     private readonly taskRunnerFactory;
-    constructor(config: EnqueueConfig, taskRunnerFactory: TaskRunnerProvider);
+    constructor(config: EnqueueConfig, taskRunnerFactory: TaskRunnerFactory);
     handle(req: PayloadRequest): Promise<Response>;
 }

package/dist/server/features/enqueue-translation/handler.js

@@ -1,6 +1,6 @@
 import { ServerResponse } from "../../shared";
 import { isCollectionAvailable, getAllCollectionIds } from "../_lib/collection-utils";
-import { EnqueueInputSchema } from './model';
+import { EnqueueInputSchema } from "./model";
 /**
  * Enqueues translation tasks for documents
  */ export class EnqueueTranslationHandler {

package/dist/server/features/enqueue-translation/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 { EnqueueConfig } from './model';
+import type { Endpoint } from "payload";
+import type { AccessGuard } from "../../shared";
+import type { TaskRunnerFactory } from "../../modules/task-runner";
+import type { EnqueueConfig } from "./model";
 /**
  * Creates the enqueue translation endpoint
  */
-export declare function createEnqueueRoute(taskRunnerFactory: TaskRunnerProvider, config: EnqueueConfig, access?: AccessGuard, basePath?: string): Endpoint;
+export declare function createEnqueueRoute(taskRunnerFactory: TaskRunnerFactory, config: EnqueueConfig, access?: AccessGuard, basePath?: string): Endpoint;

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

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

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

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

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

@@ -1,6 +1,6 @@
 import { ServerResponse } from "../../shared";
 import { isCollectionAvailable } from "../_lib/collection-utils";
-import { GetCollectionStatusInputSchema } from './model';
+import { GetCollectionStatusInputSchema } from "./model";
 /**
  * Gets translation status for all documents in a collection
  */ export class GetCollectionStatusHandler {

package/dist/server/features/get-collection-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 { GetCollectionStatusConfig } from './model';
+import type { Endpoint } from "payload";
+import type { AccessGuard } from "../../shared";
+import type { TaskRunnerFactory } from "../../modules/task-runner";
+import type { GetCollectionStatusConfig } from "./model";
 /**
  * Creates the get collection status endpoint
  */
-export declare function createGetCollectionStatusRoute(config: GetCollectionStatusConfig, taskRunnerFactory: TaskRunnerProvider, access?: AccessGuard, basePath?: string): Endpoint;
+export declare function createGetCollectionStatusRoute(config: GetCollectionStatusConfig, taskRunnerFactory: TaskRunnerFactory, access?: AccessGuard, basePath?: string): Endpoint;

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/features/translate-field/resolveFieldSubtree.d.ts

@@ -0,0 +1,31 @@
+import type { Field } from "payload";
+/**
+ * Outcome of mapping a declared field path to a translatable subtree.
+ *
+ * - `resolved` — the path lands on a translatable leaf; `schema` + `sourceData`
+ *   are ready for `translateContent`, and `fieldName` is the key to unwrap the result.
+ * - `not-found` — the path resolves to no field at all (a typo) → caller returns 400.
+ * - `not-translatable` — resolves to a field that isn't a text-like leaf → caller no-ops.
+ * - `inside-blocks` — the path descends through a polymorphic `blocks` field, which
+ *   can't be resolved from the path alone (the blockType lives in the data) → caller no-ops.
+ */
+export type FieldSubtreeResolution = {
+    status: "resolved";
+    schema: Field[];
+    sourceData: Record<string, unknown>;
+    fieldName: string;
+} | {
+    status: "not-found";
+} | {
+    status: "not-translatable";
+} | {
+    status: "inside-blocks";
+};
+/**
+ * Map a declared `fieldPath` to the `{ schema, sourceData }` pair `translateContent` expects.
+ * Walks the schema by field name (via the shared {@link findFieldByPath}), dropping array indices
+ * (a field's config is shared across array items). Descends transparently through presentational
+ * containers (row, collapsible, unnamed tabs) and through named group/array/tab containers. A path
+ * that descends through a `blocks` field returns `inside-blocks`.
+ */
+export declare function resolveFieldSubtree(rootFields: Field[], fieldPath: string, value: unknown): FieldSubtreeResolution;

package/dist/server/features/translate-field/resolveFieldSubtree.js

@@ -0,0 +1,45 @@
+import { isTranslatableField } from "../../shared";
+import { findFieldByPath } from "../../shared/field-traversal";
+const isIndexSegment = (segment)=>/^\d+$/u.test(segment);
+/**
+ * Map a declared `fieldPath` to the `{ schema, sourceData }` pair `translateContent` expects.
+ * Walks the schema by field name (via the shared {@link findFieldByPath}), dropping array indices
+ * (a field's config is shared across array items). Descends transparently through presentational
+ * containers (row, collapsible, unnamed tabs) and through named group/array/tab containers. A path
+ * that descends through a `blocks` field returns `inside-blocks`.
+ */ export function resolveFieldSubtree(rootFields, fieldPath, value) {
+    const segments = fieldPath.split(".").map((segment)=>segment.trim()).filter((segment)=>segment.length > 0 && !isIndexSegment(segment));
+    if (segments.length === 0) return {
+        status: "not-found"
+    };
+    const result = findFieldByPath(rootFields, segments);
+    switch(result.status){
+        case "leaf":
+            return isTranslatableField(result.field) ? {
+                status: "resolved",
+                schema: [
+                    result.field
+                ],
+                sourceData: {
+                    [result.field.name]: value
+                },
+                fieldName: result.field.name
+            } : {
+                status: "not-translatable"
+            };
+        case "container":
+            return {
+                status: "not-translatable"
+            };
+        case "inside-blocks":
+            return {
+                status: "inside-blocks"
+            };
+        case "not-found":
+            return {
+                status: "not-found"
+            };
+    }
+}
+
+//# sourceMappingURL=resolveFieldSubtree.js.map

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);
 }