@focus-reactive/payload-plugin-translator 0.11.0 → 0.11.2

package/README.md

@@ -205,6 +205,45 @@ translatorPlugin({
 });
 ```
 
+### Drafts and publishing
+
+Applies to every way a translation is triggered — the admin controls, `POST /translate/enqueue`, and
+auto-translate. It matters most if your collections have `versions.drafts` enabled.
+
+**Without publish-on-translation**, the translation is written as a **draft version**. The document's
+published state is left alone: a live page stays live, an unpublished one stays unpublished, and the
+translated locale does not appear on the public site until someone publishes it.
+
+**With publish-on-translation**, the translation is written as a draft and the target locale is then
+published — a separate step, so it happens whether or not any field actually needed translating.
+Only the locale that was translated is published; other locales keep whatever state they were in.
+Translating a document that is not currently published does make the document live, with just that
+locale's content in it.
+
+A translation is taken from **the source locale's own current content** — the newer draft when one
+exists, else the published row, never a value Payload substitutes from another locale. Translating
+*from* a locale you have not filled in therefore translates nothing.
+
+Two consequences worth knowing before you rely on them:
+
+- **Publishing publishes the current draft, whatever is in it.** A translation is based on the
+  version the editor sees, and publishing puts that live — including pending edits nobody made for
+  the translation's sake, and including non-localized fields, which Payload stores once per document
+  and so cannot scope to a locale. That is what the flag asks for, but it is worth remembering
+  before running "translate and publish" over a long list of documents: every unpublished draft
+  among them goes live.
+- **`skip_existing` counts anything non-empty as translated.** A translation waiting unpublished in
+  a draft counts, so a reviewer's corrected text is published as it stands rather than
+  re-translated. It has no notion of *reviewed*, and it does not consult stale-detection — a locale
+  the admin marks out of date is still skipped
+  ([#118](https://github.com/focusreactive/payload-plugins/issues/118)).
+
+> **Changed in 0.11.1.** Before this, translating one locale as a draft unpublished the document in
+> every locale, and translating one locale with publishing pushed every other locale's unpublished
+> draft live ([#102](https://github.com/focusreactive/payload-plugins/issues/102)). The source was
+> also read from the published row with fallbacks, so translating from an empty locale translated
+> the default locale's text.
+
 ### Stale-translation detection
 
 _Since v0.8.0._
@@ -221,6 +260,10 @@ Dismiss acknowledges the drift without re-translating; the marker stays hidden u
 changes again. When `provenance` is disabled nothing is shown. Note the fingerprint is text-only, so
 formatting-only edits to rich text do not mark a locale stale.
 
+> **Upgrading to 0.11.1.** Records written earlier fingerprinted the source differently, so a locale
+> can read out of date once after upgrading with nothing actually needing re-translation. Dismissing
+> the marker or re-translating settles it.
+
 ### Auto-translate on source change
 
 _Since v0.9.0._
@@ -249,9 +292,12 @@ translatorPlugin({
 Behaviour: fires only on a **published** source save (draft/autosave saves are ignored; a collection
 without drafts treats every save as published); skips when no translatable content actually changed
 (same fingerprint as stale-detection); coalesces rapid edits via `debounceMs`; the translation is saved
-with the source document's status (published source → published translation); never re-triggers on its
+with the source document's status, scoped to **only the translated locale**; never re-triggers on its
 own translation writes; and never fails the editor's save (best-effort — failures are logged).
 
+> See [Drafts and publishing](#drafts-and-publishing) for what a translation does to a document's
+> published state.
+
 > **Requires a working job runner.** Auto-translate only **enqueues** jobs — they run via the task
 > runner (`createPayloadJobsRunner`) and its autorun loop. On serverless platforms such as **Vercel**,
 > cron-based autorun may not run automatically, so enqueued translations can sit unexecuted until

package/dist/client/widgets/bulk-translation-dashboard/ui/BulkTranslationDashboard.server.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { headers as getHeaders } from "next/headers";
-import { collectionHasDrafts } from "../../../../server/shared/guards";
+import { hasDraftsEnabled } from "payload/shared";
 import { resolveAutoTranslateSummary } from "../../../entities/translation/model/autoTranslateSummary";
 import BulkTranslationDashboard from "./BulkTranslationDashboard";
 const BulkTranslationDashboardServer = async (props)=>{
@@ -15,7 +15,7 @@ const BulkTranslationDashboardServer = async (props)=>{
     if (!hasAccess) return null;
     if (!props.collectionSlug) return null;
     const collection = props.payload.collections[props.collectionSlug]?.config;
-    const hasDrafts = collection ? collectionHasDrafts(collection) : false;
+    const hasDrafts = collection ? hasDraftsEnabled(collection) : false;
     const autoTranslate = resolveAutoTranslateSummary(collection, props.payload.config.localization ? props.payload.config.localization.defaultLocale : undefined);
     return /*#__PURE__*/ _jsx(BulkTranslationDashboard, {
         hasDrafts: hasDrafts,

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

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { headers as getHeaders } from "next/headers";
-import { collectionHasDrafts } from "../../../../server/shared/guards";
+import { hasDraftsEnabled } from "payload/shared";
 import { resolveAutoTranslateSummary } from "../../../entities/translation/model/autoTranslateSummary";
 import TranslateDocument from "./TranslateDocument";
 async function TranslateDocumentServer(props) {
@@ -14,7 +14,7 @@ async function TranslateDocumentServer(props) {
     });
     if (!hasAccess) return null;
     if (!props.id) return null;
-    const hasDrafts = collectionHasDrafts(props.collection);
+    const hasDrafts = hasDraftsEnabled(props.collection);
     const autoTranslate = resolveAutoTranslateSummary(props.collection, props.payload.config.localization ? props.payload.config.localization.defaultLocale : undefined);
     return /*#__PURE__*/ _jsx(TranslateDocument, {
         hasDrafts: hasDrafts,

package/dist/client/widgets/translate-field-control/ui/TranslateFieldControl.js

@@ -47,8 +47,11 @@ import styles from "./styles.module.scss";
     const { mutateAsync, isPending } = useTranslateField();
     // `config.localization` is `false | {…}`, so the truthy check is load-bearing (not just a nil guard).
     const defaultLocale = config.localization ? config.localization.defaultLocale : undefined;
+    // `useLocale()` is typed `Locale` but actually returns `false | {} | Locale` until the admin's
+    // locale provider resolves (see the V4 TODO on the hook in @payloadcms/ui), so `code` can be absent.
+    const targetCode = locale?.code ?? "";
     const [isOpen, popup] = useToggle();
-    const [sourceLng, setSourceLng] = useState(()=>defaultLocale && defaultLocale !== locale.code ? defaultLocale : "");
+    const [sourceLng, setSourceLng] = useState(()=>defaultLocale && defaultLocale !== targetCode ? defaultLocale : "");
     // `null` = no undo available; an object wraps the value so a legitimately `undefined` field value
     // (a real pre-translation state) stays distinguishable from "nothing to undo".
     const [undo, setUndo] = useState(null);
@@ -57,7 +60,7 @@ import styles from "./styles.module.scss";
     // once translating the unsaved value in place is supported.) All hooks above run unconditionally.
     if (id === undefined || id === null) return null;
     // Source options: every locale except the one being edited (it's the fixed target).
-    const sourceLocaleOptions = localeOptions.filter((option)=>option.value !== locale.code);
+    const sourceLocaleOptions = localeOptions.filter((option)=>option.value !== targetCode);
     const canTranslate = sourceLng !== "" && !isPending;
     // One write path for every supported field type: a form UPDATE bumping value AND initialValue.
     // A Lexical (richText) editor re-mounts on the initialValue change so it shows the new content;
@@ -79,7 +82,7 @@ import styles from "./styles.module.scss";
             const { data } = await mutateAsync({
                 collectionSlug,
                 fieldPath: path,
-                targetLng: locale.code,
+                targetLng: targetCode,
                 sourceLng,
                 docId: id
             });
@@ -132,7 +135,7 @@ import styles from "./styles.module.scss";
                 className: styles.row,
                 children: [
                     /*#__PURE__*/ _jsxs("div", {
-                        "aria-label": `Translation direction: from ${sourceLng || "a source locale"} into ${locale.code}`,
+                        "aria-label": `Translation direction: from ${sourceLng || "a source locale"} into ${targetCode}`,
                         className: styles.direction,
                         role: "group",
                         children: [
@@ -161,9 +164,9 @@ import styles from "./styles.module.scss";
                                 children: "→"
                             }),
                             /*#__PURE__*/ _jsx("span", {
-                                "aria-label": `Target locale: ${locale.code} (the locale you're editing)`,
+                                "aria-label": `Target locale: ${targetCode} (the locale you're editing)`,
                                 className: styles.current,
-                                children: locale.code.toLowerCase()
+                                children: targetCode.toLowerCase()
                             })
                         ]
                     }),
@@ -176,7 +179,7 @@ import styles from "./styles.module.scss";
                             $isIconButton: true,
                             $isLoading: isPending,
                             disabled: !canTranslate,
-                            "aria-label": `Translate from ${sourceLng || "the selected locale"} into ${locale.code}`,
+                            "aria-label": `Translate from ${sourceLng || "the selected locale"} into ${targetCode}`,
                             onClick: handleTranslate,
                             children: /*#__PURE__*/ _jsx(SendIcon, {})
                         })

package/dist/core/translation-pipeline/stages/field-collector/FieldChunkCollector.js

@@ -30,9 +30,6 @@ const asObject = (value)=>isObject(value) ? value : {};
         this.strategy = strategy;
     }
     /** Collects translatable field chunks that need translation. */ collect() {
-        // The read walk SELECTS translatable leaves (via the shared selection core) and records, per
-        // selected leaf, the source value to translate plus its write target. The mutation is applied
-        // in a separate explicit pass below — read and write are no longer fused inside the walk.
         const selected = [];
         const chunks = [];
         const { strategy } = this;
@@ -119,8 +116,6 @@ const asObject = (value)=>isObject(value) ? value : {};
             target: this.targetData,
             path: []
         }, walker);
-        // Apply pass: write each selected leaf's source value into filteredData — this is what gets
-        // translated. Kept separate from the read walk above so selection stays read-only.
         for (const { dataRef, key, sourceValue } of selected){
             dataRef[key] = sourceValue;
         }

package/dist/index.d.ts

@@ -11,8 +11,8 @@ export { createTranslationProvider } from "./translation-providers";
 export type { CompletionFn, CompletionRequest, TranslationProviderConfig, JsonSchemaObject, SystemPromptBuilder, SystemPromptContext, } from "./translation-providers";
 export { TranslationProviderError, NoContentError, UnparseableReplyError, KeySetMismatchError, TransportError, ProviderConfigurationError, } from "./translation-providers";
 export type { TranslationFailureCode } from "./translation-providers";
-export { createPayloadJobsRunner, createSyncRunner } from "./server/modules/task-runner";
-export type { TaskRunnerProvider, PayloadJobsRunnerOptions } from "./server/modules/task-runner";
+export { createPayloadJobsRunner, createSyncRunner, toTaskFilter, } from "./server/modules/task-runner";
+export type { TaskRunnerProvider, PayloadJobsRunnerOptions, TaskFilter, } from "./server/modules/task-runner";
 export { documentLevel, collectionLevel, fieldLevel } from "./composition/levels";
 export type { TranslationLevel } from "./server/modules/translation-levels";
 export { withFieldTranslation } from "./field-config";

package/dist/index.js

@@ -4,7 +4,7 @@ export { openAIComplete } from "./translation-providers";
 export { createTranslationProvider } from "./translation-providers";
 export { TranslationProviderError, NoContentError, UnparseableReplyError, KeySetMismatchError, TransportError, ProviderConfigurationError } from "./translation-providers";
 // Task runners
-export { createPayloadJobsRunner, createSyncRunner } from "./server/modules/task-runner";
+export { createPayloadJobsRunner, createSyncRunner, toTaskFilter } from "./server/modules/task-runner";
 // Translation levels
 export { documentLevel, collectionLevel, fieldLevel } from "./composition/levels";
 // Field config

package/dist/server/features/translate-document/handler.d.ts

@@ -16,4 +16,5 @@ export declare class TranslateDocumentHandler implements Handler<TranslateDocume
     constructor(translationProvider: TranslationProvider, schemaMap: CollectionSchemaMap, provenanceServiceFactory?: ProvenanceServiceFactory);
     handle(payload: Payload, input: TranslateDocumentInput): Promise<TranslateDocumentOutput>;
     private saveTranslatedDocument;
+    private publishTargetLocale;
 }

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

@@ -2,6 +2,10 @@ import { APIError } from "payload";
 import { translateContent } from "../../../core/translation-pipeline";
 import { fetchSourceDocument } from "../../shared/payload/sourceDocument";
 import { AUTO_TRANSLATE_SKIP_CONTEXT_KEY } from "../../../types/AutoTranslateContext";
+import { resolveTargetLayer } from "./targetLayer";
+/** Loop guard: the auto-translate afterChange hook (#51) skips writes carrying this key. */ const translatorWriteContext = ()=>({
+        [AUTO_TRANSLATE_SKIP_CONTEXT_KEY]: true
+    });
 /**
  * Translates a single document from source language to target language. Provenance is delegated to
  * {@link ProvenanceService}: this handler only decides *when* to capture the source fingerprint
@@ -17,71 +21,76 @@ import { AUTO_TRANSLATE_SKIP_CONTEXT_KEY } from "../../../types/AutoTranslateCon
     }
     async handle(payload, input) {
         const { collection, collectionId, sourceLng, targetLng, strategy, publishOnTranslation } = input;
-        // Get original schema (preserves localized: true on nested fields)
         const schema = this.schemaMap.get(collection);
         if (!schema) throw new APIError(`Collection "${collection}" not found in schemaMap`, 400);
-        const sourceData = await fetchSourceDocument(payload, collection, collectionId, sourceLng);
-        // Capture the staleness baseline from the PRISTINE source NOW, before the pipeline runs — it
-        // translates in place and shares object-valued source leaves (e.g. richText nodes) by reference,
-        // so fingerprinting after `translateContent` would hash the target translation and make every
-        // fresh translation look instantly stale. The service is best-effort (a failure returns null).
+        const layer = resolveTargetLayer({
+            versions: payload.collections[collection].config.versions,
+            targetLng
+        });
+        // `draft: true` is unconditional: on a collection without drafts Payload has no version to
+        // substitute, so it returns the only row. The WRITE cannot be so relaxed — the `no-drafts`
+        // layer omits `draft` entirely, because that is the argument shape `main` sent.
+        const [sourceData, currentTargetVersion] = await Promise.all([
+            fetchSourceDocument(payload, collection, collectionId, sourceLng),
+            payload.findByID({
+                collection,
+                id: collectionId,
+                locale: targetLng,
+                fallbackLocale: false,
+                depth: 0,
+                draft: true
+            })
+        ]);
         const provenance = this.provenanceServiceFactory?.(payload);
         const sourceFingerprint = provenance?.captureFingerprint(collection, sourceData) ?? null;
-        const targetData = await payload.findByID({
-            collection,
-            id: collectionId,
-            locale: targetLng,
-            fallbackLocale: false,
-            depth: 0
-        });
         const translatedData = await translateContent({
             schema,
             sourceData,
-            targetData,
+            targetData: currentTargetVersion,
             sourceLng,
             targetLng,
             translationProvider: this.translationProvider,
             strategy
         });
-        if (!translatedData) return {
-            success: true
-        };
-        const collectionConfig = payload.collections[collection].config;
-        await this.saveTranslatedDocument(payload, collection, collectionId, translatedData, targetLng, sourceLng, collectionConfig, publishOnTranslation);
-        if (provenance && sourceFingerprint !== null) {
-            await provenance.record({
-                collectionSlug: collection,
-                documentId: String(collectionId),
-                targetLocale: targetLng,
-                sourceLocale: sourceLng
-            }, sourceFingerprint);
+        if (translatedData) {
+            await this.saveTranslatedDocument(payload, input, translatedData, layer.write);
+            if (provenance && sourceFingerprint !== null) {
+                await provenance.record({
+                    collectionSlug: collection,
+                    documentId: String(collectionId),
+                    targetLocale: targetLng,
+                    sourceLocale: sourceLng
+                }, sourceFingerprint);
+            }
+        }
+        if (publishOnTranslation && layer.kind === "drafts") {
+            await this.publishTargetLocale(payload, input, layer.publish);
         }
         return {
             success: true
         };
     }
-    async saveTranslatedDocument(payload, collection, collectionId, translatedData, targetLng, sourceLng, collectionConfig, publishOnTranslation) {
-        let isAutosaveEnabled = false;
-        const versions = collectionConfig.versions;
-        if (versions && versions.drafts) {
-            translatedData["_status"] = publishOnTranslation ? "published" : "draft";
-            const drafts = versions.drafts;
-            if (!publishOnTranslation && drafts.autosave) isAutosaveEnabled = true;
-        }
+    async saveTranslatedDocument(payload, input, translatedData, write) {
         await payload.update({
-            collection: collection,
-            id: collectionId,
+            collection: input.collection,
+            id: input.collectionId,
             data: translatedData,
-            autosave: isAutosaveEnabled,
-            locale: targetLng,
-            fallbackLocale: sourceLng,
-            // Mark this as a translator-authored write so the auto-translate afterChange hook (#51) skips it
-            // — the loop guard's second barrier, alongside the source-locale check. This write always targets
-            // the TARGET locale, so it is already exempt by locale; the flag also covers any future write
-            // path that could touch the source locale.
-            context: {
-                [AUTO_TRANSLATE_SKIP_CONTEXT_KEY]: true
-            }
+            ...write,
+            locale: input.targetLng,
+            fallbackLocale: input.sourceLng,
+            context: translatorWriteContext()
+        });
+    }
+    async publishTargetLocale(payload, input, publish) {
+        await payload.update({
+            collection: input.collection,
+            id: input.collectionId,
+            data: {
+                _status: publish.status
+            },
+            publishSpecificLocale: publish.publishSpecificLocale,
+            locale: publish.publishSpecificLocale,
+            context: translatorWriteContext()
         });
     }
 }

package/dist/server/features/translate-document/targetLayer.d.ts

@@ -0,0 +1,37 @@
+import type { CollectionConfig } from "payload";
+export type VersionsSlice = CollectionConfig["versions"];
+/** The arguments that publish one locale, once a collection is known to have a draft layer. */
+export type PublishScope = {
+    publishSpecificLocale: string;
+    /**
+     * Merged into the published write's data. Looks redundant beside `publishSpecificLocale`
+     * and is not: without it, any other locale holding a pending draft drags the whole
+     * document back to `draft` (#102).
+     */
+    status: "published";
+};
+/**
+ * Where a translation is written, and — separately — how the locale is published afterwards.
+ *
+ * A union, not one shape with optional fields: `publishSpecificLocale` on a collection with
+ * versions but no drafts drops every other locale from the live row (Payload 3.84.1, silent).
+ * `publish` exists only on the `drafts` variant, so that pair is unbuildable — see
+ * `targetLayer.contract.test.ts`.
+ */
+export type TargetLayer = {
+    kind: "no-drafts";
+    write: {
+        autosave: false;
+    };
+} | {
+    kind: "drafts";
+    write: {
+        draft: true;
+        autosave: boolean;
+    };
+    publish: PublishScope;
+};
+export declare function resolveTargetLayer(args: {
+    versions: VersionsSlice;
+    targetLng: string;
+}): TargetLayer;

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

@@ -0,0 +1,26 @@
+import { hasAutosaveEnabled, hasDraftsEnabled } from "payload/shared";
+export function resolveTargetLayer(args) {
+    const { versions, targetLng } = args;
+    const config = {
+        versions
+    };
+    if (!hasDraftsEnabled(config)) return {
+        kind: "no-drafts",
+        write: {
+            autosave: false
+        }
+    };
+    return {
+        kind: "drafts",
+        write: {
+            draft: true,
+            autosave: hasAutosaveEnabled(config)
+        },
+        publish: {
+            publishSpecificLocale: targetLng,
+            status: "published"
+        }
+    };
+}
+
+//# sourceMappingURL=targetLayer.js.map

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

@@ -2,6 +2,7 @@ import { getByPath, ServerResponse } from "../../shared";
 import { translateContent } from "../../../core/translation-pipeline";
 import { FieldTranslationInputSchema, MAX_FIELD_VALUE_BYTES } from "./model";
 import { resolveFieldSubtree } from "./resolveFieldSubtree";
+import { fetchSourceDocument } from "../../shared/payload/sourceDocument";
 const byteLength = (value)=>new TextEncoder().encode(JSON.stringify(value) ?? "").length;
 const noop = (value, level, message)=>({
         status: "noop",
@@ -31,16 +32,9 @@ const noop = (value, level, message)=>({
         const { collection_slug, field_path, target_lng, source_lng, doc_id } = parsed.data;
         const fields = this.config.schemaMap.get(collection_slug);
         if (!fields) return ServerResponse.badRequest(`Collection "${collection_slug}" is not available for translation`);
-        // Read the source value from the saved document in `source_lng` (fallbackLocale: false so an
-        // empty source reads as empty → noop, not a fallback). The doc also lets the resolver
-        // disambiguate `blocks` — their `blockType` lives in the data.
-        const sourceDoc = await req.payload.findByID({
-            collection: collection_slug,
-            id: doc_id,
-            locale: source_lng,
-            fallbackLocale: false,
-            depth: 0
-        });
+        // The whole document, not just the field: the resolver needs it to disambiguate `blocks`, whose
+        // `blockType` lives in the data.
+        const sourceDoc = await fetchSourceDocument(req.payload, collection_slug, doc_id, source_lng);
         const sourceValue = getByPath(sourceDoc, field_path);
         // Guard the *translated* payload (held synchronously through the provider call), not the
         // request body, which now carries no field value.

package/dist/server/modules/auto-translate/AutoTranslateEnqueue.hook.js

@@ -1,3 +1,4 @@
+import { hasDraftsEnabled } from "payload/shared";
 import { hasSourceContentChanged } from "../../../core/domain/auto-translate";
 import { AUTO_TRANSLATE_CUSTOM_KEY } from "../../../core/domain/auto-translate";
 import { AUTO_TRANSLATE_SKIP_CONTEXT_KEY } from "../../../types/AutoTranslateContext";
@@ -31,7 +32,7 @@ import { buildAutoTranslateTasks, passesPublishGate } from "./AutoTranslate.poli
                 return doc;
             }
             if (req.locale !== sourceLocale) return doc;
-            const hasDrafts = Boolean(collection.versions && collection.versions.drafts);
+            const hasDrafts = hasDraftsEnabled(collection);
             if (!passesPublishGate(doc, hasDrafts)) return doc;
             const schema = schemaMap.get(collection.slug);
             if (schema && !hasSourceContentChanged(previousDoc, doc, schema)) return doc;

package/dist/server/modules/lifecycle/withQueuedNotification.js

@@ -1,3 +1,4 @@
+import { toTaskFilter } from "../task-runner/toTaskFilter";
 import { taskFromInput } from "./taskMapping";
 /**
  * Decorate a {@link TaskRunner} so `enqueue` fires the `queued` lifecycle callback for each task.
@@ -12,7 +13,9 @@ import { taskFromInput } from "./taskMapping";
         },
         cancel: (taskIds)=>runner.cancel(taskIds),
         run: (taskId)=>runner.run(taskId),
-        findByCollection: (collectionSlug, documentIds)=>runner.findByCollection(collectionSlug, documentIds)
+        // Normalized rather than forwarded as-is: the wrapper's own signature comes from the overload
+        // pair, so it cannot pass the deprecated array form straight through.
+        findByCollection: (collectionSlug, filter)=>runner.findByCollection(collectionSlug, toTaskFilter(filter))
     };
 }
 

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

@@ -24,7 +24,25 @@ export interface TaskRunner {
      */
     run(taskId: string): Promise<RunResult>;
     /**
-     * Find tasks by collection and optionally filter by document IDs.
+     * @deprecated Pass `{ documentIds }` instead. Removed in the next major.
+     * See docs/DEPRECATIONS.md#find-by-collection-document-ids-array
      */
-    findByCollection(collectionSlug: CollectionSlug, documentIds?: Array<string | number>): Promise<Task[]>;
+    findByCollection(collectionSlug: CollectionSlug, documentIds: Array<string | number>): Promise<Task[]>;
+    /** Find tasks for a collection, optionally narrowed by a {@link TaskFilter}. */
+    findByCollection(collectionSlug: CollectionSlug, filter?: TaskFilter): Promise<Task[]>;
 }
+/**
+ * How a {@link TaskRunner.findByCollection} call is narrowed. Each field says whether it reaches the
+ * database or is applied in memory over everything the database returned.
+ *
+ * @since 0.12.0
+ */
+export type TaskFilter = {
+    /** Keep only tasks for these documents. Applied in memory — see `PayloadJobsTaskRunner.findByCollection`. */
+    documentIds?: Array<string | number>;
+    /**
+     * Drop tasks that have finished. Keeps running and failed ones — everything a re-enqueue can still
+     * supersede — so it is wider than the `pending` status.
+     */
+    excludeCompleted?: boolean;
+};

package/dist/server/modules/task-runner/TaskRunner.interface.js

@@ -1,10 +1,8 @@
 /**
- * Interface for task execution backends.
+ * How a {@link TaskRunner.findByCollection} call is narrowed. Each field says whether it reaches the
+ * database or is applied in memory over everything the database returned.
  *
- * Implementations handle queuing, cancellation, status tracking,
- * and execution of translation tasks. All business logic
- * (like cancelling existing tasks before enqueue) is encapsulated
- * within the implementation.
+ * @since 0.12.0
  */ export { };
 
 //# sourceMappingURL=TaskRunner.interface.js.map

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

@@ -3,4 +3,5 @@ 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 { TaskFilter, TaskRunner } from "./TaskRunner.interface";
+export { toTaskFilter } from "./toTaskFilter";

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

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

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

@@ -1,5 +1,5 @@
 import type { Payload, CollectionSlug } from "payload";
-import type { TaskRunner } from "../TaskRunner.interface";
+import type { TaskFilter, TaskRunner } from "../TaskRunner.interface";
 import type { Task, TaskInput, RunResult } from "../types";
 import type { PayloadJobsRunnerConfig } from "./types";
 /**
@@ -15,87 +15,26 @@ export declare class PayloadJobsTaskRunner implements TaskRunner {
     cancel(taskIds: string[]): Promise<void>;
     run(taskId: string): Promise<RunResult>;
     /**
-     * Reset stale processing locks so abandoned jobs become eligible for the
-     * autorun picker again. The picker requires processing:false, no error, and
-     * no pending waitUntil; a job abandoned mid-run (no error, no waitUntil)
-     * satisfies the rest, so clearing processing is sufficient for that case.
-     * A job that already exhausted retries (hasError:true) stays excluded from
-     * autorun and is only recoverable via a manual run().
-     *
-     * A job is stale when it is still `processing: true`, not yet completed, and
-     * its `updatedAt` is older than `staleJobTimeoutMs` — i.e. a process was
-     * killed mid-run (deploy/crash/timeout). Threshold-based, so a job genuinely
-     * in flight on another live instance (fresh `updatedAt`) is left alone.
-     * Filters on real `payload-jobs` columns only (no JSON-path traversal), so
-     * the drizzle SQLite issue in `findByCollection` does not apply here.
-     * @returns the number of jobs reclaimed.
+     * Clear stale `processing` locks — still processing, not completed, `updatedAt` older than
+     * `staleJobTimeoutMs` — so abandoned jobs are eligible for the autorun picker again. A job that
+     * exhausted its retries carries `hasError: true` and stays excluded from autorun even after its
+     * lock is cleared; only a manual `run()` recovers it.
+     * @returns how many locks were cleared.
      */
     reclaimStaleJobs(): Promise<number>;
-    /**
-     * Clear the `processing` lock on every job matching `where`, returning how
-     * many were reset. Shared by the per-job reset in `run()` (a stale lock) and
-     * the bulk boot/recovery reset in `reclaimStaleJobs()`. `depth: 0` because
-     * only the count is needed — no relationships to populate.
-     */
+    /** Clears the `processing` lock on every job matching `where`. `depth: 0` — only the count is read. */
     private resetProcessing;
-    /**
-     * A processing lock is stale once `updatedAt` is older than the configured
-     * timeout — the owning run is presumed dead.
-     */
     private isStale;
     /**
-     * Find translation jobs for a collection, optionally narrowed by document IDs.
-     *
-     * Narrowing is by `taskSlug` only in SQL; the collection slug and document
-     * IDs are matched in memory (via the normalized `Task`, which reads both the
-     * current flat-text shape and the legacy relationship shape). This is the
-     * one path that must transparently span both stored shapes during the
-     * ID-agnostic migration — see docs/DEPRECATIONS.md#jobs-input-collection-field.
-     *
-     * IMPORTANT — why slug/id are matched in memory, not in the SQL WHERE
-     * ------------------------------------------------------------------------
-     * The "natural" implementation would push `input.collection_id` into the
-     * where clause. This DOES NOT work on SQLite (and is unreliable on any
-     * adapter) because of two compounding bugs in Payload's drizzle layer.
-     *
-     * 1. The `input` field on `payload-jobs` is declared `type: 'json'`. The
-     *    drizzle path resolver (`@payloadcms/drizzle/queries/getTableColumnFromPath`)
-     *    has no `case 'json'` branch, so the value is left as a raw column and
-     *    the path segments are passed through to `parseParams.js`, which on
-     *    SQLite builds raw SQL using `convertPathToJSONTraversal` — generating
-     *    expressions like `input->>'collection_id'`.
+     * Find translation jobs for a collection.
      *
-     * 2. When `parseParams.js` formats the right-hand side of `in`/`not_in`
-     *    (and even `equals` when `!isNaN(val)`), it inlines values via JS
-     *    template literals WITHOUT wrapping strings in quotes. The string
-     *    `'1'` from our WHERE becomes raw `1` in the SQL. Drizzle therefore
-     *    emits queries like `WHERE input->>'collection_id' IN (1)` even though
-     *    the caller passed `['1']` (an array of strings).
-     *
-     * On SQLite, `->>` preserves the JSON value's type and `IN (...)` does NOT
-     * coerce between TEXT and INTEGER, so a numeric-looking string id never
-     * matches once bug #2 strips its quotes. Storing the id as text (this
-     * migration) does not fix the SQL path — drizzle re-numbers it anyway — so
-     * we keep matching in memory.
-     *
-     * Why in-memory filtering is acceptable here
-     * ------------------------------------------
-     * Per-task job sets are small (typically <100 rows; the plugin actively
-     * cancels superseded jobs so they don't accumulate), so the JS filtering
-     * is effectively free. If/when the upstream drizzle bug is fixed, this can
-     * collapse back to a single SQL query.
-     */
-    findByCollection(collectionSlug: CollectionSlug, documentIds?: Array<string | number>): Promise<Task[]>;
-    /**
-     * Group tasks by collection slug
+     * Only `taskSlug` and `completedAt` reach the database; slug and document ids are matched in memory
+     * because a job's collection reference may sit in either the flat-text fields or the legacy
+     * relationship shape (`readCollectionRef`), so a `where` on `input.collection_slug` would silently
+     * drop every pre-migration job. `excludeCompleted` is what bounds the read — see issue #108.
      */
+    findByCollection(collectionSlug: CollectionSlug, filter?: Array<string | number> | TaskFilter): Promise<Task[]>;
     private groupByCollection;
-    /**
-     * Internal cancel implementation
-     */
-    private cancelInternal;
-    /**
-     * Internal method to find jobs with where clause
-     */
+    private cancelAndDeleteJobs;
     private findJobsInternal;
 }

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

@@ -1,3 +1,4 @@
+import { toTaskFilter } from "../toTaskFilter";
 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
@@ -18,14 +19,20 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
         const byCollection = this.groupByCollection(tasks);
         for (const [collectionSlug, items] of byCollection){
             const documentIds = items.map((t)=>t.collectionId);
-            const existing = await this.findByCollection(collectionSlug, documentIds);
+            // Finished jobs must stay out of this set: superseding deletes (`cancelAndDeleteJobs` reaches
+            // `payload.delete`), so a completed job for the same (document, locale) would be erased along
+            // with the pending one.
+            const existing = await this.findByCollection(collectionSlug, {
+                documentIds,
+                excludeCompleted: true
+            });
             // 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 this.cancelAndDeleteJobs(toCancel.map((t)=>t.id));
             }
         }
         await Promise.all(tasks.map((task)=>this.payload.jobs.queue({
@@ -52,7 +59,7 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
     }
     async cancel(taskIds) {
         if (taskIds.length === 0) return;
-        await this.cancelInternal(taskIds);
+        await this.cancelAndDeleteJobs(taskIds);
     }
     async run(taskId) {
         const tasks = await this.findJobsInternal({
@@ -76,9 +83,7 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
             };
         }
         if (task.status === "running") {
-            // A genuinely in-flight job is refused. A stale processing lock (left by
-            // a process killed mid-run) is reclaimable: clear it first so the queue
-            // picker below — which only selects `processing: false` — can re-run it.
+            // The picker below selects only `processing: false`, so a stale lock must be cleared first.
             if (!this.isStale(task.updatedAt)) {
                 return {
                     success: false,
@@ -91,17 +96,10 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
                 }
             });
         }
-        // Execute synchronously via the queue + `where` picker so the job runs to
-        // completion within this request (nothing is abandoned after the HTTP
-        // response — reliable on serverless too).
-        //
-        // NOT `payload.jobs.runByID({ id })`: on the drizzle adapter the id-path
-        // (`db.updateJobs({ id })`) writes `processing: true` but returns no rows,
-        // so `runJobs` reports `noJobsRemaining` and the handler never runs —
-        // leaving the job stuck at `processing: true` forever. The `where`-based
-        // picker selects, runs, and finalizes the job correctly (verified against
-        // sqlite). The picker also enforces processing:false / no-error / no
-        // pending waitUntil, so a failed (max-retries) job is not re-run here.
+        // `where` picker, not `payload.jobs.runByID({ id })`: in `runJobs` the guard block
+        // (processing:false, hasError not true, waitUntil due) is built only for the non-id branch, so
+        // the id path would re-run a job that already exhausted its retries. Checked against payload
+        // 3.84.1.
         await this.payload.jobs.run({
             queue: this.config.queueName,
             where: {
@@ -116,20 +114,11 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
         };
     }
     /**
-   * Reset stale processing locks so abandoned jobs become eligible for the
-   * autorun picker again. The picker requires processing:false, no error, and
-   * no pending waitUntil; a job abandoned mid-run (no error, no waitUntil)
-   * satisfies the rest, so clearing processing is sufficient for that case.
-   * A job that already exhausted retries (hasError:true) stays excluded from
-   * autorun and is only recoverable via a manual run().
-   *
-   * A job is stale when it is still `processing: true`, not yet completed, and
-   * its `updatedAt` is older than `staleJobTimeoutMs` — i.e. a process was
-   * killed mid-run (deploy/crash/timeout). Threshold-based, so a job genuinely
-   * in flight on another live instance (fresh `updatedAt`) is left alone.
-   * Filters on real `payload-jobs` columns only (no JSON-path traversal), so
-   * the drizzle SQLite issue in `findByCollection` does not apply here.
-   * @returns the number of jobs reclaimed.
+   * Clear stale `processing` locks — still processing, not completed, `updatedAt` older than
+   * `staleJobTimeoutMs` — so abandoned jobs are eligible for the autorun picker again. A job that
+   * exhausted its retries carries `hasError: true` and stays excluded from autorun even after its
+   * lock is cleared; only a manual `run()` recovers it.
+   * @returns how many locks were cleared.
    */ async reclaimStaleJobs() {
         const cutoff = new Date(Date.now() - this.config.staleJobTimeoutMs).toISOString();
         return this.resetProcessing({
@@ -157,12 +146,7 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
             ]
         });
     }
-    /**
-   * Clear the `processing` lock on every job matching `where`, returning how
-   * many were reset. Shared by the per-job reset in `run()` (a stale lock) and
-   * the bulk boot/recovery reset in `reclaimStaleJobs()`. `depth: 0` because
-   * only the count is needed — no relationships to populate.
-   */ async resetProcessing(where) {
+    /** Clears the `processing` lock on every job matching `where`. `depth: 0` — only the count is read. */ async resetProcessing(where) {
         const result = await this.payload.update({
             collection: this.config.jobsCollection,
             depth: 0,
@@ -173,10 +157,7 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
         });
         return result.docs.length;
     }
-    /**
-   * A processing lock is stale once `updatedAt` is older than the configured
-   * timeout — the owning run is presumed dead.
-   */ isStale(updatedAt) {
+    isStale(updatedAt) {
         const parsed = Date.parse(updatedAt);
         // Unknown/corrupt timestamp → treat as stale so the job can be recovered
         // rather than permanently refused as already-running.
@@ -184,60 +165,28 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
         return Date.now() - parsed > this.config.staleJobTimeoutMs;
     }
     /**
-   * Find translation jobs for a collection, optionally narrowed by document IDs.
-   *
-   * Narrowing is by `taskSlug` only in SQL; the collection slug and document
-   * IDs are matched in memory (via the normalized `Task`, which reads both the
-   * current flat-text shape and the legacy relationship shape). This is the
-   * one path that must transparently span both stored shapes during the
-   * ID-agnostic migration — see docs/DEPRECATIONS.md#jobs-input-collection-field.
-   *
-   * IMPORTANT — why slug/id are matched in memory, not in the SQL WHERE
-   * ------------------------------------------------------------------------
-   * The "natural" implementation would push `input.collection_id` into the
-   * where clause. This DOES NOT work on SQLite (and is unreliable on any
-   * adapter) because of two compounding bugs in Payload's drizzle layer.
-   *
-   * 1. The `input` field on `payload-jobs` is declared `type: 'json'`. The
-   *    drizzle path resolver (`@payloadcms/drizzle/queries/getTableColumnFromPath`)
-   *    has no `case 'json'` branch, so the value is left as a raw column and
-   *    the path segments are passed through to `parseParams.js`, which on
-   *    SQLite builds raw SQL using `convertPathToJSONTraversal` — generating
-   *    expressions like `input->>'collection_id'`.
+   * Find translation jobs for a collection.
    *
-   * 2. When `parseParams.js` formats the right-hand side of `in`/`not_in`
-   *    (and even `equals` when `!isNaN(val)`), it inlines values via JS
-   *    template literals WITHOUT wrapping strings in quotes. The string
-   *    `'1'` from our WHERE becomes raw `1` in the SQL. Drizzle therefore
-   *    emits queries like `WHERE input->>'collection_id' IN (1)` even though
-   *    the caller passed `['1']` (an array of strings).
-   *
-   * On SQLite, `->>` preserves the JSON value's type and `IN (...)` does NOT
-   * coerce between TEXT and INTEGER, so a numeric-looking string id never
-   * matches once bug #2 strips its quotes. Storing the id as text (this
-   * migration) does not fix the SQL path — drizzle re-numbers it anyway — so
-   * we keep matching in memory.
-   *
-   * Why in-memory filtering is acceptable here
-   * ------------------------------------------
-   * Per-task job sets are small (typically <100 rows; the plugin actively
-   * cancels superseded jobs so they don't accumulate), so the JS filtering
-   * is effectively free. If/when the upstream drizzle bug is fixed, this can
-   * collapse back to a single SQL query.
-   */ async findByCollection(collectionSlug, documentIds) {
-        const all = await this.findJobsInternal(undefined, {
+   * Only `taskSlug` and `completedAt` reach the database; slug and document ids are matched in memory
+   * because a job's collection reference may sit in either the flat-text fields or the legacy
+   * relationship shape (`readCollectionRef`), so a `where` on `input.collection_slug` would silently
+   * drop every pre-migration job. `excludeCompleted` is what bounds the read — see issue #108.
+   */ async findByCollection(collectionSlug, filter) {
+        const { documentIds, excludeCompleted } = toTaskFilter(filter);
+        const where = excludeCompleted ? {
+            completedAt: {
+                exists: false
+            }
+        } : undefined;
+        const all = await this.findJobsInternal(where, {
             pagination: false
         });
         const bySlug = all.filter((t)=>t.input.collectionSlug === collectionSlug);
         if (!documentIds?.length) return bySlug;
-        // `documentIds` is the public `Array<string | number>` param, so normalize
-        // it here; `t.input.collectionId` is already `ID` (string) via normalizeJob.
         const wanted = new Set(documentIds.map(String));
         return bySlug.filter((t)=>wanted.has(t.input.collectionId));
     }
-    /**
-   * Group tasks by collection slug
-   */ groupByCollection(tasks) {
+    groupByCollection(tasks) {
         const map = new Map();
         for (const task of tasks){
             const existing = map.get(task.collectionSlug) ?? [];
@@ -246,10 +195,12 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
         }
         return map;
     }
-    /**
-   * Internal cancel implementation
-   */ async cancelInternal(taskIds) {
+    async cancelAndDeleteJobs(taskIds) {
         if (taskIds.length === 0) return;
+        // Both, in this order: `jobs.cancel` only writes `{ error: { cancelled: true }, hasError: true,
+        // processing: false }`, which is what signals a running handler to abort. The delete then removes
+        // the row — under `deleteJobOnComplete: false` a cancelled job would otherwise sit in the status
+        // feed forever.
         await this.payload.jobs.cancel({
             where: {
                 id: {
@@ -267,9 +218,7 @@ const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${
             }
         });
     }
-    /**
-   * Internal method to find jobs with where clause
-   */ async findJobsInternal(where, params) {
+    async findJobsInternal(where, params) {
         const and = [
             {
                 taskSlug: {

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

@@ -1,5 +1,5 @@
 import type { Payload, CollectionSlug } from "payload";
-import type { TaskRunner } from "../TaskRunner.interface";
+import type { TaskFilter, TaskRunner } from "../TaskRunner.interface";
 import type { TaskHandler } from "../TaskRunnerProvider.interface";
 import type { Task, TaskInput, RunResult } from "../types";
 import type { LazyMap } from "../../../shared/utils";
@@ -17,6 +17,6 @@ export declare class SyncTaskRunner implements TaskRunner {
     enqueue(inputs: TaskInput[]): Promise<void>;
     cancel(_taskIds: string[]): Promise<void>;
     run(_taskId: string): Promise<RunResult>;
-    findByCollection(collectionSlug: CollectionSlug, documentIds?: Array<string | number>): Promise<Task[]>;
+    findByCollection(collectionSlug: CollectionSlug, filter?: Array<string | number> | TaskFilter): Promise<Task[]>;
     private getKey;
 }

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

@@ -1,3 +1,4 @@
+import { toTaskFilter } from "../toTaskFilter";
 /**
  * Synchronous TaskRunner implementation.
  *
@@ -55,12 +56,17 @@
             error: "not_found"
         };
     }
-    async findByCollection(collectionSlug, documentIds) {
+    async findByCollection(collectionSlug, filter) {
+        const { documentIds, excludeCompleted } = toTaskFilter(filter);
         const results = [];
         const wanted = documentIds ? new Set(documentIds.map(String)) : undefined;
         for (const [, task] of this.tasks){
             if (task.input.collectionSlug !== collectionSlug) continue;
             if (wanted && !wanted.has(task.input.collectionId)) continue;
+            // Keyed on `completedAt`, the same field the jobs runner pushes into its where clause. Keying
+            // on `status` instead would agree only by accident: `getJobStatus` happens to check
+            // `completedAt` before `error`, and reordering it would silently split the two runners.
+            if (excludeCompleted && task.completedAt) continue;
             results.push(task);
         }
         return results;

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

@@ -0,0 +1,11 @@
+import type { TaskFilter } from "./TaskRunner.interface";
+/**
+ * Normalize the two accepted shapes of {@link TaskRunner.findByCollection}'s second argument.
+ *
+ * Every implementation of {@link TaskRunner} owes this, so it ships alongside the contract rather
+ * than being re-derived: the array form is deprecated and will be removed, and a hand-written
+ * `Array.isArray` branch in someone else's runner would outlive it.
+ *
+ * @since 0.12.0
+ */
+export declare function toTaskFilter(filter?: Array<string | number> | TaskFilter): TaskFilter;

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

@@ -0,0 +1,15 @@
+/**
+ * Normalize the two accepted shapes of {@link TaskRunner.findByCollection}'s second argument.
+ *
+ * Every implementation of {@link TaskRunner} owes this, so it ships alongside the contract rather
+ * than being re-derived: the array form is deprecated and will be removed, and a hand-written
+ * `Array.isArray` branch in someone else's runner would outlive it.
+ *
+ * @since 0.12.0
+ */ export function toTaskFilter(filter) {
+    return Array.isArray(filter) ? {
+        documentIds: filter
+    } : filter ?? {};
+}
+
+//# sourceMappingURL=toTaskFilter.js.map

package/dist/server/shared/guards/index.d.ts

@@ -1,3 +1,2 @@
 export type { TranslatableField } from "./field-guards";
 export { isTranslatableField, isLocalizedField, isRelationshipField } from "./field-guards";
-export { collectionHasDrafts } from "./collection-guards";

package/dist/server/shared/guards/index.js

@@ -1,4 +1,3 @@
 export { isTranslatableField, isLocalizedField, isRelationshipField } from "./field-guards";
-export { collectionHasDrafts } from "./collection-guards";
 
 //# sourceMappingURL=index.js.map

package/dist/server/shared/payload/sourceDocument.d.ts

@@ -1,8 +1,6 @@
 import type { CollectionSlug, Payload } from "payload";
 /**
- * Fetch a document's source-locale data with the exact shape the provenance fingerprint depends on
- * (`depth: 0`, the given locale). Used by the translation **write** path (fingerprints the source it
- * just translated) and, through {@link ProvenanceService}, by the staleness **read** path
- * (re-fingerprints the live source), so the fingerprint baseline can never drift between the two.
+ * The single source read: what "translate from X" resolves to. Both translation write paths and
+ * the staleness recompute must go through here, or the fingerprints they compare drift apart.
  */
 export declare function fetchSourceDocument(payload: Payload, collection: CollectionSlug, id: string, locale: string): Promise<import("payload").JsonObject & import("payload").TypeWithID>;

package/dist/server/shared/payload/sourceDocument.js

@@ -1,14 +1,19 @@
 /**
- * Fetch a document's source-locale data with the exact shape the provenance fingerprint depends on
- * (`depth: 0`, the given locale). Used by the translation **write** path (fingerprints the source it
- * just translated) and, through {@link ProvenanceService}, by the staleness **read** path
- * (re-fingerprints the live source), so the fingerprint baseline can never drift between the two.
+ * The single source read: what "translate from X" resolves to. Both translation write paths and
+ * the staleness recompute must go through here, or the fingerprints they compare drift apart.
  */ export function fetchSourceDocument(payload, collection, id, locale) {
     return payload.findByID({
         collection,
         id,
         locale,
-        depth: 0
+        depth: 0,
+        // The current version, as the editor sees it. A published-row read is empty whenever the source
+        // locale is unpublished — which is exactly what a publish scoped to the target locale leaves
+        // behind — and then every fresh translation fingerprints as stale.
+        draft: true,
+        // Payload's locale fallback resolves an empty source locale to the default locale's text, so
+        // "translate from fr" would translate English and fingerprint English as the French source.
+        fallbackLocale: false
     });
 }
 

package/package.json

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

package/dist/server/shared/guards/collection-guards.d.ts

@@ -1,6 +0,0 @@
-import type { CollectionConfig, SanitizedCollectionConfig } from "payload";
-/**
- * Checks if a collection has drafts enabled.
- * Handles both CollectionConfig and SanitizedCollectionConfig.
- */
-export declare function collectionHasDrafts(collection: CollectionConfig | SanitizedCollectionConfig): boolean;

package/dist/server/shared/guards/collection-guards.js

@@ -1,16 +0,0 @@
-/**
- * Type guard: Checks if versions config is an object (not boolean).
- */ function isVersionsObject(versions) {
-    return typeof versions === "object" && versions !== null;
-}
-/**
- * Checks if a collection has drafts enabled.
- * Handles both CollectionConfig and SanitizedCollectionConfig.
- */ export function collectionHasDrafts(collection) {
-    const { versions } = collection;
-    if (!versions) return false;
-    if (!isVersionsObject(versions)) return false;
-    return "drafts" in versions && Boolean(versions.drafts);
-}
-
-//# sourceMappingURL=collection-guards.js.map