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

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

@@ -0,0 +1,56 @@
+import type { CollectionSlug, Payload } from "payload";
+import type { ProvenanceKey, ProvenanceStore } from "../../../core/provenance";
+import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
+/** Per-locale staleness for one document (snake_case, matching the other translation endpoints). */
+export type StalenessLocale = {
+    target_lng: string;
+    source_lng: string;
+    is_stale: boolean;
+    translated_at: string;
+};
+/** Builds a {@link ProvenanceService} bound to a Payload instance; absent when provenance is disabled. */
+export type ProvenanceServiceFactory = (payload: Payload) => ProvenanceService;
+/**
+ * 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 declare class ProvenanceService {
+    private readonly payload;
+    private readonly store;
+    private readonly schemaMap;
+    constructor(payload: Payload, store: ProvenanceStore, schemaMap: CollectionSchemaMap);
+    /**
+     * 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: CollectionSlug, sourceData: Record<string, unknown>): string | null;
+    /** Persist a translation receipt (best-effort; a store failure logs and no-ops). */
+    record(key: ProvenanceKey & {
+        sourceLocale: string;
+    }, sourceFingerprint: string): Promise<void>;
+    /**
+     * 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.
+     */
+    getStaleness(collection: CollectionSlug, documentId: string): Promise<StalenessLocale[]>;
+    /**
+     * 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.
+     */
+    dismiss(key: ProvenanceKey): Promise<void>;
+    /**
+     * 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.
+     */
+    private makeCurrentFingerprint;
+}

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.js → Provenance.store.js}

@@ -129,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,20 +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 { ProvenanceStoreFactory } from "../provenance";
-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;
-    provenanceStoreFactory?: ProvenanceStoreFactory;
-};
+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` /
@@ -34,7 +27,7 @@ export declare class PluginConfigBuilder implements LevelContext {
     readonly taskRunnerFactory: TaskRunnerFactory;
     readonly schemaMap: CollectionSchemaMap;
     readonly translationProvider: TranslationProvider;
-    readonly provenanceStoreFactory?: ProvenanceStoreFactory;
+    readonly provenanceServiceFactory?: ProvenanceServiceFactory;
     private readonly endpoints;
     private readonly collectionComponents;
     private readonly adminProviders;
@@ -52,4 +45,3 @@ export declare class PluginConfigBuilder implements LevelContext {
     private attachCollectionComponents;
     private registerEndpoints;
 }
-export {};

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

@@ -34,7 +34,7 @@ function attachToSlot(collection, slot, component) {
     taskRunnerFactory;
     schemaMap;
     translationProvider;
-    provenanceStoreFactory;
+    provenanceServiceFactory;
     endpoints = [];
     collectionComponents = [];
     adminProviders = [];
@@ -46,7 +46,7 @@ function attachToSlot(collection, slot, component) {
         this.taskRunnerFactory = deps.taskRunnerFactory;
         this.schemaMap = deps.schemaMap;
         this.translationProvider = deps.translationProvider;
-        this.provenanceStoreFactory = deps.provenanceStoreFactory;
+        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,8 +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 { ProvenanceStoreFactory } from "../provenance";
+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).
  *
@@ -32,17 +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;
-    /** Builds a provenance store; absent when provenance is disabled (staleness then reports empty). */
-    readonly provenanceStoreFactory?: ProvenanceStoreFactory;
+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/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.8.0",
+  "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/server/features/_lib/sourceDocument.d.ts

@@ -1,9 +0,0 @@
-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). Shared by the translation **write** path (which fingerprints the
- * source it just translated) and the staleness **read** path (which re-fingerprints the live source),
- * so the fingerprint baseline can never drift between the two — the single biggest correctness trap in
- * staleness detection is thus enforced structurally, not by a comment.
- */
-export declare function fetchSourceDocument(payload: Payload, collection: CollectionSlug, id: string, locale: string): Promise<import("payload").JsonObject & import("payload").TypeWithID>;

package/dist/server/features/_lib/sourceDocument.js

@@ -1,16 +0,0 @@
-/**
- * Fetch a document's source-locale data with the exact shape the provenance fingerprint depends on
- * (`depth: 0`, the given locale). Shared by the translation **write** path (which fingerprints the
- * source it just translated) and the staleness **read** path (which re-fingerprints the live source),
- * so the fingerprint baseline can never drift between the two — the single biggest correctness trap in
- * staleness detection is thus enforced structurally, not by a comment.
- */ export function fetchSourceDocument(payload, collection, id, locale) {
-    return payload.findByID({
-        collection,
-        id,
-        locale,
-        depth: 0
-    });
-}
-
-//# sourceMappingURL=sourceDocument.js.map

package/dist/server/features/staleness/service.d.ts

@@ -1,15 +0,0 @@
-import type { CollectionSlug, Payload } from "payload";
-import type { StalenessConfig, StalenessLocaleOutput } from "./model";
-/**
- * Per-locale staleness for one document: read every provenance record, recompute the current source
- * fingerprint, and mark each locale stale when the source drifted and the drift was not dismissed.
- * Returns `[]` when provenance is disabled or the collection has no schema — a normal condition, not
- * an error (genuine store/fetch failures propagate for the caller to log).
- */
-export declare function computeDocumentStaleness(payload: Payload, config: StalenessConfig, collection: CollectionSlug, documentId: string): Promise<StalenessLocaleOutput[]>;
-/**
- * Acknowledge the current source drift for one target locale: recompute the current source
- * fingerprint (write-path-identical) and persist it as the dismissed fingerprint, so the indicator
- * hides until the source changes again. No-op when provenance is disabled or the locale has no record.
- */
-export declare function dismissLocaleStaleness(payload: Payload, config: StalenessConfig, collection: CollectionSlug, documentId: string, targetLocale: string): Promise<void>;

package/dist/server/features/staleness/service.js

@@ -1,78 +0,0 @@
-import { computeSourceFingerprint } from "../../../core/content-projection/computeSourceFingerprint";
-import { isRecordStale } from "../../../core/provenance";
-import { fetchSourceDocument } from "../_lib/sourceDocument";
-/**
- * Recompute the current source fingerprint the **same way the write path does**. Both sides fetch via
- * the shared {@link fetchSourceDocument} (identical `depth`/locale shape) and hash with the shared
- * {@link computeSourceFingerprint} + the same `schemaMap` entry, so an untouched document can never
- * report stale. Cached per source locale so a document translated from one source into N locales
- * fetches the source once.
- */ function makeCurrentFingerprint(payload, collection, documentId, schema) {
-    const cache = new Map();
-    return async (sourceLocale)=>{
-        const cached = cache.get(sourceLocale);
-        if (cached !== undefined) return cached;
-        const sourceData = await fetchSourceDocument(payload, collection, documentId, sourceLocale);
-        const fingerprint = computeSourceFingerprint(sourceData, schema);
-        cache.set(sourceLocale, fingerprint);
-        return fingerprint;
-    };
-}
-/**
- * Per-locale staleness for one document: read every provenance record, recompute the current source
- * fingerprint, and mark each locale stale when the source drifted and the drift was not dismissed.
- * Returns `[]` when provenance is disabled or the collection has no schema — a normal condition, not
- * an error (genuine store/fetch failures propagate for the caller to log).
- */ export async function computeDocumentStaleness(payload, config, collection, documentId) {
-    const schema = config.schemaMap.get(collection);
-    if (!config.provenanceStoreFactory || !schema) return [];
-    const store = config.provenanceStoreFactory(payload);
-    const records = await store.findByDocument(collection, documentId);
-    if (records.length === 0) return [];
-    const currentFingerprint = makeCurrentFingerprint(payload, 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) {
-            // Isolate per-locale failures (e.g. the record's source locale was removed from Payload's
-            // localization config): skip just this locale so one bad record can't blank the staleness of
-            // every other, still-valid locale on the document.
-            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: recompute the current source
- * fingerprint (write-path-identical) and persist it as the dismissed fingerprint, so the indicator
- * hides until the source changes again. No-op when provenance is disabled or the locale has no record.
- */ export async function dismissLocaleStaleness(payload, config, collection, documentId, targetLocale) {
-    const schema = config.schemaMap.get(collection);
-    if (!config.provenanceStoreFactory || !schema) return;
-    const store = config.provenanceStoreFactory(payload);
-    const key = {
-        collectionSlug: collection,
-        documentId,
-        targetLocale
-    };
-    const record = await store.find(key);
-    if (!record) return;
-    const currentFingerprint = makeCurrentFingerprint(payload, collection, documentId, schema);
-    await store.dismiss(key, await currentFingerprint(record.sourceLocale));
-}
-
-//# sourceMappingURL=service.js.map