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

package/dist/composition/levels/useDocTranslationApi.d.ts

@@ -3,7 +3,7 @@ import type { LevelContext } from "../../server/modules/translation-levels";
  * Contribute the runner-agnostic document-translation API — the shared route
  * bundle, bound to the level context's runner. Both `documentLevel` and
  * `collectionLevel` call this; the plugin deduplicates the endpoints by method +
- * path, so the bundle registers exactly once. The schema map and provenance
- * store factory ride along for the staleness endpoints.
+ * path, so the bundle registers exactly once. The provenance service factory
+ * rides along for the staleness endpoints (its schema lives inside the service).
  */
 export declare function useDocTranslationApi(ctx: LevelContext): void;

package/dist/composition/levels/useDocTranslationApi.js

@@ -3,8 +3,8 @@ import { createTranslationRoutes } from "../../server/features/createTranslation
  * Contribute the runner-agnostic document-translation API — the shared route
  * bundle, bound to the level context's runner. Both `documentLevel` and
  * `collectionLevel` call this; the plugin deduplicates the endpoints by method +
- * path, so the bundle registers exactly once. The schema map and provenance
- * store factory ride along for the staleness endpoints.
+ * path, so the bundle registers exactly once. The provenance service factory
+ * rides along for the staleness endpoints (its schema lives inside the service).
  */ export function useDocTranslationApi(ctx) {
     ctx.addEndpoints(createTranslationRoutes({
         taskRunnerFactory: ctx.taskRunnerFactory,
@@ -13,8 +13,7 @@ import { createTranslationRoutes } from "../../server/features/createTranslation
         },
         access: ctx.access,
         basePath: ctx.basePath,
-        schemaMap: ctx.schemaMap,
-        provenanceStoreFactory: ctx.provenanceStoreFactory
+        provenanceServiceFactory: ctx.provenanceServiceFactory
     }));
 }
 

package/dist/plugin.js

@@ -1,19 +1,9 @@
 import { CacheProviderExport } from "./client/app/cache/CacheProvider.export";
-import { DEFAULT_PROVENANCE_SLUG, PayloadProvenanceStore, assertProvenanceSlugFree, injectProvenanceCleanup, isProvenanceCollection, makeProvenanceCollection } from "./server/modules/provenance";
-import { TranslateDocumentHandler } from "./server/features/translate-document";
-import { LifecycleNotifier, taskFromHandlerInput, withQueuedNotification } from "./server/modules/lifecycle";
+import { configureProvenance } from "./server/modules/provenance";
+import { wireTranslateRunner } from "./server/features/translate-document";
 import { documentLevel, collectionLevel } from "./composition/levels";
 import { PluginConfigBuilder } from "./server/modules/translation-levels/PluginConfigBuilder";
 import { normalizePath } from "./server/shared";
-/**
- * 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(provenance) {
-    if (!provenance) return null;
-    if (provenance === true) return DEFAULT_PROVENANCE_SLUG;
-    // `||` (not `??`) so an empty/blank slug falls back to the default instead of silently disabling.
-    return provenance.slug || DEFAULT_PROVENANCE_SLUG;
-}
 /** @deprecated Use `translatorPlugin` function instead */ export class TranslateCollectionPlugin {
     pluginConfig;
     constructor(pluginConfig){
@@ -22,61 +12,30 @@ import { normalizePath } from "./server/shared";
     init() {
         return async (config)=>{
             const { access, translationProvider, runner, collections, levels, provenance, lifecycle, basePath: rawBasePath = "/translate" } = this.pluginConfig;
-            const lifecycleCallbacks = lifecycle ?? {};
-            // Build schema map from deep-cloned collections
-            // Deep clone is required because Payload mutates the original collection objects,
-            // removing `localized: true` from nested fields during sanitization.
-            // We use JSON round-trip instead of structuredClone because Lexical editor
-            // configs contain async functions that structuredClone cannot handle.
-            // TODO: Consider introducing a FieldLike interface with only the properties
-            // used by the pipeline (name, type, localized, fields, blocks, tabs, custom)
-            // to make the contract explicit and avoid reliance on JSON round-trip.
+            // Build schema map from deep-cloned collections.
+            // Deep clone is required because Payload mutates the original collection objects, removing
+            // `localized: true` from nested fields during sanitization. JSON round-trip (not
+            // structuredClone) because Lexical editor configs contain async functions structuredClone
+            // cannot handle.
+            // TODO: Consider introducing a FieldLike interface with only the properties used by the
+            // pipeline (name, type, localized, fields, blocks, tabs, custom) to make the contract explicit
+            // and avoid reliance on JSON round-trip.
             const schemaMap = new Map(collections.map((col)=>[
                     col.slug,
                     JSON.parse(JSON.stringify(col.fields))
                 ]));
             const collectionSlugs = new Set(schemaMap.keys());
             const basePath = normalizePath(rawBasePath);
-            const provenanceSlug = resolveProvenanceSlug(provenance);
-            if (provenanceSlug) {
-                const existing = (config.collections ?? []).filter((collection)=>!isProvenanceCollection(collection));
-                assertProvenanceSlugFree(provenanceSlug, existing);
-            }
-            const provenanceStoreFactory = provenanceSlug ? (p)=>new PayloadProvenanceStore(p, provenanceSlug) : undefined;
-            const translateHandler = new TranslateDocumentHandler(translationProvider, schemaMap, provenanceStoreFactory);
-            const runnerContext = {
-                handler: async (payload, input)=>{
-                    const notifier = new LifecycleNotifier(lifecycleCallbacks, payload.logger);
-                    const task = taskFromHandlerInput(input);
-                    try {
-                        await translateHandler.handle(payload, {
-                            collection: input.collection,
-                            collectionId: input.collectionId,
-                            sourceLng: input.sourceLng,
-                            targetLng: input.targetLng,
-                            strategy: input.strategy,
-                            publishOnTranslation: input.publishOnTranslation
-                        });
-                    } catch (error) {
-                        await notifier.failed(task, error);
-                        throw error; // rethrow so the runner marks the job failed
-                    }
-                    await notifier.completed(task);
-                },
+            // Each concern owns its own config-time wiring and exposes it uniformly; init() just composes.
+            const provenanceModule = configureProvenance(provenance, schemaMap);
+            const { taskRunnerFactory, configModifier: runnerConfigModifier } = wireTranslateRunner({
+                translationProvider,
+                schemaMap,
+                provenanceServiceFactory: provenanceModule.serviceFactory,
+                runner,
+                lifecycle: lifecycle ?? {},
                 collections: Array.from(collectionSlugs)
-            };
-            const runnerConfigModifier = runner.configure(runnerContext);
-            // Bind the context once so routes receive a self-sufficient factory: the
-            // runner needs no mutable per-instance handler state and create() has no
-            // "configure() must run first" ordering coupling (translator plan, 0c).
-            // When an `onQueued` callback is set, decorate the runner so `enqueue` fires it.
-            const taskRunnerFactory = {
-                create: (payload)=>{
-                    const taskRunner = runner.create(payload, runnerContext.handler);
-                    if (!lifecycleCallbacks.onQueued) return taskRunner;
-                    return withQueuedNotification(taskRunner, new LifecycleNotifier(lifecycleCallbacks, payload.logger));
-                }
-            };
+            });
             const activeLevels = levels ?? [
                 documentLevel(),
                 collectionLevel()
@@ -88,23 +47,11 @@ import { normalizePath } from "./server/shared";
                 taskRunnerFactory,
                 schemaMap,
                 translationProvider,
-                provenanceStoreFactory
+                provenanceServiceFactory: provenanceModule.serviceFactory
             });
             for (const level of activeLevels)level.extend(builder);
             builder.addConfigModifier(runnerConfigModifier);
-            if (provenanceSlug && provenanceStoreFactory) {
-                builder.addConfigModifier((cfg)=>{
-                    const alreadyAdded = cfg.collections?.some((collection)=>collection.slug === provenanceSlug && isProvenanceCollection(collection));
-                    if (!alreadyAdded) {
-                        cfg.collections = [
-                            ...cfg.collections ?? [],
-                            makeProvenanceCollection(provenanceSlug)
-                        ];
-                    }
-                    injectProvenanceCleanup(cfg, collectionSlugs, provenanceStoreFactory, provenanceSlug);
-                    return cfg;
-                });
-            }
+            builder.addConfigModifier(provenanceModule.configure(collectionSlugs));
             builder.addAdminProvider(new CacheProviderExport(basePath));
             // The single place the Payload config is mutated.
             return builder.applyTo(config);

package/dist/server/features/createTranslationRoutes.d.ts

@@ -1,20 +1,11 @@
 import type { CollectionSlug, Endpoint } from "payload";
-import type { AccessGuard } from "../shared";
-import type { TaskRunnerFactory } from "../modules/task-runner";
-import type { CollectionSchemaMap } from "../../types/CollectionSchemaMap";
-import type { ProvenanceStoreFactory } from "../modules/provenance";
-export type TranslationRoutesDeps = {
-    taskRunnerFactory: TaskRunnerFactory;
+import type { TranslationContext } from "../modules/translation-levels";
+export type TranslationRoutesDeps = Pick<TranslationContext, "taskRunnerFactory" | "access" | "provenanceServiceFactory"> & {
     /** Collections the plugin manages — gates which slugs the routes accept. */
     collectionConfig: {
         availableCollections: Set<CollectionSlug>;
     };
-    access?: AccessGuard;
     basePath?: string;
-    /** Original per-collection field schema — needed to recompute source fingerprints for staleness. */
-    schemaMap: CollectionSchemaMap;
-    /** Builds a provenance store; absent when provenance is disabled (staleness then reports empty). */
-    provenanceStoreFactory?: ProvenanceStoreFactory;
 };
 /**
  * The translator's HTTP surface as one shared bundle: the job-API endpoints
@@ -26,6 +17,6 @@ export type TranslationRoutesDeps = {
  * document and collection levels each contribute this bundle via the level
  * context; the plugin deduplicates by method + path, so it registers exactly
  * once. The staleness endpoints always register; when provenance is disabled
- * (`provenanceStoreFactory` absent) they simply report no staleness.
+ * (`provenanceServiceFactory` absent) they simply report no staleness.
  */
-export declare function createTranslationRoutes({ taskRunnerFactory, collectionConfig, access, basePath, schemaMap, provenanceStoreFactory, }: TranslationRoutesDeps): Endpoint[];
+export declare function createTranslationRoutes({ taskRunnerFactory, collectionConfig, access, basePath, provenanceServiceFactory, }: TranslationRoutesDeps): Endpoint[];

package/dist/server/features/createTranslationRoutes.js

@@ -15,12 +15,11 @@ import { createGetDocumentStalenessRoute, createDismissStalenessRoute } from "./
  * document and collection levels each contribute this bundle via the level
  * context; the plugin deduplicates by method + path, so it registers exactly
  * once. The staleness endpoints always register; when provenance is disabled
- * (`provenanceStoreFactory` absent) they simply report no staleness.
- */ export function createTranslationRoutes({ taskRunnerFactory, collectionConfig, access, basePath, schemaMap, provenanceStoreFactory }) {
+ * (`provenanceServiceFactory` absent) they simply report no staleness.
+ */ export function createTranslationRoutes({ taskRunnerFactory, collectionConfig, access, basePath, provenanceServiceFactory }) {
     const stalenessConfig = {
         availableCollections: collectionConfig.availableCollections,
-        schemaMap,
-        provenanceStoreFactory
+        provenanceServiceFactory
     };
     return [
         createEnqueueRoute(taskRunnerFactory, collectionConfig, access, basePath),

package/dist/server/features/staleness/dismissStaleness.handler.js

@@ -1,7 +1,6 @@
 import { ServerResponse } from "../../shared";
 import { isCollectionAvailable } from "../_lib/collection-utils";
 import { DismissStalenessInputSchema } from "./model";
-import { dismissLocaleStaleness } from "./service";
 /** Dismisses (acknowledges) staleness of one target locale for a document. */ export class DismissStalenessHandler {
     config;
     constructor(config){
@@ -17,7 +16,12 @@ import { dismissLocaleStaleness } from "./service";
         if (!collectionSlug) {
             return ServerResponse.badRequest("Collection not available for translation");
         }
-        await dismissLocaleStaleness(req.payload, this.config, collectionSlug, collection_id, target_lng);
+        const service = this.config.provenanceServiceFactory?.(req.payload);
+        await service?.dismiss({
+            collectionSlug: collectionSlug,
+            documentId: collection_id,
+            targetLocale: target_lng
+        });
         return ServerResponse.success({
             success: true
         });

package/dist/server/features/staleness/getDocumentStaleness.handler.js

@@ -1,7 +1,6 @@
 import { ServerResponse } from "../../shared";
 import { isCollectionAvailable } from "../_lib/collection-utils";
 import { GetDocumentStalenessInputSchema } from "./model";
-import { computeDocumentStaleness } from "./service";
 /**
  * Reads per-locale staleness for a single document. Best-effort: a recompute failure (e.g. the
  * consumer enabled provenance but has not run the SQL migration, so the sidecar table is missing)
@@ -22,7 +21,8 @@ import { computeDocumentStaleness } from "./service";
             return ServerResponse.badRequest("Collection not available for translation");
         }
         try {
-            const locales = await computeDocumentStaleness(req.payload, this.config, collectionSlug, collection_id);
+            const service = this.config.provenanceServiceFactory?.(req.payload);
+            const locales = service ? await service.getStaleness(collectionSlug, collection_id) : [];
             return ServerResponse.success({
                 locales
             });

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

@@ -1,2 +1,2 @@
 export { createGetDocumentStalenessRoute, createDismissStalenessRoute } from "./route";
-export type { StalenessConfig, StalenessLocaleOutput } from "./model";
+export type { StalenessConfig } from "./model";

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

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import type { CollectionSlug } from "payload";
-import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
-import type { ProvenanceStoreFactory } from "../../modules/provenance";
+import type { TranslationContext } from "../../modules/translation-levels";
 /**
  * Route params for reading a document's per-locale staleness.
  *
@@ -32,21 +31,10 @@ export declare const DismissStalenessInputSchema: z.ZodObject<{
     target_lng: string;
 }>;
 /**
- * Per-locale staleness for one document (snake_case for client compatibility, matching the other
- * translation endpoints). One entry per target locale that has a provenance record.
- */
-export type StalenessLocaleOutput = {
-    target_lng: string;
-    source_lng: string;
-    is_stale: boolean;
-    translated_at: string;
-};
-/**
- * Handler configuration. `provenanceStoreFactory` is absent when provenance is disabled — the
+ * Handler configuration. `provenanceServiceFactory` is absent when provenance is disabled — the
  * handlers then report no staleness (empty), so the endpoint contract stays stable either way.
+ * The fingerprint policy + schema live inside {@link ProvenanceService}, so no `schemaMap` here.
  */
-export type StalenessConfig = {
+export type StalenessConfig = Pick<TranslationContext, "provenanceServiceFactory"> & {
     availableCollections: Set<CollectionSlug>;
-    schemaMap: CollectionSchemaMap;
-    provenanceStoreFactory?: ProvenanceStoreFactory;
 };

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

@@ -1,21 +1,19 @@
 import type { Payload } from "payload";
 import type { Handler } from "../../shared";
 import type { TranslationProvider } from "../../../core/translation-providers";
-import type { ProvenanceStoreFactory } from "../../modules/provenance";
+import type { ProvenanceServiceFactory } from "../../modules/provenance";
 import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
 import type { TranslateDocumentInput, TranslateDocumentOutput } from "./model";
-export type TranslateDocumentDependencies = {
-    translationProvider: TranslationProvider;
-    schemaMap: CollectionSchemaMap;
-};
 /**
- * Translates a single document from source language to target language
+ * Translates a single document from source language to target language. Provenance is delegated to
+ * {@link ProvenanceService}: this handler only decides *when* to capture the source fingerprint
+ * (before the pipeline mutates the source in place) and *when* to record it (after the save).
  */
 export declare class TranslateDocumentHandler implements Handler<TranslateDocumentInput, TranslateDocumentOutput> {
     private readonly translationProvider;
     private readonly schemaMap;
-    private readonly provenanceStoreFactory?;
-    constructor(translationProvider: TranslationProvider, schemaMap: CollectionSchemaMap, provenanceStoreFactory?: ProvenanceStoreFactory);
+    private readonly provenanceServiceFactory?;
+    constructor(translationProvider: TranslationProvider, schemaMap: CollectionSchemaMap, provenanceServiceFactory?: ProvenanceServiceFactory);
     handle(payload: Payload, input: TranslateDocumentInput): Promise<TranslateDocumentOutput>;
     private saveTranslatedDocument;
 }

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

@@ -1,17 +1,18 @@
 import { APIError } from "payload";
 import { translateContent } from "../../../core/translation-pipeline";
-import { computeSourceFingerprint } from "../../../core/content-projection/computeSourceFingerprint";
-import { fetchSourceDocument } from "../_lib/sourceDocument";
+import { fetchSourceDocument } from "../../shared/payload/sourceDocument";
 /**
- * Translates a single document from source language to target language
+ * Translates a single document from source language to target language. Provenance is delegated to
+ * {@link ProvenanceService}: this handler only decides *when* to capture the source fingerprint
+ * (before the pipeline mutates the source in place) and *when* to record it (after the save).
  */ export class TranslateDocumentHandler {
     translationProvider;
     schemaMap;
-    provenanceStoreFactory;
-    constructor(translationProvider, schemaMap, provenanceStoreFactory){
+    provenanceServiceFactory;
+    constructor(translationProvider, schemaMap, provenanceServiceFactory){
         this.translationProvider = translationProvider;
         this.schemaMap = schemaMap;
-        this.provenanceStoreFactory = provenanceStoreFactory;
+        this.provenanceServiceFactory = provenanceServiceFactory;
     }
     async handle(payload, input) {
         const { collection, collectionId, sourceLng, targetLng, strategy, publishOnTranslation } = input;
@@ -19,24 +20,12 @@ import { fetchSourceDocument } from "../_lib/sourceDocument";
         const schema = this.schemaMap.get(collection);
         if (!schema) throw new APIError(`Collection "${collection}" not found in schemaMap`, 400);
         const sourceData = await fetchSourceDocument(payload, collection, collectionId, sourceLng);
-        // Capture the staleness baseline from the PRISTINE source NOW, before the pipeline runs. The
-        // pipeline translates in place and shares object-valued source leaves (e.g. richText nodes) by
-        // reference with `sourceData`, so fingerprinting after `translateContent` would hash the target
-        // translation — making every fresh translation look immediately stale. Best-effort: a fingerprint
-        // failure logs and skips provenance rather than breaking the translation.
-        let sourceFingerprint = null;
-        if (this.provenanceStoreFactory) {
-            try {
-                sourceFingerprint = computeSourceFingerprint(sourceData, schema);
-            } catch (error) {
-                payload.logger.error({
-                    err: error,
-                    collection,
-                    documentId: String(collectionId),
-                    msg: "translator: failed to fingerprint source for provenance"
-                });
-            }
-        }
+        // Capture the staleness baseline from the PRISTINE source NOW, before the pipeline runs — it
+        // translates in place and shares object-valued source leaves (e.g. richText nodes) by reference,
+        // so fingerprinting after `translateContent` would hash the target translation and make every
+        // fresh translation look instantly stale. The service is best-effort (a failure returns null).
+        const provenance = this.provenanceServiceFactory?.(payload);
+        const sourceFingerprint = provenance?.captureFingerprint(collection, sourceData) ?? null;
         const targetData = await payload.findByID({
             collection,
             id: collectionId,
@@ -58,28 +47,13 @@ import { fetchSourceDocument } from "../_lib/sourceDocument";
         };
         const collectionConfig = payload.collections[collection].config;
         await this.saveTranslatedDocument(payload, collection, collectionId, translatedData, targetLng, sourceLng, collectionConfig, publishOnTranslation);
-        if (this.provenanceStoreFactory && sourceFingerprint !== null) {
-            const store = this.provenanceStoreFactory(payload);
-            try {
-                await store.upsert({
-                    collectionSlug: collection,
-                    documentId: String(collectionId),
-                    targetLocale: targetLng,
-                    sourceLocale: sourceLng,
-                    sourceFingerprint,
-                    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"
-                });
-            }
+        if (provenance && sourceFingerprint !== null) {
+            await provenance.record({
+                collectionSlug: collection,
+                documentId: String(collectionId),
+                targetLocale: targetLng,
+                sourceLocale: sourceLng
+            }, sourceFingerprint);
         }
         return {
             success: true

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

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

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

@@ -1,3 +1,4 @@
 export { TranslateDocumentHandler } from "./handler";
+export { wireTranslateRunner } from "./wireTranslateRunner";
 
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,28 @@
+import type { CollectionSlug } from "payload";
+import type { TranslationProvider } from "../../../core/translation-providers";
+import type { CollectionSchemaMap } from "../../../types/CollectionSchemaMap";
+import type { ConfigModifier } from "../../../types/ConfigModifier";
+import type { ProvenanceServiceFactory } from "../../modules/provenance";
+import type { TranslationLifecycleCallbacks } from "../../modules/lifecycle";
+import type { TaskRunnerFactory, TaskRunnerProvider } from "../../modules/task-runner";
+type WireTranslateRunnerParams = {
+    translationProvider: TranslationProvider;
+    schemaMap: CollectionSchemaMap;
+    provenanceServiceFactory?: ProvenanceServiceFactory;
+    runner: TaskRunnerProvider;
+    lifecycle: TranslationLifecycleCallbacks;
+    collections: CollectionSlug[];
+};
+/**
+ * Assemble the document-translation task pipeline: the {@link TranslateDocumentHandler}, the runner
+ * context that wraps each task with lifecycle notifications, the runner's config modifier, and the
+ * per-request {@link TaskRunnerFactory} (decorated with `onQueued` notification when configured).
+ *
+ * Extracted from the plugin's `init()` so the composition root stays a flat list — `plugin.ts` calls
+ * this once and registers the returned `configModifier` through the shared builder.
+ */
+export declare function wireTranslateRunner({ translationProvider, schemaMap, provenanceServiceFactory, runner, lifecycle, collections, }: WireTranslateRunnerParams): {
+    taskRunnerFactory: TaskRunnerFactory;
+    configModifier: ConfigModifier;
+};
+export {};

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

@@ -0,0 +1,49 @@
+import { LifecycleNotifier, taskFromHandlerInput, withQueuedNotification } from "../../modules/lifecycle";
+import { TranslateDocumentHandler } from "./handler";
+/**
+ * Assemble the document-translation task pipeline: the {@link TranslateDocumentHandler}, the runner
+ * context that wraps each task with lifecycle notifications, the runner's config modifier, and the
+ * per-request {@link TaskRunnerFactory} (decorated with `onQueued` notification when configured).
+ *
+ * Extracted from the plugin's `init()` so the composition root stays a flat list — `plugin.ts` calls
+ * this once and registers the returned `configModifier` through the shared builder.
+ */ export function wireTranslateRunner({ translationProvider, schemaMap, provenanceServiceFactory, runner, lifecycle, collections }) {
+    const translateHandler = new TranslateDocumentHandler(translationProvider, schemaMap, provenanceServiceFactory);
+    const runnerContext = {
+        handler: async (payload, input)=>{
+            const notifier = new LifecycleNotifier(lifecycle, payload.logger);
+            const task = taskFromHandlerInput(input);
+            try {
+                await translateHandler.handle(payload, {
+                    collection: input.collection,
+                    collectionId: input.collectionId,
+                    sourceLng: input.sourceLng,
+                    targetLng: input.targetLng,
+                    strategy: input.strategy,
+                    publishOnTranslation: input.publishOnTranslation
+                });
+            } catch (error) {
+                await notifier.failed(task, error);
+                throw error; // rethrow so the runner marks the job failed
+            }
+            await notifier.completed(task);
+        },
+        collections
+    };
+    // Bind the context once so routes receive a self-sufficient factory: the runner needs no mutable
+    // per-instance handler state, and create() has no "configure() must run first" ordering coupling.
+    // When an `onQueued` callback is set, decorate the runner so `enqueue` fires it.
+    const taskRunnerFactory = {
+        create: (payload)=>{
+            const taskRunner = runner.create(payload, runnerContext.handler);
+            if (!lifecycle.onQueued) return taskRunner;
+            return withQueuedNotification(taskRunner, new LifecycleNotifier(lifecycle, payload.logger));
+        }
+    };
+    return {
+        taskRunnerFactory,
+        configModifier: runner.configure(runnerContext)
+    };
+}
+
+//# sourceMappingURL=wireTranslateRunner.js.map

package/dist/server/modules/provenance/{provenanceCollection.d.ts → Provenance.collection.d.ts}

@@ -1,14 +1,7 @@
 import type { CollectionConfig } from "payload";
+import type { ManagedCollectionsConfig } from "./Provenance.shapes";
 /** Default slug for the provenance sidecar collection. Overridable via `provenance.slug`. */
 export declare const DEFAULT_PROVENANCE_SLUG = "translator-provenance";
-/**
- * True for the plugin's own provenance sidecar collection. Recognised by the {@link PROVENANCE_MARKER}
- * on `custom` (not the slug, which is consumer-configurable), so plugin wiring can stay idempotent on
- * a repeated run and the slug-collision guard can ignore an already-added sidecar.
- */
-export declare function isProvenanceCollection(collection: {
-    custom?: unknown;
-}): boolean;
 /**
  * Build the Payload config for the provenance sidecar collection.
  *
@@ -18,6 +11,21 @@ export declare function isProvenanceCollection(collection: {
  * content. The composite index on `(collectionSlug, documentId, targetLocale)` is the upsert key.
  *
  * The plugin ships only this config; the consumer's Payload creates the table (see the design doc's
- * SQL-migration note). Enabled only when the consumer opts in via `provenance` (wired in slice B).
+ * SQL-migration note). Enabled only when the consumer opts in via `provenance`.
  */
 export declare function makeProvenanceCollection(slug?: string): CollectionConfig;
+/**
+ * True for the plugin's own provenance sidecar collection. Recognised by the {@link PROVENANCE_MARKER}
+ * on `custom` (not the slug, which is consumer-configurable), so plugin wiring can stay idempotent on
+ * a repeated run and the slug-collision guard can ignore an already-added sidecar.
+ */
+export declare function isProvenanceCollection(collection: {
+    custom?: unknown;
+}): boolean;
+/**
+ * Idempotently register the provenance sidecar collection on `host`: add it once, skipping when a
+ * sidecar with this slug is already present, so a repeated `init()` never stacks a duplicate. Takes
+ * only the narrow {@link ManagedCollectionsConfig} slice — a real Payload `Config` is structurally
+ * assignable, and a test passes a plain `{ collections: [...] }` literal.
+ */
+export declare function ensureProvenanceCollectionRegistered(host: ManagedCollectionsConfig, slug: string): void;

package/dist/server/modules/provenance/{provenanceCollection.js → Provenance.collection.js}

@@ -1,12 +1,5 @@
 /** Default slug for the provenance sidecar collection. Overridable via `provenance.slug`. */ export const DEFAULT_PROVENANCE_SLUG = "translator-provenance";
 /** The `custom` marker tagging the plugin's own provenance sidecar (set + read in this module). */ const PROVENANCE_MARKER = "translatorProvenance";
-/**
- * True for the plugin's own provenance sidecar collection. Recognised by the {@link PROVENANCE_MARKER}
- * on `custom` (not the slug, which is consumer-configurable), so plugin wiring can stay idempotent on
- * a repeated run and the slug-collision guard can ignore an already-added sidecar.
- */ export function isProvenanceCollection(collection) {
-    return collection.custom?.[PROVENANCE_MARKER] === true;
-}
 /**
  * Build the Payload config for the provenance sidecar collection.
  *
@@ -16,7 +9,7 @@
  * content. The composite index on `(collectionSlug, documentId, targetLocale)` is the upsert key.
  *
  * The plugin ships only this config; the consumer's Payload creates the table (see the design doc's
- * SQL-migration note). Enabled only when the consumer opts in via `provenance` (wired in slice B).
+ * SQL-migration note). Enabled only when the consumer opts in via `provenance`.
  */ export function makeProvenanceCollection(slug = DEFAULT_PROVENANCE_SLUG) {
     return {
         slug,
@@ -78,5 +71,26 @@
         ]
     };
 }
+/**
+ * True for the plugin's own provenance sidecar collection. Recognised by the {@link PROVENANCE_MARKER}
+ * on `custom` (not the slug, which is consumer-configurable), so plugin wiring can stay idempotent on
+ * a repeated run and the slug-collision guard can ignore an already-added sidecar.
+ */ export function isProvenanceCollection(collection) {
+    return collection.custom?.[PROVENANCE_MARKER] === true;
+}
+/**
+ * Idempotently register the provenance sidecar collection on `host`: add it once, skipping when a
+ * sidecar with this slug is already present, so a repeated `init()` never stacks a duplicate. Takes
+ * only the narrow {@link ManagedCollectionsConfig} slice — a real Payload `Config` is structurally
+ * assignable, and a test passes a plain `{ collections: [...] }` literal.
+ */ export function ensureProvenanceCollectionRegistered(host, slug) {
+    const alreadyAdded = host.collections?.some((collection)=>collection.slug === slug && isProvenanceCollection(collection));
+    if (!alreadyAdded) {
+        host.collections = [
+            ...host.collections ?? [],
+            makeProvenanceCollection(slug)
+        ];
+    }
+}
 
-//# sourceMappingURL=provenanceCollection.js.map
+//# sourceMappingURL=Provenance.collection.js.map