@focus-reactive/payload-plugin-translator 0.8.1 → 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/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)
  */

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

@@ -10,6 +10,27 @@ import { JobIdSchema, toClientErrorMessage } from "../../shared";
     collection_id: JobIdSchema,
     collection_slug: z.string().nonempty()
 });
+// A job is "newer" by creation time, tie-broken by last update — both ISO-8601, so a lexicographic
+// string compare is a correct chronological compare (no Date parsing needed).
+const isNewerTask = (candidate, current)=>candidate.createdAt !== current.createdAt ? candidate.createdAt > current.createdAt : candidate.updatedAt > current.updatedAt;
+/**
+ * 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 function latestTaskPerTargetLocale(tasks) {
+    const byLocale = new Map();
+    for (const task of tasks){
+        const current = byLocale.get(task.input.targetLng);
+        if (!current || isNewerTask(task, current)) byLocale.set(task.input.targetLng, task);
+    }
+    return [
+        ...byLocale.values()
+    ];
+}
 /**
  * Transforms a Task to API output format (snake_case for client compatibility)
  */ export function taskToJobStatusOutput(task) {

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

@@ -1,4 +1,8 @@
 import { normalizeJob } from "./normalizeJob";
+// A translation job's supersession identity: same document AND same target locale. IDs are
+// String()-normalized to match the stored (string) form, so a number id compares equal to its
+// persisted job.
+const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${targetLng}`;
 /**
  * TaskRunner implementation using Payload Jobs.
  *
@@ -15,8 +19,13 @@ import { normalizeJob } from "./normalizeJob";
         for (const [collectionSlug, items] of byCollection){
             const documentIds = items.map((t)=>t.collectionId);
             const existing = await this.findByCollection(collectionSlug, documentIds);
-            if (existing.length > 0) {
-                await this.cancelInternal(existing.map((t)=>t.id));
+            // Supersede only jobs for the SAME (document, target locale) being re-enqueued — never a
+            // concurrent job for a *different* locale of the same document. Cancelling per-document would
+            // kill an in-flight translation of another locale (the concurrent re-translate bug).
+            const supersededKeys = new Set(items.map((t)=>documentLocaleKey(t.collectionId, t.targetLng)));
+            const toCancel = existing.filter((t)=>supersededKeys.has(documentLocaleKey(t.input.collectionId, t.input.targetLng)));
+            if (toCancel.length > 0) {
+                await this.cancelInternal(toCancel.map((t)=>t.id));
             }
         }
         await Promise.all(tasks.map((task)=>this.payload.jobs.queue({

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

@@ -14,7 +14,7 @@
     }
     async enqueue(inputs) {
         for (const input of inputs){
-            const key = this.getKey(input.collectionSlug, input.collectionId);
+            const key = this.getKey(input.collectionSlug, input.collectionId, input.targetLng);
             const now = new Date().toISOString();
             const task = {
                 id: crypto.randomUUID(),
@@ -65,8 +65,10 @@
         }
         return results;
     }
-    getKey(collectionSlug, collectionId) {
-        return `${collectionSlug}:${collectionId}`;
+    // Keyed by (document, target locale) so translating a second locale of the same document does not
+    // evict the first — findByCollection must be able to return one task per locale.
+    getKey(collectionSlug, collectionId, targetLng) {
+        return `${collectionSlug}:${collectionId}:${targetLng}`;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@focus-reactive/payload-plugin-translator",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Translation plugin for Payload CMS 3.x. Automatically translate your localized content using any translation provider.",
   "type": "module",
   "license": "MIT",