@focus-reactive/payload-plugin-translator 0.8.1 → 0.9.0

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/auto-translate-config";
+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

package/dist/server/modules/auto-translate/AutoTranslateEnqueue.hook.d.ts

@@ -0,0 +1,39 @@
+import type { CollectionAfterChangeHook } from "payload";
+import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
+import type { TaskRunnerFactory } from "../task-runner";
+import type { AutoTranslatePolicyResolver, NormalizedAutoTranslatePolicy } from "./AutoTranslate.policy";
+import type { AutoTranslateManagedConfig } from "./AutoTranslate.shapes";
+type AutoTranslateHookDeps = {
+    resolvePolicy: AutoTranslatePolicyResolver;
+    schemaMap: CollectionSchemaMap;
+    taskRunnerFactory: TaskRunnerFactory;
+};
+/**
+ * Build the `afterChange` hook that auto-enqueues translations when a document's source-locale content
+ * changes. Thin orchestration only — every decision lives in `AutoTranslate.policy.ts` or the core
+ * drift predicate. Best-effort by contract: any failure is logged and swallowed, never failing the
+ * editor's save.
+ *
+ * Order (cheap guards first): (1) skip the translator's own writes via the `req.context` flag;
+ * (2) resolve the policy — off ⇒ skip; (3) resolve the source locale (per-collection override else
+ * `localization.defaultLocale`) — unresolved ⇒ log + skip; (4) skip non-source-locale writes (the
+ * pipeline's target writes never match); (5) publish-gate (D8); (6) drift-gate (D3); then enqueue one
+ * job per target locale.
+ */
+export declare function makeAutoTranslateHook(deps: AutoTranslateHookDeps): CollectionAfterChangeHook;
+/**
+ * Attach the auto-translate hook to every enabled collection on `config`, appending to any
+ * consumer-supplied `afterChange` array. Idempotent: a collection that already carries the marked hook
+ * is skipped, so a repeated `init()` never stacks duplicates.
+ */
+export declare function injectAutoTranslateHook(config: AutoTranslateManagedConfig, enabledSlugs: Set<string>, hook: CollectionAfterChangeHook): void;
+/**
+ * Propagate each enabled collection's resolved policy onto the REGISTERED collection's `custom` bag, so
+ * the admin UI can read the opt-in back via `getAutoTranslateConfig`. This is required because
+ * `withAutoTranslate` stamps `custom` on the object passed to the plugin's `collections` param, which
+ * can be a DIFFERENT object than the one registered in `buildConfig.collections` (the reader would
+ * otherwise see no config and the indicator would disagree with the behaviour). Idempotent + additive:
+ * re-stamping the same value is a no-op and the behaviour wiring still reads from the plugin param.
+ */
+export declare function propagateAutoTranslateCustom(config: AutoTranslateManagedConfig, enabledSlugs: Set<string>, policies: Map<string, NormalizedAutoTranslatePolicy>): void;
+export {};

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

@@ -0,0 +1,94 @@
+import { hasSourceContentChanged } from "../../../core/auto-translate";
+import { AUTO_TRANSLATE_CUSTOM_KEY } from "../../../core/auto-translate-config";
+import { AUTO_TRANSLATE_SKIP_CONTEXT_KEY } from "../../../types/AutoTranslateContext";
+import { buildAutoTranslateTasks, passesPublishGate } from "./AutoTranslate.policy";
+/**
+ * Build the `afterChange` hook that auto-enqueues translations when a document's source-locale content
+ * changes. Thin orchestration only — every decision lives in `AutoTranslate.policy.ts` or the core
+ * drift predicate. Best-effort by contract: any failure is logged and swallowed, never failing the
+ * editor's save.
+ *
+ * Order (cheap guards first): (1) skip the translator's own writes via the `req.context` flag;
+ * (2) resolve the policy — off ⇒ skip; (3) resolve the source locale (per-collection override else
+ * `localization.defaultLocale`) — unresolved ⇒ log + skip; (4) skip non-source-locale writes (the
+ * pipeline's target writes never match); (5) publish-gate (D8); (6) drift-gate (D3); then enqueue one
+ * job per target locale.
+ */ export function makeAutoTranslateHook(deps) {
+    const { resolvePolicy, schemaMap, taskRunnerFactory } = deps;
+    const hook = async ({ doc, previousDoc, req, collection })=>{
+        try {
+            if (req.context?.[AUTO_TRANSLATE_SKIP_CONTEXT_KEY]) return doc;
+            const policy = resolvePolicy(collection.slug, doc);
+            if (!policy) return doc;
+            const localization = req.payload.config.localization;
+            const sourceLocale = policy.sourceLocale ?? (localization ? localization.defaultLocale : undefined);
+            if (!sourceLocale) {
+                req.payload.logger.warn({
+                    collection: collection.slug,
+                    documentId: String(doc.id),
+                    msg: "translator: auto-translate skipped — no source locale resolvable (set localization.defaultLocale or a per-collection sourceLocale)"
+                });
+                return doc;
+            }
+            if (req.locale !== sourceLocale) return doc;
+            const hasDrafts = Boolean(collection.versions && collection.versions.drafts);
+            if (!passesPublishGate(doc, hasDrafts)) return doc;
+            const schema = schemaMap.get(collection.slug);
+            if (schema && !hasSourceContentChanged(previousDoc, doc, schema)) return doc;
+            const tasks = buildAutoTranslateTasks({
+                policy,
+                collectionSlug: collection.slug,
+                documentId: String(doc.id),
+                sourceLocale,
+                doc,
+                hasDrafts,
+                now: Date.now()
+            });
+            if (tasks.length === 0) return doc;
+            await taskRunnerFactory.create(req.payload).enqueue(tasks);
+        } catch (error) {
+            req.payload.logger.error({
+                err: error,
+                collection: collection.slug,
+                documentId: String(doc.id),
+                msg: "translator: auto-translate hook failed"
+            });
+        }
+        return doc;
+    };
+    hook.__translatorAutoTranslate = true;
+    return hook;
+}
+/**
+ * Attach the auto-translate hook to every enabled collection on `config`, appending to any
+ * consumer-supplied `afterChange` array. Idempotent: a collection that already carries the marked hook
+ * is skipped, so a repeated `init()` never stacks duplicates.
+ */ export function injectAutoTranslateHook(config, enabledSlugs, hook) {
+    for (const collection of config.collections ?? []){
+        if (!enabledSlugs.has(collection.slug)) continue;
+        collection.hooks ??= {};
+        collection.hooks.afterChange ??= [];
+        const alreadyInjected = collection.hooks.afterChange.some((existing)=>existing.__translatorAutoTranslate === true);
+        if (!alreadyInjected) collection.hooks.afterChange.push(hook);
+    }
+}
+/**
+ * Propagate each enabled collection's resolved policy onto the REGISTERED collection's `custom` bag, so
+ * the admin UI can read the opt-in back via `getAutoTranslateConfig`. This is required because
+ * `withAutoTranslate` stamps `custom` on the object passed to the plugin's `collections` param, which
+ * can be a DIFFERENT object than the one registered in `buildConfig.collections` (the reader would
+ * otherwise see no config and the indicator would disagree with the behaviour). Idempotent + additive:
+ * re-stamping the same value is a no-op and the behaviour wiring still reads from the plugin param.
+ */ export function propagateAutoTranslateCustom(config, enabledSlugs, policies) {
+    for (const collection of config.collections ?? []){
+        if (!enabledSlugs.has(collection.slug)) continue;
+        const policy = policies.get(collection.slug);
+        if (!policy) continue;
+        collection.custom = {
+            ...collection.custom ?? {},
+            [AUTO_TRANSLATE_CUSTOM_KEY]: policy
+        };
+    }
+}
+
+//# sourceMappingURL=AutoTranslateEnqueue.hook.js.map

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

@@ -0,0 +1,4 @@
+export { configureAutoTranslate } from "./AutoTranslate.wiring";
+export type { AutoTranslateModule } from "./AutoTranslate.wiring";
+export { makeAutoTranslateHook, injectAutoTranslateHook } from "./AutoTranslateEnqueue.hook";
+export type { AutoTranslatePolicyResolver, NormalizedAutoTranslatePolicy, } from "./AutoTranslate.policy";

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

@@ -0,0 +1,7 @@
+// Auto-translate adapter (Payload-backed). The payload-free drift predicate + config reader live in
+// the core (src/core/auto-translate*, src/core/content-projection); this module is the config-time
+// wiring + the afterChange hook that enqueues translations on a source-locale change (#51).
+export { configureAutoTranslate } from "./AutoTranslate.wiring";
+export { makeAutoTranslateHook, injectAutoTranslateHook } from "./AutoTranslateEnqueue.hook";
+
+//# sourceMappingURL=index.js.map

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

@@ -1,4 +1,8 @@
 import { normalizeJob } from "./normalizeJob";
+// A translation job's supersession identity: same document AND same target locale. IDs are
+// String()-normalized to match the stored (string) form, so a number id compares equal to its
+// persisted job.
+const documentLocaleKey = (collectionId, targetLng)=>`${String(collectionId)}:${targetLng}`;
 /**
  * TaskRunner implementation using Payload Jobs.
  *
@@ -15,13 +19,22 @@ import { normalizeJob } from "./normalizeJob";
         for (const [collectionSlug, items] of byCollection){
             const documentIds = items.map((t)=>t.collectionId);
             const existing = await this.findByCollection(collectionSlug, documentIds);
-            if (existing.length > 0) {
-                await this.cancelInternal(existing.map((t)=>t.id));
+            // Supersede only jobs for the SAME (document, target locale) being re-enqueued — never a
+            // concurrent job for a *different* locale of the same document. Cancelling per-document would
+            // kill an in-flight translation of another locale (the concurrent re-translate bug).
+            const supersededKeys = new Set(items.map((t)=>documentLocaleKey(t.collectionId, t.targetLng)));
+            const toCancel = existing.filter((t)=>supersededKeys.has(documentLocaleKey(t.input.collectionId, t.input.targetLng)));
+            if (toCancel.length > 0) {
+                await this.cancelInternal(toCancel.map((t)=>t.id));
             }
         }
         await Promise.all(tasks.map((task)=>this.payload.jobs.queue({
                 task: this.config.taskName,
                 queue: this.config.queueName,
+                // Debounce: when set, Payload holds the job until this instant. A superseding enqueue for
+                // the same (document, targetLng) cancels the pending delayed job first (see enqueue above),
+                // so rapid source edits coalesce to the final one. Undefined for the manual path.
+                waitUntil: task.waitUntil,
                 input: {
                     // Flat text reference (ID-agnostic). Stored as a string — no
                     // relationship type validation against the collection's ID type,

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

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

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

@@ -23,6 +23,13 @@ export type TaskInput = {
     targetLng: string;
     strategy: "overwrite" | "skip_existing";
     publishOnTranslation: boolean;
+    /**
+     * Optional scheduled-run time (debounce). When set, the job runs no earlier than this instant;
+     * omitted/`undefined` = run as soon as the runner picks it up (every existing caller). Honored by
+     * the Payload Jobs runner via `payload.jobs.queue({ waitUntil })`; the sync (dev) runner ignores it
+     * and runs immediately.
+     */
+    waitUntil?: Date;
 };
 /**
  * Normalized task representation

package/dist/types/AutoTranslateContext.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The `req.context` flag the translator sets on its OWN document writes so the auto-translate
+ * `afterChange` hook skips them — the loop guard's second barrier (#51 D5). A single exported constant
+ * shared by the setter (`TranslateDocumentHandler.saveTranslatedDocument`) and the reader (the
+ * auto-translate hook), so the set-side and honor-side keys can never diverge.
+ *
+ * Lives in `types/` (a leaf contract) so both `server/features/translate-document` and
+ * `server/modules/auto-translate` import it without creating a cross-module edge.
+ */
+export declare const AUTO_TRANSLATE_SKIP_CONTEXT_KEY = "translatorSkipAutoTranslate";

package/dist/types/AutoTranslateContext.js

@@ -0,0 +1,11 @@
+/**
+ * The `req.context` flag the translator sets on its OWN document writes so the auto-translate
+ * `afterChange` hook skips them — the loop guard's second barrier (#51 D5). A single exported constant
+ * shared by the setter (`TranslateDocumentHandler.saveTranslatedDocument`) and the reader (the
+ * auto-translate hook), so the set-side and honor-side keys can never diverge.
+ *
+ * Lives in `types/` (a leaf contract) so both `server/features/translate-document` and
+ * `server/modules/auto-translate` import it without creating a cross-module edge.
+ */ export const AUTO_TRANSLATE_SKIP_CONTEXT_KEY = "translatorSkipAutoTranslate";
+
+//# sourceMappingURL=AutoTranslateContext.js.map

package/package.json

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