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

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/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,8 +19,13 @@ 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({

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/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.2",
   "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