@focus-reactive/payload-plugin-translator 0.6.1 → 0.7.0

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 /**
  * Input validation schema
  */ export const EnqueueInputSchema = z.object({
@@ -8,9 +8,9 @@ import { z } from 'zod';
     collection_id: z.array(z.coerce.string()).nonempty(),
     select_all: z.boolean().optional(),
     strategy: z.enum([
-        'overwrite',
-        'skip_existing'
-    ]).optional().default('overwrite'),
+        "overwrite",
+        "skip_existing"
+    ]).optional().default("overwrite"),
     publish_on_translation: z.boolean().optional().default(false)
 });
 

package/dist/server/features/get-collection-status/index.d.ts

@@ -1 +1 @@
-export { createGetCollectionStatusRoute } from './route';
+export { createGetCollectionStatusRoute } from "./route";

package/dist/server/features/get-collection-status/index.js

@@ -1,3 +1,3 @@
-export { createGetCollectionStatusRoute } from './route';
+export { createGetCollectionStatusRoute } from "./route";
 
 //# sourceMappingURL=index.js.map

package/dist/server/features/get-collection-status/model.d.ts

@@ -1,6 +1,6 @@
-import { z } from 'zod';
-import type { CollectionSlug } from 'payload';
-import type { TaskStatus } from '../../modules/task-runner';
+import { z } from "zod";
+import type { CollectionSlug } from "payload";
+import type { TaskStatus } from "../../modules/task-runner";
 /**
  * Input validation schema
  */

package/dist/server/features/get-collection-status/model.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 /**
  * Input validation schema
  */ export const GetCollectionStatusInputSchema = z.object({

package/dist/server/features/get-document-status/index.d.ts

@@ -1,2 +1,2 @@
-export { createGetDocumentStatusRoute } from './route';
-export { taskToJobStatusOutput } from './model';
+export { createGetDocumentStatusRoute } from "./route";
+export { taskToJobStatusOutput } from "./model";

package/dist/server/features/get-document-status/index.js

@@ -1,4 +1,4 @@
-export { createGetDocumentStatusRoute } from './route';
-export { taskToJobStatusOutput } from './model';
+export { createGetDocumentStatusRoute } from "./route";
+export { taskToJobStatusOutput } from "./model";
 
 //# sourceMappingURL=index.js.map

package/dist/server/features/run-translation/index.d.ts

@@ -1 +1 @@
-export { createRunRoute } from './route';
+export { createRunRoute } from "./route";

package/dist/server/features/run-translation/index.js

@@ -1,3 +1,3 @@
-export { createRunRoute } from './route';
+export { createRunRoute } from "./route";
 
 //# sourceMappingURL=index.js.map

package/dist/server/features/translate-document/handler.d.ts

@@ -1,7 +1,9 @@
 import type { Payload } from "payload";
 import type { Handler } from "../../shared";
-import type { TranslationProvider } from "../../modules/translation-providers";
-import type { CollectionSchemaMap, TranslateDocumentInput, TranslateDocumentOutput } from "./model";
+import type { TranslationProvider } from "../../../core/translation-providers";
+import type { ProvenanceStoreFactory } from "../../modules/provenance";
+import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
+import type { TranslateDocumentInput, TranslateDocumentOutput } from "./model";
 export type TranslateDocumentDependencies = {
     translationProvider: TranslationProvider;
     schemaMap: CollectionSchemaMap;
@@ -12,7 +14,8 @@ export type TranslateDocumentDependencies = {
 export declare class TranslateDocumentHandler implements Handler<TranslateDocumentInput, TranslateDocumentOutput> {
     private readonly translationProvider;
     private readonly schemaMap;
-    constructor(translationProvider: TranslationProvider, schemaMap: CollectionSchemaMap);
+    private readonly provenanceStoreFactory?;
+    constructor(translationProvider: TranslationProvider, schemaMap: CollectionSchemaMap, provenanceStoreFactory?: ProvenanceStoreFactory);
     handle(payload: Payload, input: TranslateDocumentInput): Promise<TranslateDocumentOutput>;
     private saveTranslatedDocument;
 }

package/dist/server/features/translate-document/handler.js

@@ -1,13 +1,16 @@
 import { APIError } from "payload";
-import { translateContent } from "../../modules/translation-pipeline";
+import { translateContent } from "../../../core/translation-pipeline";
+import { computeSourceFingerprint } from "../../../core/content-projection/computeSourceFingerprint";
 /**
  * Translates a single document from source language to target language
  */ export class TranslateDocumentHandler {
     translationProvider;
     schemaMap;
-    constructor(translationProvider, schemaMap){
+    provenanceStoreFactory;
+    constructor(translationProvider, schemaMap, provenanceStoreFactory){
         this.translationProvider = translationProvider;
         this.schemaMap = schemaMap;
+        this.provenanceStoreFactory = provenanceStoreFactory;
     }
     async handle(payload, input) {
         const { collection, collectionId, sourceLng, targetLng, strategy, publishOnTranslation } = input;
@@ -41,6 +44,29 @@ import { translateContent } from "../../modules/translation-pipeline";
         };
         const collectionConfig = payload.collections[collection].config;
         await this.saveTranslatedDocument(payload, collection, collectionId, translatedData, targetLng, sourceLng, collectionConfig, publishOnTranslation);
+        if (this.provenanceStoreFactory) {
+            const store = this.provenanceStoreFactory(payload);
+            try {
+                await store.upsert({
+                    collectionSlug: collection,
+                    documentId: String(collectionId),
+                    targetLocale: targetLng,
+                    sourceLocale: sourceLng,
+                    sourceFingerprint: computeSourceFingerprint(sourceData, schema),
+                    translatedAt: new Date().toISOString(),
+                    dismissedFingerprint: null
+                });
+            } catch (error) {
+                payload.logger.error({
+                    err: error,
+                    collection,
+                    documentId: String(collectionId),
+                    targetLocale: targetLng,
+                    sourceLocale: sourceLng,
+                    msg: "translator: failed to record translation provenance"
+                });
+            }
+        }
         return {
             success: true
         };

package/dist/server/features/translate-document/index.d.ts

@@ -1,2 +1,2 @@
 export { TranslateDocumentHandler } from "./handler";
-export type { CollectionSchemaMap } from "./model";
+export type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";

package/dist/server/features/translate-document/model.d.ts

@@ -1,6 +1,6 @@
-import type { CollectionSlug, Field } from "payload";
+import type { CollectionSlug } from "payload";
 import type { ID } from "../../modules/task-runner/types";
-import type { TranslationStrategyName } from "../../modules/translation-pipeline/strategies";
+import type { TranslationStrategyName } from "../../../core/translation-pipeline/strategies";
 /**
  * Input for the translate document handler
  */
@@ -18,8 +18,3 @@ export type TranslateDocumentInput = {
 export type TranslateDocumentOutput = {
     success: true;
 };
-/**
- * Map of collection slug to original field schema.
- * Used to access original schemas before Payload sanitization.
- */
-export type CollectionSchemaMap = Map<CollectionSlug, Field[]>;

package/dist/server/features/translate-document/model.js

@@ -1,6 +1,5 @@
 /**
- * Map of collection slug to original field schema.
- * Used to access original schemas before Payload sanitization.
+ * Output of the translate document handler
  */ export { };
 
 //# sourceMappingURL=model.js.map

package/dist/server/features/translate-field/handler.js

@@ -1,5 +1,5 @@
 import { getByPath, ServerResponse } from "../../shared";
-import { translateContent } from "../../modules/translation-pipeline";
+import { translateContent } from "../../../core/translation-pipeline";
 import { FieldTranslationInputSchema, MAX_FIELD_VALUE_BYTES } from "./model";
 import { resolveFieldSubtree } from "./resolveFieldSubtree";
 const byteLength = (value)=>new TextEncoder().encode(JSON.stringify(value) ?? "").length;

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

@@ -3,4 +3,5 @@ export type { CreateFieldRouteArgs } from "./route";
 export { TranslateFieldHandler } from "./handler";
 export { resolveFieldSubtree } from "./resolveFieldSubtree";
 export type { FieldSubtreeResolution } from "./resolveFieldSubtree";
-export type { FieldTranslationConfig, FieldTranslationInput, FieldTranslationNotice, FieldTranslationResult } from "./model";
+export type { FieldTranslationConfig, FieldTranslationInput } from "./model";
+export type { FieldTranslationNotice, FieldTranslationResult, } from "../../../types/wire/field-translation";

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import type { CollectionSchemaMap } from "../translate-document";
-import type { TranslationProvider } from "../../modules/translation-providers";
+import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
+import type { TranslationProvider } from "../../../core/translation-providers";
 /**
  * Max serialized size of the value the endpoint will translate — the value read from the
  * source-locale document (the request body no longer carries one; this is from-locale only). The
@@ -43,20 +43,3 @@ export type FieldTranslationConfig = {
     schemaMap: CollectionSchemaMap;
     translationProvider: TranslationProvider;
 };
-export type FieldTranslationNotice = {
-    level: "info" | "warning";
-    message: string;
-};
-/**
- * Successful response. Never an error for "couldn't translate": a field with no
- * localized content (or a path our resolver can't handle yet) is a `noop` with a
- * calm notice, not an HTTP error.
- */
-export type FieldTranslationResult = {
-    status: "translated";
-    value: unknown;
-} | {
-    status: "noop";
-    value: unknown;
-    notice: FieldTranslationNotice;
-};

package/dist/server/features/translate-field/resolveFieldSubtree.js

@@ -1,5 +1,5 @@
 import { isTranslatableField } from "../../shared";
-import { findFieldByPath } from "../../shared/field-traversal";
+import { findFieldByPath } from "../../../core/field-traversal";
 /**
  * Map a declared `fieldPath` to the `{ schema, sourceData }` pair `translateContent` expects.
  * Walks the schema via the shared {@link findFieldByPath}. Descends transparently through

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

@@ -9,4 +9,4 @@ export type CreateFieldRouteArgs = FieldTranslationConfig & {
  * Creates the synchronous field-translation endpoint: `POST {basePath}/field`.
  * Wired with the same access + error-envelope plumbing as the document routes.
  */
-export declare function createFieldRoute({ schemaMap, translationProvider, access, basePath }: CreateFieldRouteArgs): Endpoint;
+export declare function createFieldRoute({ schemaMap, translationProvider, access, basePath, }: CreateFieldRouteArgs): Endpoint;

package/dist/server/index.d.ts

@@ -1,3 +1,3 @@
-export * from './features';
-export * from './modules';
-export * from './shared';
+export * from "./features";
+export * from "./modules";
+export * from "./shared";

package/dist/server/index.js

@@ -1,5 +1,5 @@
-export * from './features';
-export * from './modules';
-export * from './shared';
+export * from "./features";
+export * from "./modules";
+export * from "./shared";
 
 //# sourceMappingURL=index.js.map

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

@@ -1,2 +1,2 @@
-export * from './translation-providers';
-export * from './translation-pipeline';
+export * from "../../core/translation-providers";
+export * from "../../core/translation-pipeline";

package/dist/server/modules/index.js

@@ -1,4 +1,4 @@
-export * from './translation-providers';
-export * from './translation-pipeline';
+export * from "../../core/translation-providers";
+export * from "../../core/translation-pipeline";
 
 //# sourceMappingURL=index.js.map

package/dist/server/modules/lifecycle/LifecycleNotifier.d.ts

@@ -0,0 +1,21 @@
+import type { TranslationLifecycleCallbacks, TranslationTask } from "./types";
+/** Minimal logger surface used for swallowed callback errors (Payload's `payload.logger` satisfies it). */
+type LifecycleLogger = {
+    error: (obj: unknown) => void;
+};
+/**
+ * Fires the host's translation lifecycle callbacks, best-effort. Each callback is invoked in a
+ * try/catch (covering both synchronous throws and rejected promises); a failure is logged and
+ * swallowed, never propagated — a broken host callback must not fail the translation. Absent
+ * callbacks are a no-op.
+ */
+export declare class LifecycleNotifier {
+    private readonly callbacks;
+    private readonly logger;
+    constructor(callbacks: TranslationLifecycleCallbacks, logger: LifecycleLogger);
+    queued(task: TranslationTask): Promise<void>;
+    completed(task: TranslationTask): Promise<void>;
+    failed(task: TranslationTask, error: unknown): Promise<void>;
+    private safe;
+}
+export {};

package/dist/server/modules/lifecycle/LifecycleNotifier.js

@@ -0,0 +1,38 @@
+/**
+ * Fires the host's translation lifecycle callbacks, best-effort. Each callback is invoked in a
+ * try/catch (covering both synchronous throws and rejected promises); a failure is logged and
+ * swallowed, never propagated — a broken host callback must not fail the translation. Absent
+ * callbacks are a no-op.
+ */ export class LifecycleNotifier {
+    callbacks;
+    logger;
+    constructor(callbacks, logger){
+        this.callbacks = callbacks;
+        this.logger = logger;
+    }
+    queued(task) {
+        const callback = this.callbacks.onQueued;
+        return this.safe("lifecycle.onQueued", callback && (()=>callback(task)));
+    }
+    completed(task) {
+        const callback = this.callbacks.onCompleted;
+        return this.safe("lifecycle.onCompleted", callback && (()=>callback(task)));
+    }
+    failed(task, error) {
+        const callback = this.callbacks.onFailed;
+        return this.safe("lifecycle.onFailed", callback && (()=>callback(task, error)));
+    }
+    async safe(name, thunk) {
+        if (!thunk) return;
+        try {
+            await thunk();
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                msg: `translator: ${name} callback threw`
+            });
+        }
+    }
+}
+
+//# sourceMappingURL=LifecycleNotifier.js.map

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

@@ -0,0 +1,4 @@
+export { LifecycleNotifier } from "./LifecycleNotifier";
+export { withQueuedNotification } from "./withQueuedNotification";
+export { taskFromHandlerInput, taskFromInput } from "./taskMapping";
+export type { TranslationLifecycleCallbacks, TranslationTask } from "./types";

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

@@ -0,0 +1,7 @@
+// Translation lifecycle callbacks — always-on host hooks fired around the runner (not gated by the
+// provenance opt-in, no schema/migration).
+export { LifecycleNotifier } from "./LifecycleNotifier";
+export { withQueuedNotification } from "./withQueuedNotification";
+export { taskFromHandlerInput, taskFromInput } from "./taskMapping";
+
+//# sourceMappingURL=index.js.map

package/dist/server/modules/lifecycle/taskMapping.d.ts

@@ -0,0 +1,7 @@
+import type { TaskInput } from "../task-runner/types";
+import type { TaskHandlerInput } from "../task-runner/TaskRunnerProvider.interface";
+import type { TranslationTask } from "./types";
+/** Map an enqueue-side {@link TaskInput} to the public {@link TranslationTask}. */
+export declare const taskFromInput: (task: TaskInput) => TranslationTask;
+/** Map an execution-side {@link TaskHandlerInput} to the public {@link TranslationTask}. */
+export declare const taskFromHandlerInput: (input: TaskHandlerInput) => TranslationTask;

package/dist/server/modules/lifecycle/taskMapping.js

@@ -0,0 +1,16 @@
+/** Map an enqueue-side {@link TaskInput} to the public {@link TranslationTask}. */ export const taskFromInput = (task)=>({
+        collection: task.collectionSlug,
+        id: task.collectionId,
+        sourceLng: task.sourceLng,
+        targetLng: task.targetLng,
+        strategy: task.strategy
+    });
+/** Map an execution-side {@link TaskHandlerInput} to the public {@link TranslationTask}. */ export const taskFromHandlerInput = (input)=>({
+        collection: input.collection,
+        id: input.collectionId,
+        sourceLng: input.sourceLng,
+        targetLng: input.targetLng,
+        strategy: input.strategy
+    });
+
+//# sourceMappingURL=taskMapping.js.map

package/dist/server/modules/lifecycle/types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Descriptor passed to the lifecycle callbacks — a stable, framework-neutral view of one translation
+ * task. Mirrors the fields the runner already threads through; `publishOnTranslation` is intentionally
+ * omitted (an internal write concern, not lifecycle-relevant). `id` is a string: the plugin is
+ * ID-agnostic and normalizes every document id to a string at ingress.
+ *
+ * @since 0.7.0
+ */
+export type TranslationTask = {
+    collection: string;
+    id: string;
+    sourceLng: string;
+    targetLng: string;
+    /**
+     * The resolution strategy for the task. Deliberately widened to `string` (not the internal
+     * `"overwrite" | "skip_existing"` union) so adding a strategy is not a breaking change to this
+     * public type; host callbacks should treat unknown values gracefully.
+     */
+    strategy: string;
+};
+/**
+ * Optional server-side hooks the host can supply to react to translation lifecycle events, passed as
+ * the plugin's `lifecycle` config object. Always available (no schema, no migration) and independent
+ * of the `provenance` opt-in. A throwing callback never fails the translation — it is caught and
+ * logged (see {@link LifecycleNotifier}).
+ *
+ * `onCompleted` / `onFailed` fire per **execution attempt**: the Payload Jobs runner may retry a
+ * failed task, so a task that fails then succeeds fires `onFailed` on each failed attempt and
+ * `onCompleted` on the one that succeeds. `onQueued` fires once, when the task is enqueued.
+ *
+ * @since 0.7.0
+ */
+export type TranslationLifecycleCallbacks = {
+    /**
+     * Fired for each task as it is queued. Best-effort: emitted just before the task is handed to the
+     * runner, so if enqueueing then throws it may fire for a task that never actually queued.
+     *
+     * @since 0.7.0
+     */
+    onQueued?: (task: TranslationTask) => void | Promise<void>;
+    /** Fired after a task completes without error. @since 0.7.0 */
+    onCompleted?: (task: TranslationTask) => void | Promise<void>;
+    /** Fired when a task's translation throws, with the error. @since 0.7.0 */
+    onFailed?: (task: TranslationTask, error: unknown) => void | Promise<void>;
+};

package/dist/server/modules/lifecycle/types.js

@@ -0,0 +1,21 @@
+/**
+ * Descriptor passed to the lifecycle callbacks — a stable, framework-neutral view of one translation
+ * task. Mirrors the fields the runner already threads through; `publishOnTranslation` is intentionally
+ * omitted (an internal write concern, not lifecycle-relevant). `id` is a string: the plugin is
+ * ID-agnostic and normalizes every document id to a string at ingress.
+ *
+ * @since 0.7.0
+ */ /**
+ * Optional server-side hooks the host can supply to react to translation lifecycle events, passed as
+ * the plugin's `lifecycle` config object. Always available (no schema, no migration) and independent
+ * of the `provenance` opt-in. A throwing callback never fails the translation — it is caught and
+ * logged (see {@link LifecycleNotifier}).
+ *
+ * `onCompleted` / `onFailed` fire per **execution attempt**: the Payload Jobs runner may retry a
+ * failed task, so a task that fails then succeeds fires `onFailed` on each failed attempt and
+ * `onCompleted` on the one that succeeds. `onQueued` fires once, when the task is enqueued.
+ *
+ * @since 0.7.0
+ */ export { };
+
+//# sourceMappingURL=types.js.map

package/dist/server/modules/lifecycle/withQueuedNotification.d.ts

@@ -0,0 +1,9 @@
+import type { TaskRunner } from "../task-runner/TaskRunner.interface";
+import type { LifecycleNotifier } from "./LifecycleNotifier";
+/**
+ * Decorate a {@link TaskRunner} so `enqueue` fires the `queued` lifecycle callback for each task.
+ * Fired BEFORE delegating: a synchronous runner (the sync runner) may execute a task inline during
+ * `enqueue` and fire `completed`, so emitting `queued` first preserves the queued → completed order.
+ * All other methods delegate unchanged.
+ */
+export declare function withQueuedNotification(runner: TaskRunner, notifier: LifecycleNotifier): TaskRunner;

package/dist/server/modules/lifecycle/withQueuedNotification.js

@@ -0,0 +1,19 @@
+import { taskFromInput } from "./taskMapping";
+/**
+ * Decorate a {@link TaskRunner} so `enqueue` fires the `queued` lifecycle callback for each task.
+ * Fired BEFORE delegating: a synchronous runner (the sync runner) may execute a task inline during
+ * `enqueue` and fire `completed`, so emitting `queued` first preserves the queued → completed order.
+ * All other methods delegate unchanged.
+ */ export function withQueuedNotification(runner, notifier) {
+    return {
+        async enqueue (tasks) {
+            await Promise.all(tasks.map((task)=>notifier.queued(taskFromInput(task))));
+            await runner.enqueue(tasks);
+        },
+        cancel: (taskIds)=>runner.cancel(taskIds),
+        run: (taskId)=>runner.run(taskId),
+        findByCollection: (collectionSlug, documentIds)=>runner.findByCollection(collectionSlug, documentIds)
+    };
+}
+
+//# sourceMappingURL=withQueuedNotification.js.map

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

@@ -0,0 +1,21 @@
+import type { Payload } from "payload";
+import type { ProvenanceKey, ProvenanceStore, TranslationProvenanceRecord } from "../../../core/provenance";
+/** Builds a provenance store bound to a Payload instance; absent when provenance is disabled. */
+export type ProvenanceStoreFactory = (payload: Payload) => ProvenanceStore;
+/**
+ * Payload-backed {@link ProvenanceStore}. All Payload coupling for provenance lives here; the core
+ * knows only the port. Records are keyed by `(collectionSlug, documentId, targetLocale)`; `upsert`
+ * matches on that key so a re-translation updates the row in place instead of duplicating it.
+ *
+ * The sidecar holds custom fields that no generated collection type describes, so the slug is cast to
+ * `CollectionSlug` once; the record shape is guaranteed by {@link makeProvenanceCollection}.
+ */
+export declare class PayloadProvenanceStore implements ProvenanceStore {
+    private readonly payload;
+    private readonly collection;
+    constructor(payload: Payload, slug: string);
+    upsert(record: TranslationProvenanceRecord): Promise<void>;
+    find(key: ProvenanceKey): Promise<TranslationProvenanceRecord | null>;
+    deleteByDocument(collectionSlug: string, documentId: string): Promise<void>;
+    private findDoc;
+}

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

@@ -0,0 +1,109 @@
+function keyWhere(key) {
+    return {
+        and: [
+            {
+                collectionSlug: {
+                    equals: key.collectionSlug
+                }
+            },
+            {
+                documentId: {
+                    equals: key.documentId
+                }
+            },
+            {
+                targetLocale: {
+                    equals: key.targetLocale
+                }
+            }
+        ]
+    };
+}
+function toRecord(doc) {
+    return {
+        collectionSlug: String(doc.collectionSlug),
+        documentId: String(doc.documentId),
+        targetLocale: String(doc.targetLocale),
+        sourceLocale: String(doc.sourceLocale),
+        sourceFingerprint: String(doc.sourceFingerprint),
+        // `translatedAt` is backed by a `date` field, which Payload may hand back as a Date; normalize to
+        // ISO-8601 so the stored contract holds and #50's fingerprint comparison stays format-stable.
+        translatedAt: new Date(doc.translatedAt).toISOString(),
+        dismissedFingerprint: doc.dismissedFingerprint == null ? null : String(doc.dismissedFingerprint)
+    };
+}
+/**
+ * Payload-backed {@link ProvenanceStore}. All Payload coupling for provenance lives here; the core
+ * knows only the port. Records are keyed by `(collectionSlug, documentId, targetLocale)`; `upsert`
+ * matches on that key so a re-translation updates the row in place instead of duplicating it.
+ *
+ * The sidecar holds custom fields that no generated collection type describes, so the slug is cast to
+ * `CollectionSlug` once; the record shape is guaranteed by {@link makeProvenanceCollection}.
+ */ export class PayloadProvenanceStore {
+    payload;
+    collection;
+    constructor(payload, slug){
+        this.payload = payload;
+        this.collection = slug;
+    }
+    async upsert(record) {
+        const existing = await this.findDoc(record);
+        if (existing === null) {
+            try {
+                await this.payload.create({
+                    collection: this.collection,
+                    data: record
+                });
+            } catch (error) {
+                const raceWinner = await this.findDoc(record);
+                if (raceWinner === null) throw error;
+                await this.payload.update({
+                    collection: this.collection,
+                    id: raceWinner.id,
+                    data: record
+                });
+            }
+        } else {
+            await this.payload.update({
+                collection: this.collection,
+                id: existing.id,
+                data: record
+            });
+        }
+    }
+    async find(key) {
+        const doc = await this.findDoc(key);
+        return doc === null ? null : toRecord(doc);
+    }
+    async deleteByDocument(collectionSlug, documentId) {
+        await this.payload.delete({
+            collection: this.collection,
+            where: {
+                and: [
+                    {
+                        collectionSlug: {
+                            equals: collectionSlug
+                        }
+                    },
+                    {
+                        documentId: {
+                            equals: documentId
+                        }
+                    }
+                ]
+            }
+        });
+    }
+    async findDoc(key) {
+        const result = await this.payload.find({
+            collection: this.collection,
+            where: keyWhere(key),
+            limit: 1,
+            depth: 0,
+            pagination: false
+        });
+        return result.docs[0] ?? null;
+    }
+}
+
+//# sourceMappingURL=PayloadProvenanceStore.js.map

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

@@ -0,0 +1,5 @@
+export { DEFAULT_PROVENANCE_SLUG, isProvenanceCollection, makeProvenanceCollection, } from "./provenanceCollection";
+export { PayloadProvenanceStore } from "./PayloadProvenanceStore";
+export type { ProvenanceStoreFactory } from "./PayloadProvenanceStore";
+export { injectProvenanceCleanup, makeProvenanceCleanupHook } from "./provenanceCleanupHook";
+export { assertProvenanceSlugFree } from "./slugGuard";

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

@@ -0,0 +1,8 @@
+// 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";
+export { assertProvenanceSlugFree } from "./slugGuard";
+
+//# sourceMappingURL=index.js.map