@focus-reactive/payload-plugin-translator 0.8.0 → 0.8.2

package/dist/client/entities/translation/api/queries/useDocumentTranslation.d.ts

@@ -9,7 +9,7 @@ type Options = {
 };
 export declare function useDocumentTranslation({ collection, id }: Props, options?: Options): {
     invalidate: () => void;
-    data: NoInfer<DocumentTranslation>;
+    data: NoInfer<DocumentTranslation[]>;
     error: Error;
     isError: true;
     isPending: false;
@@ -32,12 +32,12 @@ export declare function useDocumentTranslation({ collection, id }: Props, option
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation[]>, Error>>;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    promise: Promise<NoInfer<DocumentTranslation>>;
+    promise: Promise<NoInfer<DocumentTranslation[]>>;
 } | {
     invalidate: () => void;
-    data: NoInfer<DocumentTranslation>;
+    data: NoInfer<DocumentTranslation[]>;
     error: null;
     isError: false;
     isPending: false;
@@ -60,9 +60,9 @@ export declare function useDocumentTranslation({ collection, id }: Props, option
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation[]>, Error>>;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    promise: Promise<NoInfer<DocumentTranslation>>;
+    promise: Promise<NoInfer<DocumentTranslation[]>>;
 } | {
     invalidate: () => void;
     data: undefined;
@@ -88,9 +88,9 @@ export declare function useDocumentTranslation({ collection, id }: Props, option
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation[]>, Error>>;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    promise: Promise<NoInfer<DocumentTranslation>>;
+    promise: Promise<NoInfer<DocumentTranslation[]>>;
 } | {
     invalidate: () => void;
     data: undefined;
@@ -116,9 +116,9 @@ export declare function useDocumentTranslation({ collection, id }: Props, option
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation[]>, Error>>;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    promise: Promise<NoInfer<DocumentTranslation>>;
+    promise: Promise<NoInfer<DocumentTranslation[]>>;
 } | {
     invalidate: () => void;
     data: undefined;
@@ -144,12 +144,12 @@ export declare function useDocumentTranslation({ collection, id }: Props, option
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation[]>, Error>>;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    promise: Promise<NoInfer<DocumentTranslation>>;
+    promise: Promise<NoInfer<DocumentTranslation[]>>;
 } | {
     invalidate: () => void;
-    data: NoInfer<DocumentTranslation>;
+    data: NoInfer<DocumentTranslation[]>;
     isError: false;
     error: null;
     isPending: false;
@@ -172,8 +172,8 @@ export declare function useDocumentTranslation({ collection, id }: Props, option
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation>, Error>>;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<NoInfer<DocumentTranslation[]>, Error>>;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    promise: Promise<NoInfer<DocumentTranslation>>;
+    promise: Promise<NoInfer<DocumentTranslation[]>>;
 };
 export {};

package/dist/client/entities/translation/api/queries/useDocumentTranslation.js

@@ -26,12 +26,16 @@ export function useDocumentTranslation({ collection, id }, options) {
                     method: "get",
                     signal
                 });
-                return response.data;
+                // Normalize to an array defensively: a stale admin tab from before the object→array response
+                // change (deploy skew) would otherwise feed a non-array here and break the polling callback.
+                return Array.isArray(response.data) ? response.data : [];
             });
         },
         enabled: options?.enabled,
+        // Keep polling while any locale's job is still in flight; stop once every job is terminal.
         refetchInterval: (query)=>{
-            return query.state.data?.status === "failed" || query.state.data?.status === "completed" ? false : POLLING_INTERVAL_MILLISECONDS;
+            const active = (query.state.data ?? []).some((job)=>job.status === "pending" || job.status === "running");
+            return active ? POLLING_INTERVAL_MILLISECONDS : false;
         }
     });
     const invalidate = useCallback(()=>{
@@ -49,23 +53,35 @@ export function useDocumentTranslation({ collection, id }, options) {
     // When a queued (async) translation transitions to "completed" in-session, the provenance
     // record's sourceFingerprint has just been updated server-side — invalidate staleness so the
     // "Out of date" notice clears without waiting for the next focus/remount refetch (#50).
-    // Seeded lazily (undefined) and gated on a *defined, non-completed → completed* transition, so a
-    // cold mount of an already-completed document does NOT fire a spurious extra refetch.
-    const previousStatusRef = useRef(undefined);
+    // Tracked as a *set* of completed target locales (the feed is now per-locale): fire whenever a
+    // locale newly reaches "completed". The snapshot is tagged with the document key and reset when
+    // the document changes, so a cold mount of an already-completed document — or navigating to a
+    // different document within the same component instance — does NOT fire a spurious extra refetch.
+    const docKey = `${collection}:${id}`;
+    const previousCompletedRef = useRef(undefined);
     useEffect(()=>{
-        const previousStatus = previousStatusRef.current;
-        const currentStatus = query.data?.status;
-        if (currentStatus === "completed" && previousStatus !== undefined && previousStatus !== "completed") {
+        const jobs = query.data;
+        if (!jobs) return;
+        const completed = new Set(jobs.filter((job)=>job.status === "completed").map((job)=>job.input.target_lng));
+        const previous = previousCompletedRef.current;
+        const sameDoc = previous?.docKey === docKey;
+        if (sameDoc && [
+            ...completed
+        ].some((locale)=>!previous.locales.has(locale))) {
             queryClient.invalidateQueries({
                 queryKey: [
                     DOCUMENT_STALENESS_QUERY_KEY
                 ]
             });
         }
-        previousStatusRef.current = currentStatus;
+        previousCompletedRef.current = {
+            docKey,
+            locales: completed
+        };
     }, [
-        query.data?.status,
-        queryClient
+        query.data,
+        queryClient,
+        docKey
     ]);
     return {
         ...query,

package/dist/client/entities/translation/index.d.ts

@@ -19,7 +19,7 @@ export declare const TranslationsApi: {
 };
 export type { DocumentTranslation, DocumentTranslationCompleted, DocumentTranslationFailed, DocumentTranslationPending, DocumentTranslationRunning, CollectionTranslationStatus, CollectionTranslationStatusItem, GroupedCollectionTranslationStatus, DocumentStaleness, StalenessLocale, } from "./model/types";
 export { DocumentTranslationStatus } from "./model/enums";
-export { derivePanelStatus, deriveCollectionPanelStatus, describePanelStatus, } from "./model/panelStatus";
+export { derivePanelStatus, deriveCollectionPanelStatus, deriveDocumentRunStatus, describePanelStatus, } from "./model/panelStatus";
 export type { PanelStatus, MarkerTone } from "./model/panelStatus";
 export { PanelStatusMarker } from "./ui/PanelStatusMarker";
 export { ActionButton } from "./ui/ActionButton";

package/dist/client/entities/translation/index.js

@@ -18,7 +18,7 @@ export const TranslationsApi = {
     useDismissStaleness
 };
 export { DocumentTranslationStatus } from "./model/enums";
-export { derivePanelStatus, deriveCollectionPanelStatus, describePanelStatus } from "./model/panelStatus";
+export { derivePanelStatus, deriveCollectionPanelStatus, deriveDocumentRunStatus, describePanelStatus } from "./model/panelStatus";
 export { PanelStatusMarker } from "./ui/PanelStatusMarker";
 export { ActionButton } from "./ui/ActionButton";
 export { buildTranslationStatusRows } from "./model/statusRows";

package/dist/client/entities/translation/model/panelStatus.d.ts

@@ -1,6 +1,6 @@
 import { DocumentTranslationStatus } from "./enums";
 import type { StatusDotColor } from "./statusRows";
-import type { GroupedCollectionTranslationStatus } from "./types";
+import type { DocumentTranslation, GroupedCollectionTranslationStatus } from "./types";
 /**
  * The single aggregate signal shown on a translate trigger (document or collection). Detail lives in
  * the popup; the panel only surfaces the most urgent state at a glance (see the panel-UI design doc).
@@ -37,8 +37,14 @@ export declare function describePanelStatus(status: PanelStatus | undefined, fal
     tone?: MarkerTone;
     title: string;
 };
+/**
+ * Collapse the per-locale job feed into the single most-urgent run status for the trigger marker.
+ * Returns `undefined` when there are no jobs. The panel shows one aggregate signal; the popup's list
+ * carries the full per-locale detail.
+ */
+export declare function deriveDocumentRunStatus(runs: DocumentTranslation[] | undefined): DocumentTranslationStatus | undefined;
 type PanelStatusInput = {
-    /** Status of the latest translation job, if any. */
+    /** Status of the most-urgent translation job across locales, if any (see `deriveDocumentRunStatus`). */
     runStatus?: DocumentTranslationStatus | null;
     /** Target locales whose translation is out of date (from staleness detection). */
     staleLocales: string[];

package/dist/client/entities/translation/model/panelStatus.js

@@ -50,6 +50,22 @@ import { DocumentTranslationStatus } from "./enums";
             };
     }
 }
+// The most-urgent job status wins the single aggregate marker, in the order `derivePanelStatus`
+// itself ranks them: a failure to surface, then in-flight work, then a queued job, then completed.
+const RUN_STATUS_PRIORITY = [
+    DocumentTranslationStatus.FAILED,
+    DocumentTranslationStatus.RUNNING,
+    DocumentTranslationStatus.PENDING,
+    DocumentTranslationStatus.COMPLETED
+];
+/**
+ * Collapse the per-locale job feed into the single most-urgent run status for the trigger marker.
+ * Returns `undefined` when there are no jobs. The panel shows one aggregate signal; the popup's list
+ * carries the full per-locale detail.
+ */ export function deriveDocumentRunStatus(runs) {
+    const present = new Set(runs?.map((run)=>run.status));
+    return RUN_STATUS_PRIORITY.find((status)=>present.has(status));
+}
 /**
  * Collapse the latest run status + per-locale staleness into one panel marker, by priority:
  * `failed → running → stale → fresh → none`. A more urgent transient state (a failed or in-flight

package/dist/client/entities/translation/model/statusRows.d.ts

@@ -29,14 +29,17 @@ export declare const STATE_DOT: Record<TranslationRowState, {
     animated?: boolean;
 }>;
 /**
- * Build the unified status rows from per-locale staleness + the single latest job.
+ * Build the unified status rows from per-locale staleness + the latest job per target locale.
  *
- * Rows come from `staleness.locales` (one per translated target: `stale` or `translated`). The latest
- * job is overlaid onto its target locale: a **transient** job state (failed/running/pending) wins over
- * the durable signal for that locale, and a job for a target with no provenance row yet adds a row.
- * Sorted `failed → running → pending → stale → translated`, newest first within a group.
+ * Rows come from `staleness.locales` (one per translated target: `stale` or `translated`). Each job in
+ * `runs` (one per target locale — see `useDocumentTranslation`) is overlaid onto its target locale: a
+ * **transient** job state (failed/running/pending) wins over the durable signal for that locale, and a
+ * job for a target with no provenance row yet adds a row. Overlaying *every* job (not just one) is what
+ * lets several concurrent re-translations each show their own live state instead of the last one
+ * appearing to overwrite the rest. Sorted by the fixed source→target locale pair (not by state), so a
+ * row keeps its place when its state changes — re-translating a locale never reorders the list.
  */
 export declare function buildTranslationStatusRows(input: {
     staleness?: DocumentStaleness | null;
-    run?: DocumentTranslation;
+    runs?: DocumentTranslation[];
 }): TranslationStatusRow[];

package/dist/client/entities/translation/model/statusRows.js

@@ -20,32 +20,30 @@
         color: "green"
     }
 };
-// Most urgent first. Transient job states outrank the durable stale/translated signal.
-const ORDER = {
-    failed: 0,
-    running: 1,
-    pending: 2,
-    stale: 3,
-    translated: 4
-};
 const TRANSIENT = new Set([
     "failed",
     "running",
     "pending"
 ]);
+// A row's permanent identity for ordering: the source→target locale pair (unique per row, never
+// changes when the row's state does).
+const localePairKey = (row)=>`${row.sourceLocale}:${row.targetLocale}`;
 // Maps the closed 4-member job-status set to a row state. "completed" → "translated"; the transient
 // three pass through. If a new DocumentTranslationStatus is ever added, extend this explicitly —
 // otherwise it would silently render as "translated".
 const toRowState = (jobStatus)=>jobStatus === "failed" || jobStatus === "running" || jobStatus === "pending" ? jobStatus : "translated";
 /**
- * Build the unified status rows from per-locale staleness + the single latest job.
+ * Build the unified status rows from per-locale staleness + the latest job per target locale.
  *
- * Rows come from `staleness.locales` (one per translated target: `stale` or `translated`). The latest
- * job is overlaid onto its target locale: a **transient** job state (failed/running/pending) wins over
- * the durable signal for that locale, and a job for a target with no provenance row yet adds a row.
- * Sorted `failed → running → pending → stale → translated`, newest first within a group.
+ * Rows come from `staleness.locales` (one per translated target: `stale` or `translated`). Each job in
+ * `runs` (one per target locale — see `useDocumentTranslation`) is overlaid onto its target locale: a
+ * **transient** job state (failed/running/pending) wins over the durable signal for that locale, and a
+ * job for a target with no provenance row yet adds a row. Overlaying *every* job (not just one) is what
+ * lets several concurrent re-translations each show their own live state instead of the last one
+ * appearing to overwrite the rest. Sorted by the fixed source→target locale pair (not by state), so a
+ * row keeps its place when its state changes — re-translating a locale never reorders the list.
  */ export function buildTranslationStatusRows(input) {
-    const { staleness, run } = input;
+    const { staleness, runs } = input;
     const byTarget = new Map();
     for (const locale of staleness?.locales ?? []){
         byTarget.set(locale.target_lng, {
@@ -55,7 +53,7 @@ const toRowState = (jobStatus)=>jobStatus === "failed" || jobStatus === "running
             at: locale.translated_at
         });
     }
-    if (run) {
+    for (const run of runs ?? []){
         const state = toRowState(run.status);
         const target = run.input.target_lng;
         const existing = byTarget.get(target);
@@ -71,9 +69,13 @@ const toRowState = (jobStatus)=>jobStatus === "failed" || jobStatus === "running
             });
         }
     }
+    // Stable order by the source→target locale pair — the one thing about a row that never changes when
+    // its state does. Sorting by state/time instead would make a row jump (e.g. to the top) the moment
+    // you re-translate it; the locale pair keeps every row in a fixed place, and progress is conveyed by
+    // the badge/dot, not the position. The pair is unique (one row per target), so no tie-break needed.
     return [
         ...byTarget.values()
-    ].sort((a, b)=>ORDER[a.state] - ORDER[b.state] || (b.at ?? "").localeCompare(a.at ?? ""));
+    ].sort((a, b)=>localePairKey(a).localeCompare(localePairKey(b)));
 }
 
 //# sourceMappingURL=statusRows.js.map

package/dist/client/entities/translation/model/types.d.ts

@@ -35,7 +35,12 @@ export type DocumentTranslationCompleted = {
     completed_at: string;
     input: InputData;
 };
-export type DocumentTranslation = DocumentTranslationCompleted | DocumentTranslationRunning | DocumentTranslationFailed | DocumentTranslationPending | null;
+/**
+ * One translation job for a single target locale. The document status feed is an array of these —
+ * the latest job per target locale (see `useDocumentTranslation`), because re-translate queues an
+ * independent job per locale.
+ */
+export type DocumentTranslation = DocumentTranslationCompleted | DocumentTranslationRunning | DocumentTranslationFailed | DocumentTranslationPending;
 export type CollectionTranslationStatusItem = {
     id: string;
     status: DocumentTranslationStatus;

package/dist/client/widgets/translate-document/ui/TranslateDocument.js

@@ -2,7 +2,7 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { toast, useLocale } from "@payloadcms/ui";
 import { useEffect, useMemo } from "react";
-import { buildTranslationStatusRows, derivePanelStatus, TranslationsApi, TranslationStatusList } from "../../../entities/translation";
+import { buildTranslationStatusRows, deriveDocumentRunStatus, derivePanelStatus, TranslationsApi, TranslationStatusList } from "../../../entities/translation";
 import { OpenDocumentTranslationPopup } from "../../../features/open-document-translation-popup";
 import { DocumentTranslationForm, FORM_FIELDS } from "../../../features/translate-document-form";
 import { DocumentTranslationFormModel } from "../../../features/translate-document-form/index.client";
@@ -27,15 +27,15 @@ const TranslateDocument = ({ hasDrafts })=>{
     ]);
     // The panel trigger shows one aggregate marker; the popup shows the full per-locale list.
     const panelStatus = useMemo(()=>derivePanelStatus({
-            runStatus: data?.status,
+            runStatus: deriveDocumentRunStatus(data),
             staleLocales
         }), [
-        data?.status,
+        data,
         staleLocales
     ]);
     const statusRows = useMemo(()=>buildTranslationStatusRows({
             staleness,
-            run: data
+            runs: data
         }), [
         staleness,
         data

package/dist/composition/levels/useDocTranslationApi.d.ts

@@ -3,7 +3,7 @@ import type { LevelContext } from "../../server/modules/translation-levels";
  * Contribute the runner-agnostic document-translation API — the shared route
  * bundle, bound to the level context's runner. Both `documentLevel` and
  * `collectionLevel` call this; the plugin deduplicates the endpoints by method +
- * path, so the bundle registers exactly once. The schema map and provenance
- * store factory ride along for the staleness endpoints.
+ * path, so the bundle registers exactly once. The provenance service factory
+ * rides along for the staleness endpoints (its schema lives inside the service).
  */
 export declare function useDocTranslationApi(ctx: LevelContext): void;

package/dist/composition/levels/useDocTranslationApi.js

@@ -3,8 +3,8 @@ import { createTranslationRoutes } from "../../server/features/createTranslation
  * Contribute the runner-agnostic document-translation API — the shared route
  * bundle, bound to the level context's runner. Both `documentLevel` and
  * `collectionLevel` call this; the plugin deduplicates the endpoints by method +
- * path, so the bundle registers exactly once. The schema map and provenance
- * store factory ride along for the staleness endpoints.
+ * path, so the bundle registers exactly once. The provenance service factory
+ * rides along for the staleness endpoints (its schema lives inside the service).
  */ export function useDocTranslationApi(ctx) {
     ctx.addEndpoints(createTranslationRoutes({
         taskRunnerFactory: ctx.taskRunnerFactory,
@@ -13,8 +13,7 @@ import { createTranslationRoutes } from "../../server/features/createTranslation
         },
         access: ctx.access,
         basePath: ctx.basePath,
-        schemaMap: ctx.schemaMap,
-        provenanceStoreFactory: ctx.provenanceStoreFactory
+        provenanceServiceFactory: ctx.provenanceServiceFactory
     }));
 }
 

package/dist/plugin.js

@@ -1,19 +1,9 @@
 import { CacheProviderExport } from "./client/app/cache/CacheProvider.export";
-import { DEFAULT_PROVENANCE_SLUG, PayloadProvenanceStore, assertProvenanceSlugFree, injectProvenanceCleanup, isProvenanceCollection, makeProvenanceCollection } from "./server/modules/provenance";
-import { TranslateDocumentHandler } from "./server/features/translate-document";
-import { LifecycleNotifier, taskFromHandlerInput, withQueuedNotification } from "./server/modules/lifecycle";
+import { configureProvenance } from "./server/modules/provenance";
+import { wireTranslateRunner } from "./server/features/translate-document";
 import { documentLevel, collectionLevel } from "./composition/levels";
 import { PluginConfigBuilder } from "./server/modules/translation-levels/PluginConfigBuilder";
 import { normalizePath } from "./server/shared";
-/**
- * Resolve the opt-in `provenance` config to a sidecar slug, or `null` when disabled.
- * `false`/omitted → off; `true` or `{}` → on with the default slug; `{ slug }` → on with that slug.
- */ function resolveProvenanceSlug(provenance) {
-    if (!provenance) return null;
-    if (provenance === true) return DEFAULT_PROVENANCE_SLUG;
-    // `||` (not `??`) so an empty/blank slug falls back to the default instead of silently disabling.
-    return provenance.slug || DEFAULT_PROVENANCE_SLUG;
-}
 /** @deprecated Use `translatorPlugin` function instead */ export class TranslateCollectionPlugin {
     pluginConfig;
     constructor(pluginConfig){
@@ -22,61 +12,30 @@ import { normalizePath } from "./server/shared";
     init() {
         return async (config)=>{
             const { access, translationProvider, runner, collections, levels, provenance, lifecycle, basePath: rawBasePath = "/translate" } = this.pluginConfig;
-            const lifecycleCallbacks = lifecycle ?? {};
-            // Build schema map from deep-cloned collections
-            // Deep clone is required because Payload mutates the original collection objects,
-            // removing `localized: true` from nested fields during sanitization.
-            // We use JSON round-trip instead of structuredClone because Lexical editor
-            // configs contain async functions that structuredClone cannot handle.
-            // TODO: Consider introducing a FieldLike interface with only the properties
-            // used by the pipeline (name, type, localized, fields, blocks, tabs, custom)
-            // to make the contract explicit and avoid reliance on JSON round-trip.
+            // Build schema map from deep-cloned collections.
+            // Deep clone is required because Payload mutates the original collection objects, removing
+            // `localized: true` from nested fields during sanitization. JSON round-trip (not
+            // structuredClone) because Lexical editor configs contain async functions structuredClone
+            // cannot handle.
+            // TODO: Consider introducing a FieldLike interface with only the properties used by the
+            // pipeline (name, type, localized, fields, blocks, tabs, custom) to make the contract explicit
+            // and avoid reliance on JSON round-trip.
             const schemaMap = new Map(collections.map((col)=>[
                     col.slug,
                     JSON.parse(JSON.stringify(col.fields))
                 ]));
             const collectionSlugs = new Set(schemaMap.keys());
             const basePath = normalizePath(rawBasePath);
-            const provenanceSlug = resolveProvenanceSlug(provenance);
-            if (provenanceSlug) {
-                const existing = (config.collections ?? []).filter((collection)=>!isProvenanceCollection(collection));
-                assertProvenanceSlugFree(provenanceSlug, existing);
-            }
-            const provenanceStoreFactory = provenanceSlug ? (p)=>new PayloadProvenanceStore(p, provenanceSlug) : undefined;
-            const translateHandler = new TranslateDocumentHandler(translationProvider, schemaMap, provenanceStoreFactory);
-            const runnerContext = {
-                handler: async (payload, input)=>{
-                    const notifier = new LifecycleNotifier(lifecycleCallbacks, payload.logger);
-                    const task = taskFromHandlerInput(input);
-                    try {
-                        await translateHandler.handle(payload, {
-                            collection: input.collection,
-                            collectionId: input.collectionId,
-                            sourceLng: input.sourceLng,
-                            targetLng: input.targetLng,
-                            strategy: input.strategy,
-                            publishOnTranslation: input.publishOnTranslation
-                        });
-                    } catch (error) {
-                        await notifier.failed(task, error);
-                        throw error; // rethrow so the runner marks the job failed
-                    }
-                    await notifier.completed(task);
-                },
+            // Each concern owns its own config-time wiring and exposes it uniformly; init() just composes.
+            const provenanceModule = configureProvenance(provenance, schemaMap);
+            const { taskRunnerFactory, configModifier: runnerConfigModifier } = wireTranslateRunner({
+                translationProvider,
+                schemaMap,
+                provenanceServiceFactory: provenanceModule.serviceFactory,
+                runner,
+                lifecycle: lifecycle ?? {},
                 collections: Array.from(collectionSlugs)
-            };
-            const runnerConfigModifier = runner.configure(runnerContext);
-            // Bind the context once so routes receive a self-sufficient factory: the
-            // runner needs no mutable per-instance handler state and create() has no
-            // "configure() must run first" ordering coupling (translator plan, 0c).
-            // When an `onQueued` callback is set, decorate the runner so `enqueue` fires it.
-            const taskRunnerFactory = {
-                create: (payload)=>{
-                    const taskRunner = runner.create(payload, runnerContext.handler);
-                    if (!lifecycleCallbacks.onQueued) return taskRunner;
-                    return withQueuedNotification(taskRunner, new LifecycleNotifier(lifecycleCallbacks, payload.logger));
-                }
-            };
+            });
             const activeLevels = levels ?? [
                 documentLevel(),
                 collectionLevel()
@@ -88,23 +47,11 @@ import { normalizePath } from "./server/shared";
                 taskRunnerFactory,
                 schemaMap,
                 translationProvider,
-                provenanceStoreFactory
+                provenanceServiceFactory: provenanceModule.serviceFactory
             });
             for (const level of activeLevels)level.extend(builder);
             builder.addConfigModifier(runnerConfigModifier);
-            if (provenanceSlug && provenanceStoreFactory) {
-                builder.addConfigModifier((cfg)=>{
-                    const alreadyAdded = cfg.collections?.some((collection)=>collection.slug === provenanceSlug && isProvenanceCollection(collection));
-                    if (!alreadyAdded) {
-                        cfg.collections = [
-                            ...cfg.collections ?? [],
-                            makeProvenanceCollection(provenanceSlug)
-                        ];
-                    }
-                    injectProvenanceCleanup(cfg, collectionSlugs, provenanceStoreFactory, provenanceSlug);
-                    return cfg;
-                });
-            }
+            builder.addConfigModifier(provenanceModule.configure(collectionSlugs));
             builder.addAdminProvider(new CacheProviderExport(basePath));
             // The single place the Payload config is mutated.
             return builder.applyTo(config);

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

@@ -1,20 +1,11 @@
 import type { CollectionSlug, Endpoint } from "payload";
-import type { AccessGuard } from "../shared";
-import type { TaskRunnerFactory } from "../modules/task-runner";
-import type { CollectionSchemaMap } from "../../types/CollectionSchemaMap";
-import type { ProvenanceStoreFactory } from "../modules/provenance";
-export type TranslationRoutesDeps = {
-    taskRunnerFactory: TaskRunnerFactory;
+import type { TranslationContext } from "../modules/translation-levels";
+export type TranslationRoutesDeps = Pick<TranslationContext, "taskRunnerFactory" | "access" | "provenanceServiceFactory"> & {
     /** Collections the plugin manages — gates which slugs the routes accept. */
     collectionConfig: {
         availableCollections: Set<CollectionSlug>;
     };
-    access?: AccessGuard;
     basePath?: string;
-    /** Original per-collection field schema — needed to recompute source fingerprints for staleness. */
-    schemaMap: CollectionSchemaMap;
-    /** Builds a provenance store; absent when provenance is disabled (staleness then reports empty). */
-    provenanceStoreFactory?: ProvenanceStoreFactory;
 };
 /**
  * The translator's HTTP surface as one shared bundle: the job-API endpoints
@@ -26,6 +17,6 @@ export type TranslationRoutesDeps = {
  * document and collection levels each contribute this bundle via the level
  * context; the plugin deduplicates by method + path, so it registers exactly
  * once. The staleness endpoints always register; when provenance is disabled
- * (`provenanceStoreFactory` absent) they simply report no staleness.
+ * (`provenanceServiceFactory` absent) they simply report no staleness.
  */
-export declare function createTranslationRoutes({ taskRunnerFactory, collectionConfig, access, basePath, schemaMap, provenanceStoreFactory, }: TranslationRoutesDeps): Endpoint[];
+export declare function createTranslationRoutes({ taskRunnerFactory, collectionConfig, access, basePath, provenanceServiceFactory, }: TranslationRoutesDeps): Endpoint[];

package/dist/server/features/createTranslationRoutes.js

@@ -15,12 +15,11 @@ import { createGetDocumentStalenessRoute, createDismissStalenessRoute } from "./
  * document and collection levels each contribute this bundle via the level
  * context; the plugin deduplicates by method + path, so it registers exactly
  * once. The staleness endpoints always register; when provenance is disabled
- * (`provenanceStoreFactory` absent) they simply report no staleness.
- */ export function createTranslationRoutes({ taskRunnerFactory, collectionConfig, access, basePath, schemaMap, provenanceStoreFactory }) {
+ * (`provenanceServiceFactory` absent) they simply report no staleness.
+ */ export function createTranslationRoutes({ taskRunnerFactory, collectionConfig, access, basePath, provenanceServiceFactory }) {
     const stalenessConfig = {
         availableCollections: collectionConfig.availableCollections,
-        schemaMap,
-        provenanceStoreFactory
+        provenanceServiceFactory
     };
     return [
         createEnqueueRoute(taskRunnerFactory, collectionConfig, access, basePath),

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, latestTaskPerTargetLocale, taskToJobStatusOutput } from "./model";
 /**
  * Gets the translation status for a specific document
  */ export class GetDocumentStatusHandler {
@@ -20,7 +20,9 @@ import { GetDocumentStatusInputSchema, taskToJobStatusOutput } from "./model";
         const tasks = await runner.findByCollection(collectionSlug, [
             collection_id
         ]);
-        return ServerResponse.success(tasks[0] ? taskToJobStatusOutput(tasks[0]) : null);
+        // One job per target locale (latest), not a single job for the whole document — re-translate
+        // queues an independent job per locale, and the status panel renders a row per locale.
+        return ServerResponse.success(latestTaskPerTargetLocale(tasks).map(taskToJobStatusOutput));
     }
 }
 

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

@@ -56,6 +56,16 @@ export type JobStatusOutput = {
 export type GetDocumentStatusConfig = {
     availableCollections: Set<CollectionSlug>;
 };
+/**
+ * Reduce a document's jobs to the latest one per target locale.
+ *
+ * `findByCollection` returns every job for the document across all target locales (plus any superseded
+ * jobs not yet cancelled). The status panel shows one row per target locale, so we keep — per
+ * `targetLng` — the most recently created job (tie-break: most recently updated). Without this the
+ * caller sees a single arbitrary job and every other in-flight locale looks idle, which is the
+ * concurrent re-translate bug (a second re-translate appearing to overwrite the first's status).
+ */
+export declare function latestTaskPerTargetLocale(tasks: Task[]): Task[];
 /**
  * Transforms a Task to API output format (snake_case for client compatibility)
  */