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

package/dist/server/modules/provenance/Provenance.service.js

@@ -0,0 +1,124 @@
+import { computeSourceFingerprint } from "../../../core/content-projection/computeSourceFingerprint";
+import { isRecordStale } from "../../../core/provenance";
+import { fetchSourceDocument } from "../../shared/payload/sourceDocument";
+/**
+ * The single owner of provenance fingerprint policy — how the source is hashed on write, re-hashed on
+ * read, and compared for staleness. The write path and the read path go through this one class, so
+ * they can never drift (the biggest correctness trap in staleness detection). Sits above the CRUD
+ * {@link ProvenanceStore} port; the port + `computeSourceFingerprint` + `isRecordStale` stay
+ * framework-agnostic in the core.
+ *
+ * Best-effort by contract: fingerprint/record failures log and no-op rather than failing a translation.
+ */ export class ProvenanceService {
+    payload;
+    store;
+    schemaMap;
+    constructor(payload, store, schemaMap){
+        this.payload = payload;
+        this.store = store;
+        this.schemaMap = schemaMap;
+    }
+    /**
+   * Hash the PRISTINE source. The caller MUST pass source fetched **before** the translation pipeline
+   * runs — the pipeline mutates object-valued leaves (e.g. richText nodes) in place, so hashing after
+   * it would capture the target translation and make every fresh translation look instantly stale.
+   * Returns `null` on any failure (no schema, hashing error) so provenance is skipped, not the translation.
+   */ captureFingerprint(collection, sourceData) {
+        const schema = this.schemaMap.get(collection);
+        if (!schema) return null;
+        try {
+            return computeSourceFingerprint(sourceData, schema);
+        } catch (error) {
+            this.payload.logger.error({
+                err: error,
+                collection,
+                msg: "translator: failed to fingerprint source for provenance"
+            });
+            return null;
+        }
+    }
+    /** Persist a translation receipt (best-effort; a store failure logs and no-ops). */ async record(key, sourceFingerprint) {
+        try {
+            await this.store.upsert({
+                collectionSlug: key.collectionSlug,
+                documentId: key.documentId,
+                targetLocale: key.targetLocale,
+                sourceLocale: key.sourceLocale,
+                sourceFingerprint,
+                translatedAt: new Date().toISOString(),
+                dismissedFingerprint: null
+            });
+        } catch (error) {
+            this.payload.logger.error({
+                err: error,
+                collection: key.collectionSlug,
+                documentId: key.documentId,
+                targetLocale: key.targetLocale,
+                sourceLocale: key.sourceLocale,
+                msg: "translator: failed to record translation provenance"
+            });
+        }
+    }
+    /**
+   * Per-locale staleness for one document: read every receipt, recompute the current source
+   * fingerprint (write-path-identical), and mark each locale stale on undismissed drift. Returns `[]`
+   * when the collection has no schema. Isolates per-locale failures so one bad record can't blank the rest.
+   */ async getStaleness(collection, documentId) {
+        const schema = this.schemaMap.get(collection);
+        if (!schema) return [];
+        const records = await this.store.findByDocument(collection, documentId);
+        if (records.length === 0) return [];
+        const currentFingerprint = this.makeCurrentFingerprint(collection, documentId, schema);
+        const locales = [];
+        for (const record of records){
+            try {
+                const current = await currentFingerprint(record.sourceLocale);
+                locales.push({
+                    target_lng: record.targetLocale,
+                    source_lng: record.sourceLocale,
+                    is_stale: isRecordStale(record, current),
+                    translated_at: record.translatedAt
+                });
+            } catch (error) {
+                this.payload.logger.error({
+                    err: error,
+                    collection,
+                    documentId,
+                    targetLocale: record.targetLocale,
+                    sourceLocale: record.sourceLocale,
+                    msg: "translator: failed to compute staleness for locale"
+                });
+            }
+        }
+        return locales;
+    }
+    /**
+   * Acknowledge the current source drift for one target locale: persist the current fingerprint as the
+   * dismissed one, so the indicator hides until the source changes again. No-op when the collection has
+   * no schema or the locale has no record.
+   */ async dismiss(key) {
+        const schema = this.schemaMap.get(key.collectionSlug);
+        if (!schema) return;
+        const record = await this.store.find(key);
+        if (!record) return;
+        const currentFingerprint = this.makeCurrentFingerprint(key.collectionSlug, key.documentId, schema);
+        await this.store.dismiss(key, await currentFingerprint(record.sourceLocale));
+    }
+    /**
+   * Recompute the current source fingerprint the same way the write path does (shared fetch shape +
+   * hash). Cached per source locale so a document translated from one source into N locales fetches
+   * the source once.
+   */ makeCurrentFingerprint(collection, documentId, schema) {
+        const cache = new Map();
+        return async (sourceLocale)=>{
+            const cached = cache.get(sourceLocale);
+            if (cached !== undefined) return cached;
+            const sourceData = await fetchSourceDocument(this.payload, collection, documentId, sourceLocale);
+            const fingerprint = computeSourceFingerprint(sourceData, schema);
+            cache.set(sourceLocale, fingerprint);
+            return fingerprint;
+        };
+    }
+}
+
+//# sourceMappingURL=Provenance.service.js.map

package/dist/server/modules/provenance/Provenance.shapes.d.ts

@@ -0,0 +1,26 @@
+import type { CollectionAfterDeleteHook } from "payload";
+/**
+ * The minimal slice of a Payload collection that provenance's config-time wiring reads and mutates:
+ * its `slug`, the sidecar `custom` marker, and the `afterDelete` hook slot. A real `CollectionConfig`
+ * is **structurally assignable** to this — call sites pass the live collection with no adapter, and a
+ * test passes a plain `{ slug: "posts" }` literal. Keeps `injectProvenanceCleanup` /
+ * `ensureProvenanceCollectionRegistered` off the god-`Config`/`CollectionConfig` types.
+ *
+ * The only Payload type imported here is `CollectionAfterDeleteHook` — a framework callback contract
+ * that legitimately stays framework-typed.
+ */
+export type ManagedCollectionEntry = {
+    slug: string;
+    custom?: unknown;
+    hooks?: {
+        afterDelete?: CollectionAfterDeleteHook[];
+    };
+};
+/**
+ * The minimal config host provenance's config-time wiring touches: just a mutable `collections`
+ * array. A real Payload `Config` plugs straight in (its `collections?: CollectionConfig[]` satisfies
+ * `ManagedCollectionEntry[]`).
+ */
+export type ManagedCollectionsConfig = {
+    collections?: ManagedCollectionEntry[];
+};

package/dist/server/modules/provenance/Provenance.shapes.js

@@ -0,0 +1,7 @@
+/**
+ * The minimal config host provenance's config-time wiring touches: just a mutable `collections`
+ * array. A real Payload `Config` plugs straight in (its `collections?: CollectionConfig[]` satisfies
+ * `ManagedCollectionEntry[]`).
+ */ export { };
+
+//# sourceMappingURL=Provenance.shapes.js.map

package/dist/server/modules/provenance/{PayloadProvenanceStore.d.ts → Provenance.store.d.ts}

@@ -16,6 +16,8 @@ export declare class PayloadProvenanceStore implements ProvenanceStore {
     constructor(payload: Payload, slug: string);
     upsert(record: TranslationProvenanceRecord): Promise<void>;
     find(key: ProvenanceKey): Promise<TranslationProvenanceRecord | null>;
+    findByDocument(collectionSlug: string, documentId: string): Promise<TranslationProvenanceRecord[]>;
+    dismiss(key: ProvenanceKey, dismissedFingerprint: string): Promise<void>;
     deleteByDocument(collectionSlug: string, documentId: string): Promise<void>;
     private findDoc;
 }

package/dist/server/modules/provenance/{PayloadProvenanceStore.js → Provenance.store.js}

@@ -1,3 +1,19 @@
+function documentWhere(collectionSlug, documentId) {
+    return {
+        and: [
+            {
+                collectionSlug: {
+                    equals: collectionSlug
+                }
+            },
+            {
+                documentId: {
+                    equals: documentId
+                }
+            }
+        ]
+    };
+}
 function keyWhere(key) {
     return {
         and: [
@@ -75,23 +91,30 @@ function toRecord(doc) {
         const doc = await this.findDoc(key);
         return doc === null ? null : toRecord(doc);
     }
+    async findByDocument(collectionSlug, documentId) {
+        const result = await this.payload.find({
+            collection: this.collection,
+            where: documentWhere(collectionSlug, documentId),
+            depth: 0,
+            pagination: false
+        });
+        return result.docs.map(toRecord);
+    }
+    async dismiss(key, dismissedFingerprint) {
+        const existing = await this.findDoc(key);
+        if (existing === null) return;
+        await this.payload.update({
+            collection: this.collection,
+            id: existing.id,
+            data: {
+                dismissedFingerprint
+            }
+        });
+    }
     async deleteByDocument(collectionSlug, documentId) {
         await this.payload.delete({
             collection: this.collection,
-            where: {
-                and: [
-                    {
-                        collectionSlug: {
-                            equals: collectionSlug
-                        }
-                    },
-                    {
-                        documentId: {
-                            equals: documentId
-                        }
-                    }
-                ]
-            }
+            where: documentWhere(collectionSlug, documentId)
         });
     }
     async findDoc(key) {
@@ -106,4 +129,4 @@ function toRecord(doc) {
     }
 }
 
-//# sourceMappingURL=PayloadProvenanceStore.js.map
+//# sourceMappingURL=Provenance.store.js.map

package/dist/server/modules/provenance/Provenance.wiring.d.ts

@@ -0,0 +1,23 @@
+import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
+import type { ConfigModifier } from "../../../types/ConfigModifier";
+import type { ProvenanceServiceFactory } from "./Provenance.service";
+/** The opt-in `provenance` plugin option (kept local so this module doesn't depend on plugin.ts). */
+export type ProvenanceOption = boolean | {
+    slug?: string;
+} | undefined;
+/**
+ * Everything the provenance module contributes at config time, in one object (mirrors
+ * `TaskRunnerProvider.configure`): the request-scoped {@link ProvenanceService} factory used by the
+ * handlers/routes, and the single {@link ConfigModifier} that registers the sidecar collection and
+ * the cleanup hook. When provenance is disabled, `serviceFactory` is absent and `configure` is a no-op.
+ */
+export type ProvenanceModule = {
+    serviceFactory?: ProvenanceServiceFactory;
+    configure(managedSlugs: Set<string>): ConfigModifier;
+};
+/**
+ * Turn the opt-in `provenance` option into a self-contained {@link ProvenanceModule}. This is the one
+ * place provenance's config-time wiring lives — `plugin.ts` only calls `configureProvenance(...)` and
+ * registers the returned modifier through the shared builder (no raw `config.collections` mutation).
+ */
+export declare function configureProvenance(option: ProvenanceOption, schemaMap: CollectionSchemaMap): ProvenanceModule;

package/dist/server/modules/provenance/Provenance.wiring.js

@@ -0,0 +1,43 @@
+import { ProvenanceService } from "./Provenance.service";
+import { PayloadProvenanceStore } from "./Provenance.store";
+import { DEFAULT_PROVENANCE_SLUG, ensureProvenanceCollectionRegistered, isProvenanceCollection } from "./Provenance.collection";
+import { injectProvenanceCleanup } from "./ProvenanceCleanup.hook";
+import { assertProvenanceSlugFree } from "./slugGuard";
+/**
+ * Resolve the opt-in `provenance` config to a sidecar slug, or `null` when disabled.
+ * `false`/omitted → off; `true` or `{}` → on with the default slug; `{ slug }` → on with that slug.
+ */ function resolveProvenanceSlug(option) {
+    if (!option) return null;
+    if (option === true) return DEFAULT_PROVENANCE_SLUG;
+    // `||` (not `??`) so an empty/blank slug falls back to the default instead of silently disabling.
+    return option.slug || DEFAULT_PROVENANCE_SLUG;
+}
+const NOOP = (config)=>config;
+/**
+ * Turn the opt-in `provenance` option into a self-contained {@link ProvenanceModule}. This is the one
+ * place provenance's config-time wiring lives — `plugin.ts` only calls `configureProvenance(...)` and
+ * registers the returned modifier through the shared builder (no raw `config.collections` mutation).
+ */ export function configureProvenance(option, schemaMap) {
+    const slug = resolveProvenanceSlug(option);
+    if (!slug) return {
+        configure: ()=>NOOP
+    };
+    const storeFactory = (payload)=>new PayloadProvenanceStore(payload, slug);
+    const serviceFactory = (payload)=>new ProvenanceService(payload, storeFactory(payload), schemaMap);
+    const configure = (managedSlugs)=>(config)=>{
+            // `config` infers as Payload's `Config` from the ConfigModifier return type, so this leaf never
+            // names the god-type — it only reads/mutates through narrow helpers below.
+            // Fail fast on a slug collision with a consumer collection (ignoring our own sidecar on a repeat
+            // init, so an idempotent re-run doesn't false-positive).
+            assertProvenanceSlugFree(slug, (config.collections ?? []).filter((collection)=>!isProvenanceCollection(collection)));
+            ensureProvenanceCollectionRegistered(config, slug);
+            injectProvenanceCleanup(config, managedSlugs, storeFactory, slug);
+            return config;
+        };
+    return {
+        serviceFactory,
+        configure
+    };
+}
+
+//# sourceMappingURL=Provenance.wiring.js.map

package/dist/server/modules/provenance/{provenanceCleanupHook.d.ts → ProvenanceCleanup.hook.d.ts}

@@ -1,5 +1,6 @@
-import type { CollectionAfterDeleteHook, Config } from "payload";
-import type { ProvenanceStoreFactory } from "./PayloadProvenanceStore";
+import type { CollectionAfterDeleteHook } from "payload";
+import type { ManagedCollectionsConfig } from "./Provenance.shapes";
+import type { ProvenanceStoreFactory } from "./Provenance.store";
 /**
  * Build the `afterDelete` hook that cascade-deletes a document's provenance rows for `provenanceSlug`.
  *
@@ -15,4 +16,4 @@ export declare function makeProvenanceCleanupHook(storeFactory: ProvenanceStoreF
  * yet a second instance with a different slug still attaches its own hook. The sidecar collection is
  * never in `managedSlugs`, so it is never hooked (no recursion).
  */
-export declare function injectProvenanceCleanup(config: Config, managedSlugs: Set<string>, storeFactory: ProvenanceStoreFactory, provenanceSlug: string): void;
+export declare function injectProvenanceCleanup(config: ManagedCollectionsConfig, managedSlugs: Set<string>, storeFactory: ProvenanceStoreFactory, provenanceSlug: string): void;

package/dist/server/modules/provenance/{provenanceCleanupHook.js → ProvenanceCleanup.hook.js}

@@ -38,4 +38,4 @@
     }
 }
 
-//# sourceMappingURL=provenanceCleanupHook.js.map
+//# sourceMappingURL=ProvenanceCleanup.hook.js.map

package/dist/server/modules/provenance/index.d.ts

@@ -1,5 +1,9 @@
-export { DEFAULT_PROVENANCE_SLUG, isProvenanceCollection, makeProvenanceCollection, } from "./provenanceCollection";
-export { PayloadProvenanceStore } from "./PayloadProvenanceStore";
-export type { ProvenanceStoreFactory } from "./PayloadProvenanceStore";
-export { injectProvenanceCleanup, makeProvenanceCleanupHook } from "./provenanceCleanupHook";
+export { DEFAULT_PROVENANCE_SLUG, isProvenanceCollection, makeProvenanceCollection, } from "./Provenance.collection";
+export { PayloadProvenanceStore } from "./Provenance.store";
+export type { ProvenanceStoreFactory } from "./Provenance.store";
+export { injectProvenanceCleanup, makeProvenanceCleanupHook } from "./ProvenanceCleanup.hook";
 export { assertProvenanceSlugFree } from "./slugGuard";
+export { ProvenanceService } from "./Provenance.service";
+export type { ProvenanceServiceFactory, StalenessLocale } from "./Provenance.service";
+export { configureProvenance } from "./Provenance.wiring";
+export type { ProvenanceModule, ProvenanceOption } from "./Provenance.wiring";

package/dist/server/modules/provenance/index.js

@@ -1,8 +1,10 @@
 // Provenance adapter (Payload-backed). The framework-agnostic port + record types live in the core
-// (src/core/provenance); this module is the plugin-side implementation.
-export { DEFAULT_PROVENANCE_SLUG, isProvenanceCollection, makeProvenanceCollection } from "./provenanceCollection";
-export { PayloadProvenanceStore } from "./PayloadProvenanceStore";
-export { injectProvenanceCleanup, makeProvenanceCleanupHook } from "./provenanceCleanupHook";
+// (src/core/provenance); this module is the plugin-side implementation + its config-time wiring.
+export { DEFAULT_PROVENANCE_SLUG, isProvenanceCollection, makeProvenanceCollection } from "./Provenance.collection";
+export { PayloadProvenanceStore } from "./Provenance.store";
+export { injectProvenanceCleanup, makeProvenanceCleanupHook } from "./ProvenanceCleanup.hook";
 export { assertProvenanceSlugFree } from "./slugGuard";
+export { ProvenanceService } from "./Provenance.service";
+export { configureProvenance } from "./Provenance.wiring";
 
 //# sourceMappingURL=index.js.map

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

@@ -2,18 +2,13 @@ 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 { ConfigModifier } from "../../../types/ConfigModifier";
 import type { TranslationProvider } from "../../../core/translation-providers";
 import type { TaskRunnerFactory } from "../task-runner";
-import type { CollectionAdminSlot, LevelContext } from "./types";
-type ConfigModifier = (config: Config) => Config;
-export type PluginConfigBuilderDeps = {
-    collections: CollectionConfig[];
-    basePath: string;
-    access?: AccessGuard;
-    taskRunnerFactory: TaskRunnerFactory;
-    schemaMap: CollectionSchemaMap;
-    translationProvider: TranslationProvider;
-};
+import type { ProvenanceServiceFactory } from "../provenance";
+import type { CollectionAdminSlot, LevelContext, TranslationContext } from "./types";
+/** The builder's construction deps are exactly the shared {@link TranslationContext}. */
+export type PluginConfigBuilderDeps = TranslationContext;
 /**
  * The single place that mutates the Payload `config`. Levels (through the narrow
  * {@link LevelContext}) and the plugin (through `addAdminProvider` /
@@ -32,6 +27,7 @@ export declare class PluginConfigBuilder implements LevelContext {
     readonly taskRunnerFactory: TaskRunnerFactory;
     readonly schemaMap: CollectionSchemaMap;
     readonly translationProvider: TranslationProvider;
+    readonly provenanceServiceFactory?: ProvenanceServiceFactory;
     private readonly endpoints;
     private readonly collectionComponents;
     private readonly adminProviders;
@@ -49,4 +45,3 @@ export declare class PluginConfigBuilder implements LevelContext {
     private attachCollectionComponents;
     private registerEndpoints;
 }
-export {};

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

@@ -34,6 +34,7 @@ function attachToSlot(collection, slot, component) {
     taskRunnerFactory;
     schemaMap;
     translationProvider;
+    provenanceServiceFactory;
     endpoints = [];
     collectionComponents = [];
     adminProviders = [];
@@ -45,6 +46,7 @@ function attachToSlot(collection, slot, component) {
         this.taskRunnerFactory = deps.taskRunnerFactory;
         this.schemaMap = deps.schemaMap;
         this.translationProvider = deps.translationProvider;
+        this.provenanceServiceFactory = deps.provenanceServiceFactory;
     }
     addEndpoints(endpoints) {
         this.endpoints.push(...endpoints);

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

@@ -1 +1 @@
-export type { TranslationLevel, LevelContext, CollectionAdminSlot } from "./types";
+export type { TranslationLevel, LevelContext, TranslationContext, CollectionAdminSlot, } from "./types";

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

@@ -4,7 +4,26 @@ import type { RawPayloadComponentExport } from "../../../types/PayloadComponentE
 import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
 import type { TranslationProvider } from "../../../core/translation-providers";
 import type { TaskRunnerFactory } from "../task-runner";
+import type { ProvenanceServiceFactory } from "../provenance";
 export type CollectionAdminSlot = "beforeDocumentControls" | "beforeListTable";
+/**
+ * The one bundle of config-time dependencies every translation surface / route / handler reads —
+ * the single source of truth that {@link LevelContext}, `PluginConfigBuilderDeps`, `StalenessConfig`
+ * and `TranslationRoutesDeps` all derive from (via `extends`/`Pick`), so a field can never drift
+ * between them.
+ */
+export type TranslationContext = {
+    readonly collections: CollectionConfig[];
+    readonly basePath: string;
+    readonly access?: AccessGuard;
+    readonly taskRunnerFactory: TaskRunnerFactory;
+    /** Deep-cloned localized field schema per managed collection slug. */
+    readonly schemaMap: CollectionSchemaMap;
+    /** The configured translation backend (used by the synchronous field level). */
+    readonly translationProvider: TranslationProvider;
+    /** Builds a provenance service; absent when provenance is disabled (staleness then reports empty). */
+    readonly provenanceServiceFactory?: ProvenanceServiceFactory;
+};
 /**
  * A composable translation surface (document / collection / field).
  *
@@ -31,15 +50,7 @@ export interface TranslationLevel {
  * Payload config. The plugin deduplicates endpoints by method + path on apply.
  * @internal
  */
-export interface LevelContext {
-    readonly collections: CollectionConfig[];
-    readonly basePath: string;
-    readonly access?: AccessGuard;
-    readonly taskRunnerFactory: TaskRunnerFactory;
-    /** Deep-cloned localized field schema per managed collection slug. */
-    readonly schemaMap: CollectionSchemaMap;
-    /** The configured translation backend (used by the synchronous field level). */
-    readonly translationProvider: TranslationProvider;
+export interface LevelContext extends TranslationContext {
     /** Register endpoints. Deduplicated by method + path when applied. */
     addEndpoints(endpoints: Endpoint[]): void;
     /** Attach an admin component to a slot on every managed collection. */

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

@@ -1,3 +1,4 @@
 export { ServerResponse } from "./ServerResponse";
 export { withErrorHandler } from "./withErrorHandler";
 export { withAccessCheck } from "./withAccessCheck";
+export { toClientErrorMessage, GENERIC_TRANSLATION_ERROR } from "./toClientErrorMessage";

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

@@ -1,5 +1,6 @@
 export { ServerResponse } from "./ServerResponse";
 export { withErrorHandler } from "./withErrorHandler";
 export { withAccessCheck } from "./withAccessCheck";
+export { toClientErrorMessage, GENERIC_TRANSLATION_ERROR } from "./toClientErrorMessage";
 
 //# sourceMappingURL=index.js.map

package/dist/server/shared/http/toClientErrorMessage.d.ts

@@ -0,0 +1,15 @@
+/** Shown to the browser instead of a raw provider/runtime error outside development. */
+export declare const GENERIC_TRANSLATION_ERROR = "Translation failed. See the server logs for details.";
+/**
+ * Collapse a server-side error message to something safe to send to the browser.
+ *
+ * Provider/runtime errors (e.g. `401 Incorrect API key provided: sk-proj-…`) leak implementation
+ * detail — and sometimes secrets — so the client must not see them in production. The full error
+ * still lives in the job record and server logs for debugging; only the client-facing copy is
+ * collapsed. Fail-safe: the raw message passes through solely in `development`/`test`; every other
+ * environment (including an unset `NODE_ENV`) returns {@link GENERIC_TRANSLATION_ERROR}.
+ *
+ * @param message - The raw server-side error message, if any.
+ * @returns The raw message in a debug environment, otherwise the generic text.
+ */
+export declare function toClientErrorMessage(message?: string): string;

package/dist/server/shared/http/toClientErrorMessage.js

@@ -0,0 +1,26 @@
+/** Shown to the browser instead of a raw provider/runtime error outside development. */ export const GENERIC_TRANSLATION_ERROR = "Translation failed. See the server logs for details.";
+// Only these environments get the raw message as a debug aid. Anything else — production, an unset
+// or misconfigured NODE_ENV — is treated as "not debug", so the default is the safe, generic text.
+const DEBUG_ENVS = new Set([
+    "development",
+    "test"
+]);
+/**
+ * Collapse a server-side error message to something safe to send to the browser.
+ *
+ * Provider/runtime errors (e.g. `401 Incorrect API key provided: sk-proj-…`) leak implementation
+ * detail — and sometimes secrets — so the client must not see them in production. The full error
+ * still lives in the job record and server logs for debugging; only the client-facing copy is
+ * collapsed. Fail-safe: the raw message passes through solely in `development`/`test`; every other
+ * environment (including an unset `NODE_ENV`) returns {@link GENERIC_TRANSLATION_ERROR}.
+ *
+ * @param message - The raw server-side error message, if any.
+ * @returns The raw message in a debug environment, otherwise the generic text.
+ */ export function toClientErrorMessage(message) {
+    if (DEBUG_ENVS.has(process.env.NODE_ENV ?? "")) {
+        return message?.trim() || GENERIC_TRANSLATION_ERROR;
+    }
+    return GENERIC_TRANSLATION_ERROR;
+}
+
+//# sourceMappingURL=toClientErrorMessage.js.map

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

@@ -1,4 +1,4 @@
-export { ServerResponse, withErrorHandler, withAccessCheck } from "./http";
+export { ServerResponse, withErrorHandler, withAccessCheck, toClientErrorMessage, GENERIC_TRANSLATION_ERROR, } from "./http";
 export { AnyAccessGuard } from "./access";
 export type { AccessGuard, AccessGuardRequest, Handler } from "./access";
 export { isEmpty, isObject, normalizePath, pipe, getByPath, setByPath, filterLocalizedFields, } from "./utils";

package/dist/server/shared/index.js

@@ -1,5 +1,5 @@
 // HTTP utilities
-export { ServerResponse, withErrorHandler, withAccessCheck } from "./http";
+export { ServerResponse, withErrorHandler, withAccessCheck, toClientErrorMessage, GENERIC_TRANSLATION_ERROR } from "./http";
 // Access control
 export { AnyAccessGuard } from "./access";
 // General utilities

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

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

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

@@ -0,0 +1,15 @@
+/**
+ * Fetch a document's source-locale data with the exact shape the provenance fingerprint depends on
+ * (`depth: 0`, the given locale). Used by the translation **write** path (fingerprints the source it
+ * just translated) and, through {@link ProvenanceService}, by the staleness **read** path
+ * (re-fingerprints the live source), so the fingerprint baseline can never drift between the two.
+ */ export function fetchSourceDocument(payload, collection, id, locale) {
+    return payload.findByID({
+        collection,
+        id,
+        locale,
+        depth: 0
+    });
+}
+
+//# sourceMappingURL=sourceDocument.js.map

package/dist/types/ConfigModifier.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from "payload";
+/**
+ * A config-time contribution: takes the Payload `config` and returns it (possibly a fresh object).
+ * Each translator module exposes a `configure(ctx) → ConfigModifier`; the plugin registers them
+ * through `PluginConfigBuilder.addConfigModifier`, which is the one place they are applied.
+ *
+ * Lives in `types/` (a leaf contract layer) so both `translation-levels` and the `provenance`
+ * module can import it without creating a module cycle.
+ */
+export type ConfigModifier = (config: Config) => Config;

package/dist/types/ConfigModifier.js

@@ -0,0 +1,10 @@
+/**
+ * A config-time contribution: takes the Payload `config` and returns it (possibly a fresh object).
+ * Each translator module exposes a `configure(ctx) → ConfigModifier`; the plugin registers them
+ * through `PluginConfigBuilder.addConfigModifier`, which is the one place they are applied.
+ *
+ * Lives in `types/` (a leaf contract layer) so both `translation-levels` and the `provenance`
+ * module can import it without creating a module cycle.
+ */ export { };
+
+//# sourceMappingURL=ConfigModifier.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@focus-reactive/payload-plugin-translator",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "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/ui/CompletedTranslationStatus/CompletedTranslationStatus.d.ts

@@ -1,7 +0,0 @@
-type CompletedTranslationStatusProps = {
-    completed_at: string;
-    sourceLocale: string;
-    targetLocale: string;
-};
-export declare function CompletedTranslationStatus({ completed_at, sourceLocale, targetLocale, }: CompletedTranslationStatusProps): import("react/jsx-runtime").JSX.Element;
-export {};