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

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

@@ -9,7 +9,7 @@ import { DocumentTranslationFormModel } from "../../../features/translate-docume
 import { handleFormError } from "../../../shared/lib/forms/handle-form-error";
 import { useCollectionDocumentUrlParams } from "../../../shared/lib/payload/hooks/useCollectionDocumentUrlParams";
 import styles from "./styles.module.scss";
-const TranslateDocument = ({ hasDrafts, autoTranslate })=>{
+const TranslateDocument = ({ hasDrafts, autoTranslate, targetSelection })=>{
     const locale = useLocale();
     const params = useCollectionDocumentUrlParams();
     const queueTranslationApi = TranslationsApi.useQueueDocumentTranslation();
@@ -42,12 +42,15 @@ const TranslateDocument = ({ hasDrafts, autoTranslate })=>{
     ]);
     const initialValues = useMemo(()=>({
             [FORM_FIELDS.SOURCE_LNG]: locale.code,
+            // Multi mode binds an array; single mode a string. Seed the matching empty value.
+            [FORM_FIELDS.TARGET_LNG]: targetSelection === "multi" ? [] : "",
             [FORM_FIELDS.HIDDEN_COLLECTION_SLUG]: params.collection,
             [FORM_FIELDS.HIDDEN_COLLECTION_ID]: params.id
         }), [
         locale.code,
         params.collection,
-        params.id
+        params.id,
+        targetSelection
     ]);
     const { form } = DocumentTranslationFormModel.useForm({
         initialValues
@@ -95,7 +98,8 @@ const TranslateDocument = ({ hasDrafts, autoTranslate })=>{
                             /*#__PURE__*/ _jsx(DocumentTranslationForm, {
                                 form: form,
                                 onSubmit: (formData)=>handleSubmit(formData, close),
-                                hasDrafts: hasDrafts
+                                hasDrafts: hasDrafts,
+                                targetSelection: targetSelection
                             })
                         ]
                     }),

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

@@ -1,8 +1,10 @@
 import type { BeforeDocumentControlsServerProps, CollectionConfig } from "payload";
 import type { AccessGuard } from "../../../../types/AccessGuard";
+import type { TargetSelectionMode } from "../../../../types/TargetSelection";
 type TranslateDocumentServerProps = BeforeDocumentControlsServerProps & {
     collection: CollectionConfig;
     access: AccessGuard;
+    targetSelection: TargetSelectionMode;
 };
 declare function TranslateDocumentServer(props: TranslateDocumentServerProps): Promise<import("react/jsx-runtime").JSX.Element | null>;
 export default TranslateDocumentServer;

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

@@ -18,7 +18,8 @@ async function TranslateDocumentServer(props) {
     const autoTranslate = resolveAutoTranslateSummary(props.collection, props.payload.config.localization ? props.payload.config.localization.defaultLocale : undefined);
     return /*#__PURE__*/ _jsx(TranslateDocument, {
         hasDrafts: hasDrafts,
-        autoTranslate: autoTranslate
+        autoTranslate: autoTranslate,
+        targetSelection: props.targetSelection
     });
 }
 export default TranslateDocumentServer;

package/dist/composition/levels/collectionLevel.js

@@ -16,7 +16,7 @@ import { useDocTranslationApi } from "./useDocTranslationApi";
     return {
         extend (ctx) {
             useDocTranslationApi(ctx);
-            ctx.addCollectionComponent("beforeListTable", ()=>new BulkDocumentTranslationDashboard(ctx.access));
+            ctx.addCollectionComponent("beforeListTable", ()=>new BulkDocumentTranslationDashboard(ctx.access, ctx.targetSelection));
         }
     };
 }

package/dist/composition/levels/documentLevel.js

@@ -20,7 +20,7 @@ import { useDocTranslationApi } from "./useDocTranslationApi";
     return {
         extend (ctx) {
             useDocTranslationApi(ctx);
-            ctx.addCollectionComponent("beforeDocumentControls", (collection)=>new TranslateDocumentExport(collection, ctx.access));
+            ctx.addCollectionComponent("beforeDocumentControls", (collection)=>new TranslateDocumentExport(collection, ctx.access, ctx.targetSelection));
         }
     };
 }

package/dist/core/kernel/field-traversal/index.d.ts

@@ -2,6 +2,7 @@ export { findFieldByPath } from "./findFieldByPath";
 export type { FieldPathResult } from "./findFieldByPath";
 export { hasFields, isBlockItem, isTabsField } from "./guards";
 export { classifyField, matchElementById, resolveBlockFields, tabScopes } from "./kernel";
+export { projectFieldsToFieldLike } from "./projectFieldLike";
 export { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType, tabHasName, } from "./predicates";
 export type { ArrayFieldLike, BlockLike, BlocksFieldLike, ChildCursor, ChildOutput, ContainerInfo, FieldLike, FieldStructure, FieldWalker, GroupFieldLike, LeafField, LeafFieldLike, TabLike, TabScope, TabsFieldLike, WalkSignal, } from "./types";
 export { walkFields } from "./walkFields";

package/dist/core/kernel/field-traversal/index.js

@@ -1,6 +1,7 @@
 export { findFieldByPath } from "./findFieldByPath";
 export { hasFields, isBlockItem, isTabsField } from "./guards";
 export { classifyField, matchElementById, resolveBlockFields, tabScopes } from "./kernel";
+export { projectFieldsToFieldLike } from "./projectFieldLike";
 export { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType, tabHasName } from "./predicates";
 export { walkFields } from "./walkFields";
 

package/dist/core/kernel/field-traversal/projectFieldLike.d.ts

@@ -0,0 +1,32 @@
+import type { FieldLike } from "./types";
+/**
+ * Deep-project a field schema into an independent {@link FieldLike} tree, copying ONLY the properties
+ * this layer reads. Replaces the `JSON.parse(JSON.stringify(fields))` clone the plugin used to snapshot
+ * a collection's schema before Payload's sanitizer mutates the originals.
+ *
+ * Why a bespoke projection rather than a structural clone:
+ * - **Independence is mandatory, not cosmetic.** Payload's `sanitizeFields` does `delete field.localized`
+ *   **in place** on any field nested under a localized ancestor (group/array/named tab). The pipeline
+ *   reads per-field `localized`, so a shared reference would silently lose it and the field would stop
+ *   being translated. Every field/container here is a NEW object, and `localized` is copied by value at
+ *   projection time (before sanitize runs), so the snapshot is preserved.
+ * - **`structuredClone` can't be used.** Field definitions embed Lexical editor configs containing async
+ *   functions, which `structuredClone` throws on. The old JSON round-trip "worked" only by silently
+ *   dropping every function; this projection drops them explicitly by copying a typed whitelist.
+ *
+ * The contract is exactly what the traversal/pipeline consumes: `type` (classify), `name`/`localized`
+ * (leaf data + translation gate), `custom` (only `custom.translateKit.exclude` is read), and the
+ * container members `fields` (group/array/row/collapsible/unnamed-group), `blocks` (with the
+ * load-bearing `block.slug` used for block-type dispatch), and `tabs` (named + unnamed). Every field is
+ * kept 1:1 (including presentational `ui`/`row`/`collapsible`) so downstream classification is unchanged;
+ * only the property set is narrowed.
+ *
+ * `custom` is copied by reference: it is a passthrough bag Payload does not mutate during sanitize (only
+ * `localized` is deleted, which we snapshot by value), and deep-copying it would re-introduce the
+ * `structuredClone`-on-functions problem this projection exists to avoid.
+ *
+ * @param fields - The source field list (Payload's `Field[]` is structurally assignable to `FieldLike[]`).
+ * @returns A new, independent `FieldLike[]` unaffected by later mutation of the source objects.
+ * @since 0.9.1
+ */
+export declare function projectFieldsToFieldLike(fields: FieldLike[]): FieldLike[];

package/dist/core/kernel/field-traversal/projectFieldLike.js

@@ -0,0 +1,60 @@
+function projectField(field) {
+    const out = {
+        type: field.type
+    };
+    if (field.name !== undefined) out.name = field.name;
+    if (field.localized !== undefined) out.localized = field.localized;
+    if (field.custom !== undefined) out.custom = field.custom;
+    if (field.fields) out.fields = field.fields.map(projectField);
+    if (field.blocks) {
+        out.blocks = field.blocks.map((block)=>({
+                slug: block.slug,
+                fields: block.fields.map(projectField)
+            }));
+    }
+    if (field.tabs) {
+        out.tabs = field.tabs.map((tab)=>{
+            const projected = {
+                fields: tab.fields.map(projectField)
+            };
+            if (tab.name !== undefined) projected.name = tab.name;
+            if (tab.localized !== undefined) projected.localized = tab.localized;
+            return projected;
+        });
+    }
+    return out;
+}
+/**
+ * Deep-project a field schema into an independent {@link FieldLike} tree, copying ONLY the properties
+ * this layer reads. Replaces the `JSON.parse(JSON.stringify(fields))` clone the plugin used to snapshot
+ * a collection's schema before Payload's sanitizer mutates the originals.
+ *
+ * Why a bespoke projection rather than a structural clone:
+ * - **Independence is mandatory, not cosmetic.** Payload's `sanitizeFields` does `delete field.localized`
+ *   **in place** on any field nested under a localized ancestor (group/array/named tab). The pipeline
+ *   reads per-field `localized`, so a shared reference would silently lose it and the field would stop
+ *   being translated. Every field/container here is a NEW object, and `localized` is copied by value at
+ *   projection time (before sanitize runs), so the snapshot is preserved.
+ * - **`structuredClone` can't be used.** Field definitions embed Lexical editor configs containing async
+ *   functions, which `structuredClone` throws on. The old JSON round-trip "worked" only by silently
+ *   dropping every function; this projection drops them explicitly by copying a typed whitelist.
+ *
+ * The contract is exactly what the traversal/pipeline consumes: `type` (classify), `name`/`localized`
+ * (leaf data + translation gate), `custom` (only `custom.translateKit.exclude` is read), and the
+ * container members `fields` (group/array/row/collapsible/unnamed-group), `blocks` (with the
+ * load-bearing `block.slug` used for block-type dispatch), and `tabs` (named + unnamed). Every field is
+ * kept 1:1 (including presentational `ui`/`row`/`collapsible`) so downstream classification is unchanged;
+ * only the property set is narrowed.
+ *
+ * `custom` is copied by reference: it is a passthrough bag Payload does not mutate during sanitize (only
+ * `localized` is deleted, which we snapshot by value), and deep-copying it would re-introduce the
+ * `structuredClone`-on-functions problem this projection exists to avoid.
+ *
+ * @param fields - The source field list (Payload's `Field[]` is structurally assignable to `FieldLike[]`).
+ * @returns A new, independent `FieldLike[]` unaffected by later mutation of the source objects.
+ * @since 0.9.1
+ */ export function projectFieldsToFieldLike(fields) {
+    return fields.map(projectField);
+}
+
+//# sourceMappingURL=projectFieldLike.js.map

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { translatorPlugin } from "./plugin";
 export type { TranslatorPluginConfig } from "./plugin";
+export type { TargetSelectionMode } from "./types/TargetSelection";
 export type { TranslationTask, TranslationLifecycleCallbacks } from "./server/modules/lifecycle";
 export type { TranslationProvenanceRecord } from "./core";
 export type { AccessGuard, AccessGuardRequest } from "./types/AccessGuard";

package/dist/plugin.d.ts

@@ -1,5 +1,6 @@
 import type { CollectionConfig, Config } from "payload";
 import type { AccessGuard } from "./types/AccessGuard";
+import type { TargetSelectionMode } from "./types/TargetSelection";
 import type { TranslationProvider } from "./core/domain/translation-providers";
 import type { TaskRunnerProvider } from "./server/modules/task-runner";
 import type { TranslationLifecycleCallbacks } from "./server/modules/lifecycle";
@@ -69,6 +70,15 @@ export type TranslatorPluginConfig = {
      * @since 0.7.0
      */
     lifecycle?: TranslationLifecycleCallbacks;
+    /**
+     * How the target-language field behaves in the translation forms. `'single'` (default) keeps
+     * today's one-locale-per-run behaviour, byte-identical. `'multi'` renders a compact multi-select so
+     * an editor can queue several target locales in one run — the run fans out one translation per
+     * `(document × target locale)`. Opt-in and fully backward-compatible; no schema, no migration.
+     * @default 'single'
+     * @since 0.10.0
+     */
+    targetSelection?: TargetSelectionMode;
 };
 /** @deprecated Use `TranslatorPluginConfig` instead */
 export type TranslateCollectionPluginConfig = TranslatorPluginConfig;

package/dist/plugin.js

@@ -1,6 +1,7 @@
 import { CacheProviderExport } from "./client/app/cache/CacheProvider.export";
 import { configureAutoTranslate } from "./server/modules/auto-translate";
 import { configureProvenance } from "./server/modules/provenance";
+import { projectFieldsToFieldLike } from "./core/kernel/field-traversal";
 import { wireTranslateRunner } from "./server/features/translate-document";
 import { documentLevel, collectionLevel } from "./composition/levels";
 import { PluginConfigBuilder } from "./server/modules/translation-levels/PluginConfigBuilder";
@@ -12,18 +13,16 @@ import { normalizePath } from "./server/shared";
     }
     init() {
         return async (config)=>{
-            const { access, translationProvider, runner, collections, levels, provenance, lifecycle, basePath: rawBasePath = "/translate" } = this.pluginConfig;
-            // Build schema map from deep-cloned collections.
-            // Deep clone is required because Payload mutates the original collection objects, removing
-            // `localized: true` from nested fields during sanitization. JSON round-trip (not
-            // structuredClone) because Lexical editor configs contain async functions structuredClone
-            // cannot handle.
-            // TODO: Consider introducing a FieldLike interface with only the properties used by the
-            // pipeline (name, type, localized, fields, blocks, tabs, custom) to make the contract explicit
-            // and avoid reliance on JSON round-trip.
+            const { access, translationProvider, runner, collections, levels, provenance, lifecycle, targetSelection = "single", basePath: rawBasePath = "/translate" } = this.pluginConfig;
+            // Snapshot each collection's schema as an independent FieldLike tree BEFORE Payload's sanitizer
+            // mutates the originals (it deletes `localized` from fields nested under a localized ancestor).
+            // `projectFieldsToFieldLike` deep-copies only the properties the pipeline reads — an explicit,
+            // typed contract, replacing the old JSON round-trip (which "worked" only by silently dropping the
+            // Lexical editor's async functions that structuredClone chokes on). Payload's `Field[]` is
+            // structurally assignable to `FieldLike[]`, so the projection happens right here at the boundary.
             const schemaMap = new Map(collections.map((col)=>[
                     col.slug,
-                    JSON.parse(JSON.stringify(col.fields))
+                    projectFieldsToFieldLike(col.fields)
                 ]));
             const collectionSlugs = new Set(schemaMap.keys());
             const basePath = normalizePath(rawBasePath);
@@ -51,7 +50,8 @@ import { normalizePath } from "./server/shared";
                 taskRunnerFactory,
                 schemaMap,
                 translationProvider,
-                provenanceServiceFactory: provenanceModule.serviceFactory
+                provenanceServiceFactory: provenanceModule.serviceFactory,
+                targetSelection
             });
             for (const level of activeLevels)level.extend(builder);
             builder.addConfigModifier(runnerConfigModifier);

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

@@ -1,6 +1,8 @@
 import { ServerResponse } from "../../shared";
+import { extractLocaleCodes } from "../../modules/auto-translate";
 import { isCollectionAvailable, getAllCollectionIds } from "../_lib/collection-utils";
 import { EnqueueInputSchema } from "./model";
+import { resolveTargetLocales } from "./resolveTargetLocales";
 /**
  * Enqueues translation tasks for documents
  */ export class EnqueueTranslationHandler {
@@ -16,16 +18,34 @@ import { EnqueueInputSchema } from "./model";
         const { source_lng, target_lng, collection_slug, collection_id, select_all, strategy, publish_on_translation } = validationResult.data;
         const collectionSlug = isCollectionAvailable(collection_slug, this.config.availableCollections);
         if (!collectionSlug) return ServerResponse.badRequest("Content of this collection is not available for translation");
+        // Normalize the scalar-or-array target into the concrete locales to fan out to: de-dup, exclude the
+        // source, and drop locales that are not configured (unknown locales would burn a provider call and
+        // corrupt data — Postgres locale enum / orphaned Mongo rows). `config` is optional-chained because a
+        // localization-less (or minimally-mocked) payload has none, which correctly disables the filter.
+        const knownLocales = extractLocaleCodes(req.payload.config?.localization);
+        const { targets, droppedUnknown } = resolveTargetLocales({
+            target_lng,
+            source_lng,
+            knownLocales
+        });
+        if (droppedUnknown.length > 0) {
+            req.payload.logger?.warn(`[payload-plugin-translator] enqueue on "${collectionSlug}": ignoring unknown target locale(s) ${droppedUnknown.join(", ")} (configured locales: ${knownLocales ? [
+                ...knownLocales
+            ].join(", ") : "n/a"}).`);
+        }
+        if (targets.length === 0) return ServerResponse.badRequest("No valid target locales to translate into (all requested locales were the source or unknown)");
         const collectionIds = select_all ? await getAllCollectionIds(req.payload, collectionSlug) : collection_id;
         const runner = this.taskRunnerFactory.create(req.payload);
-        const tasks = collectionIds.map((id)=>({
-                collectionSlug,
-                collectionId: id,
-                sourceLng: source_lng,
-                targetLng: target_lng,
-                strategy: strategy,
-                publishOnTranslation: publish_on_translation
-            }));
+        // One task per (document x target locale). The runner keys/supersedes per (document, targetLng),
+        // so N concurrent targets of one document coexist (PR #75) — no runner change needed.
+        const tasks = collectionIds.flatMap((id)=>targets.map((targetLng)=>({
+                    collectionSlug,
+                    collectionId: id,
+                    sourceLng: source_lng,
+                    targetLng,
+                    strategy: strategy,
+                    publishOnTranslation: publish_on_translation
+                })));
         await runner.enqueue(tasks);
         return ServerResponse.success({
             success: true,

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

@@ -5,7 +5,7 @@ import type { CollectionSlug } from "payload";
  */
 export declare const EnqueueInputSchema: z.ZodObject<{
     source_lng: z.ZodString;
-    target_lng: z.ZodString;
+    target_lng: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
     collection_slug: z.ZodString;
     collection_id: z.ZodArray<z.ZodString, "atleastone">;
     select_all: z.ZodOptional<z.ZodBoolean>;
@@ -15,7 +15,7 @@ export declare const EnqueueInputSchema: z.ZodObject<{
     collection_slug: string;
     collection_id: [string, ...string[]];
     source_lng: string;
-    target_lng: string;
+    target_lng: string | string[];
     strategy: "overwrite" | "skip_existing";
     publish_on_translation: boolean;
     select_all?: boolean | undefined;
@@ -23,7 +23,7 @@ export declare const EnqueueInputSchema: z.ZodObject<{
     collection_slug: string;
     collection_id: [string, ...string[]];
     source_lng: string;
-    target_lng: string;
+    target_lng: string | string[];
     strategy?: "overwrite" | "skip_existing" | undefined;
     publish_on_translation?: boolean | undefined;
     select_all?: boolean | undefined;

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

@@ -3,7 +3,12 @@ import { z } from "zod";
  * Input validation schema
  */ export const EnqueueInputSchema = z.object({
     source_lng: z.string().nonempty(),
-    target_lng: z.string().nonempty(),
+    // Accept a single locale (back-compat) OR a non-empty list, for multi-target fan-out. The empty
+    // array is rejected here so an empty multi-select is a validation error, not a silent no-op.
+    target_lng: z.union([
+        z.string().nonempty(),
+        z.array(z.string().nonempty()).min(1)
+    ]),
     collection_slug: z.string().nonempty(),
     collection_id: z.array(z.coerce.string()).nonempty(),
     select_all: z.boolean().optional(),

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

@@ -0,0 +1,29 @@
+/**
+ * Resolved target locales for a manual enqueue, plus what was dropped so the handler can log precisely.
+ */
+export type ResolvedTargetLocales = {
+    /** The concrete locales to fan out to — de-duplicated, source excluded, unknown removed. */
+    targets: string[];
+    /** Requested locales that are not configured (dropped) — empty when localization is unknown/disabled. */
+    droppedUnknown: string[];
+    /** Whether the source locale was requested as a target and excluded. */
+    droppedSource: boolean;
+};
+/**
+ * Normalize the enqueue `target_lng` input (scalar or array) into the concrete list of target locales
+ * to translate into. Applies, in order: array-coercion, de-duplication (first-seen order preserved),
+ * source-locale exclusion, and — when the configured locale set is known — dropping unknown locales.
+ *
+ * De-dup and unknown-dropping are the manual-enqueue counterparts of the auto-translate policy filter:
+ * the runner only supersedes against already-stored jobs, so duplicates within one enqueue must be
+ * collapsed here; and an unknown locale must never reach the pipeline — it burns a provider call and
+ * either errors on a Postgres locale enum or writes orphaned, invisible data on Mongo/SQLite.
+ *
+ * @param knownLocales - the configured locale codes, or `null` when localization is disabled/absent
+ *   (then no unknown-dropping is applied — every requested locale except the source is kept).
+ */
+export declare function resolveTargetLocales(args: {
+    target_lng: string | string[];
+    source_lng: string;
+    knownLocales: Set<string> | null;
+}): ResolvedTargetLocales;

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

@@ -0,0 +1,41 @@
+/**
+ * Resolved target locales for a manual enqueue, plus what was dropped so the handler can log precisely.
+ */ /**
+ * Normalize the enqueue `target_lng` input (scalar or array) into the concrete list of target locales
+ * to translate into. Applies, in order: array-coercion, de-duplication (first-seen order preserved),
+ * source-locale exclusion, and — when the configured locale set is known — dropping unknown locales.
+ *
+ * De-dup and unknown-dropping are the manual-enqueue counterparts of the auto-translate policy filter:
+ * the runner only supersedes against already-stored jobs, so duplicates within one enqueue must be
+ * collapsed here; and an unknown locale must never reach the pipeline — it burns a provider call and
+ * either errors on a Postgres locale enum or writes orphaned, invisible data on Mongo/SQLite.
+ *
+ * @param knownLocales - the configured locale codes, or `null` when localization is disabled/absent
+ *   (then no unknown-dropping is applied — every requested locale except the source is kept).
+ */ export function resolveTargetLocales(args) {
+    const { target_lng, source_lng, knownLocales } = args;
+    const requested = Array.isArray(target_lng) ? target_lng : [
+        target_lng
+    ];
+    const deduped = [
+        ...new Set(requested)
+    ];
+    const droppedSource = deduped.includes(source_lng);
+    const withoutSource = deduped.filter((target)=>target !== source_lng);
+    if (!knownLocales) {
+        return {
+            targets: withoutSource,
+            droppedUnknown: [],
+            droppedSource
+        };
+    }
+    const droppedUnknown = withoutSource.filter((target)=>!knownLocales.has(target));
+    const targets = withoutSource.filter((target)=>knownLocales.has(target));
+    return {
+        targets,
+        droppedUnknown,
+        droppedSource
+    };
+}
+
+//# sourceMappingURL=resolveTargetLocales.js.map

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

@@ -1,4 +1,4 @@
-import type { Field } from "payload";
+import type { FieldLike } from "../../../core/kernel/field-traversal";
 /**
  * Outcome of mapping a declared field path to a translatable subtree.
  *
@@ -14,7 +14,7 @@ import type { Field } from "payload";
  */
 export type FieldSubtreeResolution = {
     status: "resolved";
-    schema: Field[];
+    schema: FieldLike[];
     sourceData: Record<string, unknown>;
     fieldName: string;
 } | {
@@ -36,4 +36,4 @@ export type FieldSubtreeResolution = {
  * the element's `blockType` in `doc` picks the block schema. Without `doc`, a path through a
  * `blocks` field returns `inside-blocks`.
  */
-export declare function resolveFieldSubtree(rootFields: Field[], fieldPath: string, value: unknown, doc?: unknown): FieldSubtreeResolution;
+export declare function resolveFieldSubtree(rootFields: FieldLike[], fieldPath: string, value: unknown, doc?: unknown): FieldSubtreeResolution;

package/dist/server/modules/auto-translate/index.d.ts

@@ -2,3 +2,5 @@ export { configureAutoTranslate } from "./AutoTranslate.wiring";
 export type { AutoTranslateModule } from "./AutoTranslate.wiring";
 export { makeAutoTranslateHook, injectAutoTranslateHook } from "./AutoTranslateEnqueue.hook";
 export type { AutoTranslatePolicyResolver, NormalizedAutoTranslatePolicy, } from "./AutoTranslate.policy";
+export { extractLocaleCodes } from "./AutoTranslate.policy";
+export type { LocalizationLike } from "./AutoTranslate.policy";

package/dist/server/modules/auto-translate/index.js

@@ -3,5 +3,7 @@
 // wiring + the afterChange hook that enqueues translations on a source-locale change (#51).
 export { configureAutoTranslate } from "./AutoTranslate.wiring";
 export { makeAutoTranslateHook, injectAutoTranslateHook } from "./AutoTranslateEnqueue.hook";
+// Generic locale-set extraction, reused by the manual enqueue path to validate multi-target input.
+export { extractLocaleCodes } from "./AutoTranslate.policy";
 
 //# sourceMappingURL=index.js.map

package/dist/server/modules/translation-levels/PluginConfigBuilder.d.ts

@@ -2,6 +2,7 @@ import type { CollectionConfig, Config, Endpoint } from "payload";
 import type { AccessGuard } from "../../../types/AccessGuard";
 import type { RawPayloadComponentExport } from "../../../types/PayloadComponentExport";
 import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
+import type { TargetSelectionMode } from "../../../types/TargetSelection";
 import type { ConfigModifier } from "../../../types/ConfigModifier";
 import type { TranslationProvider } from "../../../core/domain/translation-providers";
 import type { TaskRunnerFactory } from "../task-runner";
@@ -28,6 +29,7 @@ export declare class PluginConfigBuilder implements LevelContext {
     readonly schemaMap: CollectionSchemaMap;
     readonly translationProvider: TranslationProvider;
     readonly provenanceServiceFactory?: ProvenanceServiceFactory;
+    readonly targetSelection: TargetSelectionMode;
     private readonly endpoints;
     private readonly collectionComponents;
     private readonly adminProviders;

package/dist/server/modules/translation-levels/PluginConfigBuilder.js

@@ -35,6 +35,7 @@ function attachToSlot(collection, slot, component) {
     schemaMap;
     translationProvider;
     provenanceServiceFactory;
+    targetSelection;
     endpoints = [];
     collectionComponents = [];
     adminProviders = [];
@@ -47,6 +48,7 @@ function attachToSlot(collection, slot, component) {
         this.schemaMap = deps.schemaMap;
         this.translationProvider = deps.translationProvider;
         this.provenanceServiceFactory = deps.provenanceServiceFactory;
+        this.targetSelection = deps.targetSelection;
     }
     addEndpoints(endpoints) {
         this.endpoints.push(...endpoints);

package/dist/server/modules/translation-levels/types.d.ts

@@ -2,6 +2,7 @@ import type { CollectionConfig, Endpoint } from "payload";
 import type { AccessGuard } from "../../../types/AccessGuard";
 import type { RawPayloadComponentExport } from "../../../types/PayloadComponentExport";
 import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
+import type { TargetSelectionMode } from "../../../types/TargetSelection";
 import type { TranslationProvider } from "../../../core/domain/translation-providers";
 import type { TaskRunnerFactory } from "../task-runner";
 import type { ProvenanceServiceFactory } from "../provenance";
@@ -23,6 +24,9 @@ export type TranslationContext = {
     readonly translationProvider: TranslationProvider;
     /** Builds a provenance service; absent when provenance is disabled (staleness then reports empty). */
     readonly provenanceServiceFactory?: ProvenanceServiceFactory;
+    /** Resolved target-language selection mode (`'single'` default) — drives which target control the
+     * admin forms render. */
+    readonly targetSelection: TargetSelectionMode;
 };
 /**
  * A composable translation surface (document / collection / field).

package/dist/types/CollectionSchemaMap.d.ts

@@ -1,6 +1,9 @@
-import type { CollectionSlug, Field } from "payload";
+import type { CollectionSlug } from "payload";
+import type { FieldLike } from "../core/kernel/field-traversal";
 /**
- * Map of collection slug to original field schema.
- * Used to access original schemas before Payload sanitization.
+ * Map of collection slug to its projected field schema — an independent {@link FieldLike} snapshot
+ * taken (via `projectFieldsToFieldLike`) before Payload's sanitizer mutates the originals, so nested
+ * `localized` flags survive. Typed as `FieldLike[]` (not Payload's `Field[]`) because every consumer
+ * reads it structurally as `FieldLike`; the projection is the boundary that makes that explicit.
  */
-export type CollectionSchemaMap = Map<CollectionSlug, Field[]>;
+export type CollectionSchemaMap = Map<CollectionSlug, FieldLike[]>;

package/dist/types/CollectionSchemaMap.js

@@ -1,6 +1,8 @@
 /**
- * Map of collection slug to original field schema.
- * Used to access original schemas before Payload sanitization.
+ * Map of collection slug to its projected field schema — an independent {@link FieldLike} snapshot
+ * taken (via `projectFieldsToFieldLike`) before Payload's sanitizer mutates the originals, so nested
+ * `localized` flags survive. Typed as `FieldLike[]` (not Payload's `Field[]`) because every consumer
+ * reads it structurally as `FieldLike`; the projection is the boundary that makes that explicit.
  */ export { };
 
 //# sourceMappingURL=CollectionSchemaMap.js.map

package/dist/types/TargetSelection.d.ts

@@ -0,0 +1,10 @@
+/**
+ * How the target-language field behaves in the translation forms (bulk dashboard + per-document panel).
+ *
+ * - `'single'` (default): one target locale per run — today's behaviour, unchanged.
+ * - `'multi'`: the editor picks several target locales and the run fans out one translation per
+ *   `(document × target locale)`; the target field renders a compact multi-select.
+ *
+ * @since 0.10.0
+ */
+export type TargetSelectionMode = "single" | "multi";

package/dist/types/TargetSelection.js

@@ -0,0 +1,11 @@
+/**
+ * How the target-language field behaves in the translation forms (bulk dashboard + per-document panel).
+ *
+ * - `'single'` (default): one target locale per run — today's behaviour, unchanged.
+ * - `'multi'`: the editor picks several target locales and the run fans out one translation per
+ *   `(document × target locale)`; the target field renders a compact multi-select.
+ *
+ * @since 0.10.0
+ */ export { };
+
+//# sourceMappingURL=TargetSelection.js.map

package/package.json

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

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslations.d.ts

@@ -1,8 +0,0 @@
-type Variables = {
-    source_lng: string;
-    target_lng: string;
-    collection_slug: string;
-    collection_id: Array<string | number>;
-};
-export declare function useQueueDocumentTranslations(): import("@tanstack/react-query").UseMutationResult<void, Error, Variables, unknown>;
-export {};

package/dist/client/entities/translation/api/mutations/useQueueDocumentTranslations.js

@@ -1,20 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { ofetch } from "ofetch";
-import { useTranslateKitConfig } from "../../../../app/config";
-import { handleNextApiError } from "../../../../shared/lib/errors/handleApiError";
-export function useQueueDocumentTranslations() {
-    const { basePath } = useTranslateKitConfig();
-    return useMutation({
-        mutationKey: [
-            "queue-document-translations"
-        ],
-        mutationFn: async (variables)=>{
-            await handleNextApiError(()=>ofetch(`/api${basePath}/enqueue-many`, {
-                    method: "post",
-                    body: variables
-                }));
-        }
-    });
-}
-
-//# sourceMappingURL=useQueueDocumentTranslations.js.map