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

package/dist/core/{content-projection → domain/content-projection}/contentProjector.d.ts

@@ -9,7 +9,7 @@
  * translation can never disagree on which content is translatable. Payload-free and read-only:
  * it never mutates the document and never captures write handles.
  */
-import type { FieldLike } from "../field-traversal/types";
+import type { FieldLike } from "../../kernel/field-traversal/types";
 import type { IdPath } from "./idPath";
 /** One translatable leaf of a document: WHERE it lives ({@link IdPath}) and WHAT text it holds. */
 export interface ProjectionEntry {

package/dist/core/{content-projection → domain/content-projection}/contentProjector.js

@@ -8,8 +8,8 @@
  * {@link leafSourceText}) as the translation pipeline's `FieldChunkCollector`, so projection and
  * translation can never disagree on which content is translatable. Payload-free and read-only:
  * it never mutates the document and never captures write handles.
- */ import { resolveBlockFields, walkFields } from "../field-traversal";
-import { isObject } from "../utils/isObject";
+ */ import { resolveBlockFields, walkFields } from "../../kernel/field-traversal";
+import { isObject } from "../../kernel/utils/isObject";
 import { elementSegment, makeIdPath } from "./idPath";
 import { isTranslatableLeaf, leafSourceText } from "./translatableLeaf";
 /**

package/dist/core/{content-projection → domain/content-projection}/translatableLeaf.d.ts

@@ -7,7 +7,7 @@
  * Payload-free (structural {@link FieldLike} + owned `Serialized*` views only) so it can move to
  * `@repo/translator-core` unchanged.
  */
-import type { FieldLike, LeafFieldLike } from "../field-traversal/types";
+import type { FieldLike, LeafFieldLike } from "../../kernel/field-traversal/types";
 /**
  * The leaf-SELECTION decision shared by projection and translation: a leaf is a translation target
  * iff it is a translatable text type, localized, and not excluded via `custom.translateKit`.

package/dist/core/{content-projection → domain/content-projection}/translatableLeaf.js

@@ -7,8 +7,8 @@
  * Payload-free (structural {@link FieldLike} + owned `Serialized*` views only) so it can move to
  * `@repo/translator-core` unchanged.
  */ import { isFieldExcludedFromTranslation } from "../field-config";
-import { collectSerializedLexicalTextNodes } from "../lexical/collectTextNodes";
-import { isSerializedLexicalRoot } from "../lexical/guards";
+import { collectSerializedLexicalTextNodes } from "../../kernel/lexical/collectTextNodes";
+import { isSerializedLexicalRoot } from "../../kernel/lexical/guards";
 /** The field types this package translates (mirrors `isTranslatableField`, payload-free). */ const isTranslatableFieldType = (field)=>field.type === "text" || field.type === "textarea" || field.type === "richText";
 /** Mirrors `isLocalizedField` structurally. */ const isLocalizedFieldLike = (field)=>field.localized === true;
 /**

package/dist/core/index.d.ts

@@ -1,12 +1,12 @@
-export type { TranslationProvider, TranslationInput, TranslationOutput, TranslationIndex, } from "./translation-providers";
+export type { TranslationProvider, TranslationInput, TranslationOutput, TranslationIndex, } from "./domain/translation-providers";
 export { TranslationPipeline, translateContent } from "./translation-pipeline";
 export type { TranslateContentArgs, TranslationStrategy } from "./translation-pipeline";
-export type { ProvenanceKey, ProvenanceStore, TranslationProvenanceRecord } from "./provenance";
-export { projectTranslatableContent } from "./content-projection/contentProjector";
-export type { ProjectionEntry } from "./content-projection/contentProjector";
-export { fingerprint } from "./content-projection/fingerprinter";
-export { computeSourceFingerprint } from "./content-projection/computeSourceFingerprint";
-export { makeIdPath } from "./content-projection/idPath";
-export type { IdPath, PathSegment } from "./content-projection/idPath";
-export { classifyField, findFieldByPath, hasFields, isBlockItem, isTabsField, matchElementById, resolveBlockFields, tabScopes, walkFields, } from "./field-traversal";
-export type { ArrayFieldLike, BlockLike, BlocksFieldLike, FieldLike, FieldStructure, FieldWalker, GroupFieldLike, LeafField, LeafFieldLike, TabLike, TabScope, TabsFieldLike, } from "./field-traversal";
+export type { ProvenanceKey, ProvenanceStore, TranslationProvenanceRecord, } from "./domain/provenance";
+export { projectTranslatableContent } from "./domain/content-projection/contentProjector";
+export type { ProjectionEntry } from "./domain/content-projection/contentProjector";
+export { fingerprint } from "./domain/content-projection/fingerprinter";
+export { computeSourceFingerprint } from "./domain/content-projection/computeSourceFingerprint";
+export { makeIdPath } from "./domain/content-projection/idPath";
+export type { IdPath, PathSegment } from "./domain/content-projection/idPath";
+export { classifyField, findFieldByPath, hasFields, isBlockItem, isTabsField, matchElementById, resolveBlockFields, tabScopes, walkFields, } from "./kernel/field-traversal";
+export type { ArrayFieldLike, BlockLike, BlocksFieldLike, FieldLike, FieldStructure, FieldWalker, GroupFieldLike, LeafField, LeafFieldLike, TabLike, TabScope, TabsFieldLike, } from "./kernel/field-traversal";

package/dist/core/index.js

@@ -5,11 +5,11 @@
 // Translation pipeline
 export { TranslationPipeline, translateContent } from "./translation-pipeline";
 // Content projection
-export { projectTranslatableContent } from "./content-projection/contentProjector";
-export { fingerprint } from "./content-projection/fingerprinter";
-export { computeSourceFingerprint } from "./content-projection/computeSourceFingerprint";
-export { makeIdPath } from "./content-projection/idPath";
+export { projectTranslatableContent } from "./domain/content-projection/contentProjector";
+export { fingerprint } from "./domain/content-projection/fingerprinter";
+export { computeSourceFingerprint } from "./domain/content-projection/computeSourceFingerprint";
+export { makeIdPath } from "./domain/content-projection/idPath";
 // Field traversal
-export { classifyField, findFieldByPath, hasFields, isBlockItem, isTabsField, matchElementById, resolveBlockFields, tabScopes, walkFields } from "./field-traversal";
+export { classifyField, findFieldByPath, hasFields, isBlockItem, isTabsField, matchElementById, resolveBlockFields, tabScopes, walkFields } from "./kernel/field-traversal";
 
 //# sourceMappingURL=index.js.map

package/dist/core/translation-pipeline/TranslationPipeline.d.ts

@@ -1,4 +1,4 @@
-import type { TranslationProvider } from "../translation-providers";
+import type { TranslationProvider } from "../domain/translation-providers";
 import type { PipelineConfig, PipelineResult } from "./types";
 import type { TranslationStrategy } from "./strategies";
 import type { TextExpander } from "./stages";

package/dist/core/translation-pipeline/stages/data-reconciler/DataReconciler.d.ts

@@ -1,4 +1,4 @@
-import type { FieldLike } from "../../../field-traversal";
+import type { FieldLike } from "../../../kernel/field-traversal";
 /**
  * Deep-merges source and target data with target priority, producing the full document shape
  * Payload validation needs. Built on the shared {@link walkFields} engine.

package/dist/core/translation-pipeline/stages/data-reconciler/DataReconciler.js

@@ -1,6 +1,6 @@
-import { isEmpty } from "../../../utils/isEmpty";
-import { isObject } from "../../../utils/isObject";
-import { matchElementById, resolveBlockFields, walkFields } from "../../../field-traversal";
+import { isEmpty } from "../../../kernel/utils/isEmpty";
+import { isObject } from "../../../kernel/utils/isObject";
+import { matchElementById, resolveBlockFields, walkFields } from "../../../kernel/field-traversal";
 const asObject = (value)=>isObject(value) ? value : {};
 /**
  * Reconcile walker: produces the full document shape from source + target, with target

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

@@ -1,4 +1,4 @@
-import type { FieldLike } from "../../../field-traversal";
+import type { FieldLike } from "../../../kernel/field-traversal";
 import type { TranslationStrategy } from "../../strategies";
 import type { FieldChunk } from "../../types";
 /**

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

@@ -1,6 +1,6 @@
-import { isTranslatableLeaf } from "../../../content-projection/translatableLeaf";
-import { matchElementById, resolveBlockFields, walkFields } from "../../../field-traversal";
-import { isObject } from "../../../utils/isObject";
+import { isTranslatableLeaf } from "../../../domain/content-projection/translatableLeaf";
+import { matchElementById, resolveBlockFields, walkFields } from "../../../kernel/field-traversal";
+import { isObject } from "../../../kernel/utils/isObject";
 const asObject = (value)=>isObject(value) ? value : {};
 /**
  * Collects FieldChunks by walking schema + data with the shared {@link walkFields} engine.

package/dist/core/translation-pipeline/stages/text-expander/RichTextExpander.js

@@ -1,4 +1,4 @@
-import { isSerializedLexicalRoot, collectSerializedLexicalTextNodes } from "../../../lexical";
+import { isSerializedLexicalRoot, collectSerializedLexicalTextNodes } from "../../../kernel/lexical";
 /**
  * Expands richText fields into multiple RichTextChunks (one per text node).
  */ export class RichTextExpander {

package/dist/core/translation-pipeline/stages/translation/Translation.stage.d.ts

@@ -1,5 +1,5 @@
 import type { PipelineContext, PipelineStage } from "../../types";
-import type { TranslationProvider } from "../../../translation-providers";
+import type { TranslationProvider } from "../../../domain/translation-providers";
 /**
  * Calls translation provider to translate text.
  */

package/dist/core/translation-pipeline/strategies/Overwrite.strategy.js

@@ -1,4 +1,4 @@
-import { isEmpty } from "../../utils/isEmpty";
+import { isEmpty } from "../../kernel/utils/isEmpty";
 /**
  * Translates all fields, overwriting existing translations.
  * This is the default strategy.

package/dist/core/translation-pipeline/strategies/SkipExisting.strategy.js

@@ -1,6 +1,6 @@
-import { isEmptyRichText } from "../../lexical/isEmptyRichText";
-import { isSerializedLexicalRoot } from "../../lexical/guards";
-import { isEmpty } from "../../utils/isEmpty";
+import { isEmptyRichText } from "../../kernel/lexical/isEmptyRichText";
+import { isSerializedLexicalRoot } from "../../kernel/lexical/guards";
+import { isEmpty } from "../../kernel/utils/isEmpty";
 /**
  * Only translates fields that are empty or missing in the target locale.
  * Existing translations are preserved.

package/dist/core/translation-pipeline/translateContent.d.ts

@@ -1,5 +1,5 @@
-import type { FieldLike } from "../field-traversal";
-import type { TranslationProvider } from "../translation-providers";
+import type { FieldLike } from "../kernel/field-traversal";
+import type { TranslationProvider } from "../domain/translation-providers";
 import type { TranslationStrategyName } from "./strategies";
 export type TranslateContentArgs = {
     /** Schema subtree to translate (e.g. `[declaredFieldConfig]`). */

package/dist/core/translation-pipeline/types/FieldChunk.d.ts

@@ -1,4 +1,4 @@
-import type { LeafFieldLike } from "../../field-traversal/types";
+import type { LeafFieldLike } from "../../kernel/field-traversal/types";
 /**
  * Represents a field-level chunk containing schema metadata.
  * Used in stages 1-3 where schema awareness is needed.

package/dist/core/translation-pipeline/types/Pipeline.d.ts

@@ -1,4 +1,4 @@
-import type { FieldLike } from "../../field-traversal";
+import type { FieldLike } from "../../kernel/field-traversal";
 /**
  * Pipeline configuration for translation execution.
  * Contains only data transformation inputs — no persistence concerns.

package/dist/core/translation-pipeline/types/PipelineContext.d.ts

@@ -1,4 +1,4 @@
-import type { FieldLike } from "../../field-traversal";
+import type { FieldLike } from "../../kernel/field-traversal";
 import type { FieldChunk } from "./FieldChunk";
 import type { TextChunk } from "./TextChunk";
 /**

package/dist/core/translation-pipeline/types/TextChunk.d.ts

@@ -1,4 +1,4 @@
-import type { SerializedTextNode } from "../../lexical";
+import type { SerializedTextNode } from "../../kernel/lexical";
 /**
  * Text chunk for plain text/textarea fields.
  * Mutates dataRef[key] directly.

package/dist/field-config.d.ts

@@ -1,5 +1,5 @@
 import type { Field, RichTextField, TextareaField, TextField } from "payload";
-import type { FieldTranslationConfig } from "./core/field-config";
+import type { FieldTranslationConfig } from "./core/domain/field-config";
 export type { FieldTranslationConfig };
 /**
  * Field types eligible for the per-field translate control — the same text-bearing

package/dist/field-config.js

@@ -1,4 +1,4 @@
-import { TRANSLATE_KIT_CUSTOM_KEY } from "./core/field-config";
+import { TRANSLATE_KIT_CUSTOM_KEY } from "./core/domain/field-config";
 import { TranslateFieldControlExport } from "./client/widgets/translate-field-control/ui/TranslateFieldControl.export";
 import { beforeInputPositioner } from "./field-actions";
 /**

package/dist/index.d.ts

@@ -12,6 +12,8 @@ export { documentLevel, collectionLevel, fieldLevel } from "./composition/levels
 export type { TranslationLevel } from "./server/modules/translation-levels";
 export { withFieldTranslation } from "./field-config";
 export type { FieldTranslationConfig } from "./field-config";
+export { withAutoTranslate } from "./auto-translate-config";
+export type { AutoTranslateConfig, AutoTranslateStrategy } from "./auto-translate-config";
 export { createTranslatePlugin, TranslateCollectionPlugin } from "./plugin";
 export type { TranslateCollectionPluginConfig } from "./plugin";
 export { OpenAITranslationProvider } from "./translation-providers";

package/dist/index.js

@@ -8,6 +8,10 @@ export { createPayloadJobsRunner, createSyncRunner } from "./server/modules/task
 export { documentLevel, collectionLevel, fieldLevel } from "./composition/levels";
 // Field config
 export { withFieldTranslation } from "./field-config";
+// Auto-translate — opt-in, per-collection auto-translation on source-locale change (#51). Wrap a
+// collection with `withAutoTranslate`; requires a working job runner/autorun to execute (see the
+// JSDoc for the Vercel/serverless caveat). Since v0.9.0.
+export { withAutoTranslate } from "./auto-translate-config";
 // Deprecated exports (for backwards compatibility)
 export { createTranslatePlugin, TranslateCollectionPlugin } from "./plugin";
 export { OpenAITranslationProvider } from "./translation-providers";

package/dist/plugin.d.ts

@@ -1,6 +1,6 @@
 import type { CollectionConfig, Config } from "payload";
 import type { AccessGuard } from "./types/AccessGuard";
-import type { TranslationProvider } from "./core/translation-providers";
+import type { TranslationProvider } from "./core/domain/translation-providers";
 import type { TaskRunnerProvider } from "./server/modules/task-runner";
 import type { TranslationLifecycleCallbacks } from "./server/modules/lifecycle";
 import type { TranslationLevel } from "./server/modules/translation-levels";

package/dist/plugin.js

@@ -1,4 +1,5 @@
 import { CacheProviderExport } from "./client/app/cache/CacheProvider.export";
+import { configureAutoTranslate } from "./server/modules/auto-translate";
 import { configureProvenance } from "./server/modules/provenance";
 import { wireTranslateRunner } from "./server/features/translate-document";
 import { documentLevel, collectionLevel } from "./composition/levels";
@@ -36,6 +37,9 @@ import { normalizePath } from "./server/shared";
                 lifecycle: lifecycle ?? {},
                 collections: Array.from(collectionSlugs)
             });
+            // Auto-translate (#51) reads its opt-in from each collection's `custom` (via `withAutoTranslate`);
+            // needs the runner's factory, so it wires after `wireTranslateRunner`.
+            const autoTranslateModule = configureAutoTranslate(collections, schemaMap, taskRunnerFactory);
             const activeLevels = levels ?? [
                 documentLevel(),
                 collectionLevel()
@@ -52,6 +56,7 @@ import { normalizePath } from "./server/shared";
             for (const level of activeLevels)level.extend(builder);
             builder.addConfigModifier(runnerConfigModifier);
             builder.addConfigModifier(provenanceModule.configure(collectionSlugs));
+            builder.addConfigModifier(autoTranslateModule.configure(collectionSlugs));
             builder.addAdminProvider(new CacheProviderExport(basePath));
             // The single place the Payload config is mutated.
             return builder.applyTo(config);

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

@@ -1,6 +1,6 @@
 import type { Payload } from "payload";
 import type { Handler } from "../../shared";
-import type { TranslationProvider } from "../../../core/translation-providers";
+import type { TranslationProvider } from "../../../core/domain/translation-providers";
 import type { ProvenanceServiceFactory } from "../../modules/provenance";
 import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
 import type { TranslateDocumentInput, TranslateDocumentOutput } from "./model";

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

@@ -1,6 +1,7 @@
 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";
 /**
  * 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
@@ -73,7 +74,14 @@ import { fetchSourceDocument } from "../../shared/payload/sourceDocument";
             data: translatedData,
             autosave: isAutosaveEnabled,
             locale: targetLng,
-            fallbackLocale: sourceLng
+            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
+            }
         });
     }
 }

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

@@ -1,5 +1,5 @@
 import type { CollectionSlug } from "payload";
-import type { TranslationProvider } from "../../../core/translation-providers";
+import type { TranslationProvider } from "../../../core/domain/translation-providers";
 import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
 import type { ConfigModifier } from "../../../types/ConfigModifier";
 import type { ProvenanceServiceFactory } from "../../modules/provenance";

package/dist/server/features/translate-field/model.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
-import type { TranslationProvider } from "../../../core/translation-providers";
+import type { TranslationProvider } from "../../../core/domain/translation-providers";
 /**
  * Max serialized size of the value the endpoint will translate — the value read from the
  * source-locale document (the request body no longer carries one; this is from-locale only). The

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

@@ -1,5 +1,5 @@
 import { isTranslatableField } from "../../shared";
-import { findFieldByPath } from "../../../core/field-traversal";
+import { findFieldByPath } from "../../../core/kernel/field-traversal";
 /**
  * Map a declared `fieldPath` to the `{ schema, sourceData }` pair `translateContent` expects.
  * Walks the schema via the shared {@link findFieldByPath}. Descends transparently through

package/dist/server/modules/auto-translate/AutoTranslate.policy.d.ts

@@ -0,0 +1,79 @@
+import type { CollectionSlug } from "payload";
+import type { AutoTranslateConfig } from "../../../core/domain/auto-translate";
+import type { TaskInput } from "../task-runner/types";
+/** A collection's auto-translate rule with defaults resolved — the shape the hook consumes. */
+export type NormalizedAutoTranslatePolicy = {
+    targets: string[];
+    strategy: "overwrite" | "skip_existing";
+    debounceMs: number;
+    sourceLocale?: string;
+};
+/**
+ * Resolve the effective auto-translate policy for a document, or `null` when off. The `doc` parameter
+ * is the reserved seam for the future document-level manager override (#51 D7): v1 resolves at the
+ * collection level and IGNORES `doc`; a later phase supplies a second implementation that consults the
+ * document, without changing the hook, drift-gate, debounce, or wiring.
+ */
+export type AutoTranslatePolicyResolver = (collectionSlug: string, doc: Record<string, unknown>) => NormalizedAutoTranslatePolicy | null;
+/** Apply defaults to a raw config: strategy → "overwrite", debounce → 0. Duplicate target locales are
+ * de-duplicated so a misconfigured `targets: ["de","de"]` never enqueues two racing jobs for the same
+ * (document, locale) in one batch (the runner's supersession only dedupes against already-stored jobs). */
+export declare function normalizeAutoTranslateConfig(config: AutoTranslateConfig): NormalizedAutoTranslatePolicy;
+/**
+ * A minimal localization shape — the set of configured locale codes, in either form Payload accepts
+ * (`"en"` or `{ code: "en" }`). Payload's `Config["localization"]` is structurally assignable, so the
+ * caller passes it straight in with no adapter and tests pass a tiny literal.
+ */
+export type LocalizationLike = false | {
+    locales: Array<string | {
+        code: string;
+    }>;
+};
+/** Extract the configured locale codes, or `null` when localization is disabled/absent. */
+export declare function extractLocaleCodes(localization: LocalizationLike | undefined): Set<string> | null;
+/** Outcome of validating a policy's locales against the configured set — the filtered policy plus what
+ * was dropped, so the caller can warn precisely. */
+export type PolicyLocaleFilter = {
+    policy: NormalizedAutoTranslatePolicy;
+    droppedTargets: string[];
+    droppedSourceLocale: string | null;
+};
+/**
+ * Drop targets (and a `sourceLocale` override) that are not configured locales, so a mistyped locale in
+ * `withAutoTranslate` never reaches the pipeline — where it would silently burn a provider call and
+ * either error at the DB (Postgres locale enum) or write orphaned, invisible data (Mongo/SQLite). Pure:
+ * returns a new policy and reports the drops; the caller (config-time wiring) emits the warning.
+ */
+export declare function filterPolicyToKnownLocales(policy: NormalizedAutoTranslatePolicy, knownLocales: Set<string>): PolicyLocaleFilter;
+/**
+ * The v1 (collection-level) resolver. Ignores `doc` — see {@link AutoTranslatePolicyResolver}. This is
+ * the single seam a future document-level manager replaces.
+ */
+export declare function makeCollectionPolicyResolver(policies: Map<string, NormalizedAutoTranslatePolicy>): AutoTranslatePolicyResolver;
+/**
+ * Publish-gate (#51 D8): a drafts-enabled collection auto-translates only on a **published** save;
+ * autosave/draft saves are ignored. A collection without drafts has no `_status`, so every save
+ * qualifies. Applies uniformly to create and update.
+ */
+export declare function passesPublishGate(doc: Record<string, unknown>, hasDrafts: boolean): boolean;
+/**
+ * Mirror the source document's status onto the translation (#51 D9). Combined with the publish-gate,
+ * the source is published whenever we reach enqueue, so translations publish; a no-drafts collection
+ * publishes too. Deliberately identical to {@link passesPublishGate} today — kept as a SEPARATE
+ * function (not merged) because it diverges once a future document-level manager (R8) can bypass the
+ * gate and translate a still-draft source; do not collapse the two.
+ */
+export declare function resolvePublishOnTranslation(doc: Record<string, unknown>, hasDrafts: boolean): boolean;
+/**
+ * Build one {@link TaskInput} per configured target locale (the source locale is always excluded).
+ * `waitUntil` encodes the debounce; `now` is injected so the timestamp is deterministic in tests.
+ */
+export declare function buildAutoTranslateTasks(args: {
+    policy: NormalizedAutoTranslatePolicy;
+    collectionSlug: CollectionSlug;
+    documentId: string;
+    sourceLocale: string;
+    doc: Record<string, unknown>;
+    hasDrafts: boolean;
+    now: number;
+}): TaskInput[];

package/dist/server/modules/auto-translate/AutoTranslate.policy.js

@@ -0,0 +1,77 @@
+/** Apply defaults to a raw config: strategy → "overwrite", debounce → 0. Duplicate target locales are
+ * de-duplicated so a misconfigured `targets: ["de","de"]` never enqueues two racing jobs for the same
+ * (document, locale) in one batch (the runner's supersession only dedupes against already-stored jobs). */ export function normalizeAutoTranslateConfig(config) {
+    return {
+        targets: [
+            ...new Set(config.targets)
+        ],
+        strategy: config.strategy ?? "overwrite",
+        debounceMs: config.debounceMs ?? 0,
+        sourceLocale: config.sourceLocale
+    };
+}
+/** Extract the configured locale codes, or `null` when localization is disabled/absent. */ export function extractLocaleCodes(localization) {
+    if (!localization) return null;
+    return new Set(localization.locales.map((locale)=>typeof locale === "string" ? locale : locale.code));
+}
+/**
+ * Drop targets (and a `sourceLocale` override) that are not configured locales, so a mistyped locale in
+ * `withAutoTranslate` never reaches the pipeline — where it would silently burn a provider call and
+ * either error at the DB (Postgres locale enum) or write orphaned, invisible data (Mongo/SQLite). Pure:
+ * returns a new policy and reports the drops; the caller (config-time wiring) emits the warning.
+ */ export function filterPolicyToKnownLocales(policy, knownLocales) {
+    const droppedTargets = policy.targets.filter((target)=>!knownLocales.has(target));
+    const sourceUnknown = policy.sourceLocale !== undefined && !knownLocales.has(policy.sourceLocale);
+    return {
+        policy: {
+            ...policy,
+            targets: policy.targets.filter((target)=>knownLocales.has(target)),
+            sourceLocale: sourceUnknown ? undefined : policy.sourceLocale
+        },
+        droppedTargets,
+        droppedSourceLocale: sourceUnknown ? policy.sourceLocale ?? null : null
+    };
+}
+/**
+ * The v1 (collection-level) resolver. Ignores `doc` — see {@link AutoTranslatePolicyResolver}. This is
+ * the single seam a future document-level manager replaces.
+ */ export function makeCollectionPolicyResolver(policies) {
+    return (collectionSlug, _doc)=>policies.get(collectionSlug) ?? null;
+}
+/**
+ * Publish-gate (#51 D8): a drafts-enabled collection auto-translates only on a **published** save;
+ * autosave/draft saves are ignored. A collection without drafts has no `_status`, so every save
+ * qualifies. Applies uniformly to create and update.
+ */ export function passesPublishGate(doc, hasDrafts) {
+    if (!hasDrafts) return true;
+    return doc._status === "published";
+}
+/**
+ * Mirror the source document's status onto the translation (#51 D9). Combined with the publish-gate,
+ * the source is published whenever we reach enqueue, so translations publish; a no-drafts collection
+ * publishes too. Deliberately identical to {@link passesPublishGate} today — kept as a SEPARATE
+ * function (not merged) because it diverges once a future document-level manager (R8) can bypass the
+ * gate and translate a still-draft source; do not collapse the two.
+ */ export function resolvePublishOnTranslation(doc, hasDrafts) {
+    if (!hasDrafts) return true;
+    return doc._status === "published";
+}
+/**
+ * Build one {@link TaskInput} per configured target locale (the source locale is always excluded).
+ * `waitUntil` encodes the debounce; `now` is injected so the timestamp is deterministic in tests.
+ */ export function buildAutoTranslateTasks(args) {
+    const { policy, collectionSlug, documentId, sourceLocale, doc, hasDrafts, now } = args;
+    const publishOnTranslation = resolvePublishOnTranslation(doc, hasDrafts);
+    const waitUntil = policy.debounceMs > 0 ? new Date(now + policy.debounceMs) : undefined;
+    return policy.targets.filter((target)=>target !== sourceLocale).map((target)=>({
+            collectionSlug,
+            collectionId: documentId,
+            sourceLng: sourceLocale,
+            targetLng: target,
+            strategy: policy.strategy,
+            publishOnTranslation,
+            waitUntil
+        }));
+}
+
+//# sourceMappingURL=AutoTranslate.policy.js.map

package/dist/server/modules/auto-translate/AutoTranslate.shapes.d.ts

@@ -0,0 +1,22 @@
+import type { CollectionAfterChangeHook } from "payload";
+/**
+ * The minimal slice of a Payload collection the auto-translate wiring mutates: its `slug` and the
+ * `afterChange` hook slot. A real `CollectionConfig` is structurally assignable to this, so call sites
+ * pass the live collection with no adapter and tests pass a `{ slug: "posts" }` literal. Keeps
+ * `injectAutoTranslateHook` off the god-`CollectionConfig` type (own shape — provenance's is not reused,
+ * per the module-owns-its-shape convention). The only Payload type imported is the hook callback
+ * contract, which legitimately stays framework-typed.
+ */
+export type AutoTranslateManagedEntry = {
+    slug: string;
+    hooks?: {
+        afterChange?: CollectionAfterChangeHook[];
+    };
+    /** The `custom` bag — the opt-in is propagated here so the admin UI can read it back off the
+     * REGISTERED collection (which may be a different object than the one `withAutoTranslate` wrapped). */
+    custom?: Record<string, unknown>;
+};
+/** The minimal config host: a mutable `collections` array. A real Payload `Config` plugs straight in. */
+export type AutoTranslateManagedConfig = {
+    collections?: AutoTranslateManagedEntry[];
+};

package/dist/server/modules/auto-translate/AutoTranslate.shapes.js

@@ -0,0 +1,3 @@
+/** The minimal config host: a mutable `collections` array. A real Payload `Config` plugs straight in. */ export { };
+
+//# sourceMappingURL=AutoTranslate.shapes.js.map

package/dist/server/modules/auto-translate/AutoTranslate.wiring.d.ts

@@ -0,0 +1,21 @@
+import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
+import type { ConfigModifier } from "../../../types/ConfigModifier";
+import type { TaskRunnerFactory } from "../task-runner";
+/** A collection as the plugin receives it — only `slug` + `custom` are read to resolve the opt-in. */
+type ConfigurableCollection = {
+    slug: string;
+    custom?: Record<string, unknown>;
+};
+/** Everything the auto-translate module contributes at config time (mirrors `ProvenanceModule`). */
+export type AutoTranslateModule = {
+    configure(managedSlugs: Set<string>): ConfigModifier;
+};
+/**
+ * Turn the opt-in `withAutoTranslate` config (read from each collection's `custom`) into a
+ * self-contained {@link AutoTranslateModule} — mirrors `configureProvenance`. Builds the per-collection
+ * policy map + resolver once, then returns a `configure(managedSlugs) → ConfigModifier` that injects a
+ * single best-effort `afterChange` hook onto every enabled + managed collection. When no collection
+ * opted in, `configure` is a no-op (no hook, no behaviour change).
+ */
+export declare function configureAutoTranslate(collections: ConfigurableCollection[], schemaMap: CollectionSchemaMap, taskRunnerFactory: TaskRunnerFactory): AutoTranslateModule;
+export {};

package/dist/server/modules/auto-translate/AutoTranslate.wiring.js

@@ -0,0 +1,68 @@
+import { getAutoTranslateConfig } from "../../../core/domain/auto-translate";
+import { extractLocaleCodes, filterPolicyToKnownLocales, makeCollectionPolicyResolver, normalizeAutoTranslateConfig } from "./AutoTranslate.policy";
+import { injectAutoTranslateHook, makeAutoTranslateHook, propagateAutoTranslateCustom } from "./AutoTranslateEnqueue.hook";
+const NOOP = (config)=>config;
+/** Emit one clear config-time warning per collection whose auto-translate config named unknown locales. */ function warnDroppedLocales(slug, filtered, knownLocales) {
+    const known = [
+        ...knownLocales
+    ].join(", ");
+    if (filtered.droppedTargets.length > 0) {
+        console.warn(`[payload-plugin-translator] auto-translate on "${slug}": ignoring unknown target locale(s) ${filtered.droppedTargets.join(", ")} (configured locales: ${known}).`);
+    }
+    if (filtered.droppedSourceLocale) {
+        console.warn(`[payload-plugin-translator] auto-translate on "${slug}": unknown sourceLocale "${filtered.droppedSourceLocale}" ignored, falling back to the default locale (configured locales: ${known}).`);
+    }
+}
+/**
+ * Turn the opt-in `withAutoTranslate` config (read from each collection's `custom`) into a
+ * self-contained {@link AutoTranslateModule} — mirrors `configureProvenance`. Builds the per-collection
+ * policy map + resolver once, then returns a `configure(managedSlugs) → ConfigModifier` that injects a
+ * single best-effort `afterChange` hook onto every enabled + managed collection. When no collection
+ * opted in, `configure` is a no-op (no hook, no behaviour change).
+ */ export function configureAutoTranslate(collections, schemaMap, taskRunnerFactory) {
+    const policies = new Map();
+    for (const collection of collections){
+        const config = getAutoTranslateConfig(collection);
+        if (config) policies.set(collection.slug, normalizeAutoTranslateConfig(config));
+    }
+    if (policies.size === 0) return {
+        configure: ()=>NOOP
+    };
+    const enabledSlugs = new Set(policies.keys());
+    const resolvePolicy = makeCollectionPolicyResolver(policies);
+    const hook = makeAutoTranslateHook({
+        resolvePolicy,
+        schemaMap,
+        taskRunnerFactory
+    });
+    return {
+        configure: (managedSlugs)=>(config)=>{
+                // Inject only onto collections that both opted in AND are plugin-managed.
+                const slugs = new Set([
+                    ...enabledSlugs
+                ].filter((slug)=>managedSlugs.has(slug)));
+                // Drop targets / source-locale overrides that are not configured locales, fail-fast with a
+                // warning at init — else a mistyped locale silently burns provider calls and orphans data at
+                // runtime. Filter the shared `policies` map once here (config-time, before any hook fires), so
+                // the hook, the propagated `custom`, and the admin indicator all read the corrected policy.
+                const knownLocales = extractLocaleCodes(config.localization);
+                if (knownLocales) {
+                    for (const slug of slugs){
+                        const policy = policies.get(slug);
+                        if (!policy) continue;
+                        const filtered = filterPolicyToKnownLocales(policy, knownLocales);
+                        warnDroppedLocales(slug, filtered, knownLocales);
+                        policies.set(slug, filtered.policy);
+                    }
+                } else if (slugs.size > 0) {
+                    console.warn("[payload-plugin-translator] auto-translate is configured but localization is disabled; no translations will be enqueued.");
+                }
+                injectAutoTranslateHook(config, slugs, hook);
+                // Mirror the opt-in onto the registered collection's `custom` so the admin UI can read it back.
+                propagateAutoTranslateCustom(config, slugs, policies);
+                return config;
+            }
+    };
+}
+
+//# sourceMappingURL=AutoTranslate.wiring.js.map