@purposeinplay/payload-ai-translate 0.1.0

package/dist/endpoints/translation-hub/force-reset.js

@@ -0,0 +1,144 @@
+import { DEFAULT_BULK_TRANSLATE_BATCHES_COLLECTION_SLUG } from '../../bulk-translate-batches-collection.js';
+import { DEFAULT_BULK_TRANSLATE_UNITS_COLLECTION_SLUG } from '../../bulk-translate-units-collection.js';
+import { createScopedLogger } from '../../lib/logger.js';
+import { errorResponse, isAdminUser, unauthorizedResponse } from './_helpers.js';
+import { extractBatchId } from './status.js';
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+/**
+ * `POST /api/translation-hub/bulk-translate/:id/force-reset`
+ *
+ * Recovery action — F-SEC-CRON-RESET. Marks every `running` unit in
+ * the batch as `failed` with `failureCode: 'transient.crashed'` and
+ * the batch itself as `failed`. Used by on-call when the worker /
+ * coordinator stalled and the normal janitor sweep hasn't picked it
+ * up.
+ *
+ * Auth: admin only — explicitly NO TOTP gate (this is a recovery
+ * action; admins must be able to unblock production without a TOTP
+ * dance if their mobile device is unavailable). The daily USD cap
+ * already enforced spending bounds for the batch in question.
+ */ export const getBulkTranslateForceResetHandler = (options = {})=>async (req)=>{
+        const batchesSlug = options.batchesCollectionSlug ?? DEFAULT_BULK_TRANSLATE_BATCHES_COLLECTION_SLUG;
+        const unitsSlug = options.unitsCollectionSlug ?? DEFAULT_BULK_TRANSLATE_UNITS_COLLECTION_SLUG;
+        if (!req.user) {
+            return unauthorizedResponse(req);
+        }
+        if (!isAdminUser(req.user)) {
+            return errorResponse('forbidden', 'Admin role required to force-reset a bulk-translation batch.', 403);
+        }
+        const batchId = extractBatchId(req.url ?? '');
+        if (!batchId) {
+            return errorResponse('invalid_batch_id', 'Batch ID could not be parsed from the request URL.', 400);
+        }
+        let batch;
+        try {
+            batch = await req.payload.findByID({
+                collection: batchesSlug,
+                id: batchId,
+                overrideAccess: true,
+                depth: 0
+            });
+        } catch (err) {
+            const log = createScopedLogger(req.payload, {
+                component: 'hub.force-reset',
+                batchId
+            });
+            log.event('warn', 'hub.force-reset.batch-read.failed', {
+                err,
+                endpoint: 'hub.force-reset',
+                batchId
+            });
+            batch = undefined;
+        }
+        if (!batch) {
+            return errorResponse('not_found', 'This translation run no longer exists. Refresh the page.', 404);
+        }
+        // Reset every `running` unit. The batch may also have `pending`
+        // units (queued payload-jobs rows that never dequeued because of
+        // a coordinator stall) — those are reset too, since the operator
+        // is explicitly unblocking the batch.
+        let resetUnits = 0;
+        const RESET_STATUSES = [
+            'running',
+            'pending'
+        ];
+        for (const status of RESET_STATUSES){
+            let page = 1;
+            // eslint-disable-next-line no-constant-condition
+            while(true){
+                const result = await req.payload.find({
+                    collection: unitsSlug,
+                    where: {
+                        and: [
+                            {
+                                batchId: {
+                                    equals: batchId
+                                }
+                            },
+                            {
+                                status: {
+                                    equals: status
+                                }
+                            }
+                        ]
+                    },
+                    page,
+                    limit: 1000,
+                    depth: 0,
+                    overrideAccess: true
+                });
+                for (const u of result.docs){
+                    try {
+                        await req.payload.update({
+                            collection: unitsSlug,
+                            id: u.id,
+                            data: {
+                                status: 'failed',
+                                failureCode: 'transient.crashed',
+                                failureMessage: 'force-reset by admin',
+                                completedAt: new Date().toISOString()
+                            },
+                            overrideAccess: true
+                        });
+                        resetUnits += 1;
+                    } catch (err) {
+                        req.payload.logger?.warn?.(`[ai-translate] force-reset: failed to reset unit ${String(u.id)}: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+                if (!result.hasNextPage) break;
+                page += 1;
+            }
+        }
+        // Mark batch itself as failed. We don't transition to `cancelled`
+        // because force-reset is an abnormal termination, not an admin-
+        // initiated cancel — the distinction matters for downstream
+        // alerting / analytics.
+        try {
+            await req.payload.update({
+                collection: batchesSlug,
+                id: batchId,
+                data: {
+                    status: 'failed',
+                    completedAt: new Date().toISOString(),
+                    failures: {
+                        ...batch.failures ?? {},
+                        force_reset_by: String(req.user.id),
+                        force_reset_note: 'force-reset by admin'
+                    }
+                },
+                overrideAccess: true
+            });
+        } catch (err) {
+            req.payload.logger?.warn?.(`[ai-translate] force-reset: failed to mark batch failed for ${batchId}: ${err instanceof Error ? err.message : String(err)}`);
+            return errorResponse('reset_failed', "The reset couldn't be saved. Try again, or contact engineering if it keeps happening.", 500);
+        }
+        return Response.json({
+            data: {
+                batchId,
+                resetUnits,
+                status: 'failed'
+            }
+        });
+    };

package/dist/endpoints/translation-hub/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Translation Hub bulk-translate REST endpoints (PR2 v1.2.0).
+ *
+ * Public surface mounted at `/api/translation-hub/bulk-translate/...`
+ * by the plugin's central wiring step (`plugin.ts`). Each handler is
+ * a factory that takes optional slug/task overrides for testability;
+ * production wiring uses defaults.
+ *
+ * Reference: docs/tickets/Plan-2026-05-27-bulk-translate.md §4.
+ */
+export { type BulkActiveHandlerOptions, getBulkTranslateActiveHandler, } from './active.js';
+export { type BulkCancelHandlerOptions, getBulkTranslateCancelHandler, } from './cancel.js';
+export { type BulkEnqueueBody, type BulkEnqueueHandlerOptions, type BulkEnqueueScope, getBulkTranslateEnqueueHandler, } from './enqueue.js';
+export { type BulkFailuresHandlerOptions, getBulkTranslateFailuresHandler, } from './failures.js';
+export { type BulkForceResetHandlerOptions, getBulkTranslateForceResetHandler, } from './force-reset.js';
+export { type BulkListHandlerOptions, getBulkTranslateListHandler, } from './list.js';
+export { type BulkPreflightHandlerOptions, getBulkTranslatePreflightHandler, } from './preflight.js';
+export { type BulkRetryFailedBody, type BulkRetryFailedHandlerOptions, getBulkTranslateRetryFailedHandler, } from './retry-failed.js';
+export { type BulkRevertBody, type BulkRevertHandlerOptions, type BulkRevertWarning, getBulkTranslateRevertHandler, } from './revert.js';
+export { type BatchJobSummary, type BulkStatusHandlerOptions, extractBatchId, getBulkTranslateStatusHandler, } from './status.js';
+export { getTranslationHubUsageSummaryHandler, parseRangeParams, type UsageSummaryCollectionBucket, type UsageSummaryHandlerOptions, type UsageSummaryLocaleBucket, type UsageSummaryModelBucket, type UsageSummaryRange, type UsageSummaryResponse, type UsageSummarySampleRow, type UsageSummaryTotals, } from './usage-summary.js';

package/dist/endpoints/translation-hub/index.js

@@ -0,0 +1,20 @@
+/**
+ * Translation Hub bulk-translate REST endpoints (PR2 v1.2.0).
+ *
+ * Public surface mounted at `/api/translation-hub/bulk-translate/...`
+ * by the plugin's central wiring step (`plugin.ts`). Each handler is
+ * a factory that takes optional slug/task overrides for testability;
+ * production wiring uses defaults.
+ *
+ * Reference: docs/tickets/Plan-2026-05-27-bulk-translate.md §4.
+ */ export { getBulkTranslateActiveHandler } from './active.js';
+export { getBulkTranslateCancelHandler } from './cancel.js';
+export { getBulkTranslateEnqueueHandler } from './enqueue.js';
+export { getBulkTranslateFailuresHandler } from './failures.js';
+export { getBulkTranslateForceResetHandler } from './force-reset.js';
+export { getBulkTranslateListHandler } from './list.js';
+export { getBulkTranslatePreflightHandler } from './preflight.js';
+export { getBulkTranslateRetryFailedHandler } from './retry-failed.js';
+export { getBulkTranslateRevertHandler } from './revert.js';
+export { extractBatchId, getBulkTranslateStatusHandler } from './status.js';
+export { getTranslationHubUsageSummaryHandler, parseRangeParams } from './usage-summary.js';

package/dist/endpoints/translation-hub/list.d.ts

@@ -0,0 +1,40 @@
+import type { PayloadHandler } from 'payload';
+export interface BulkListHandlerOptions {
+    batchesCollectionSlug?: string;
+    unitsCollectionSlug?: string;
+    /**
+     * Window after a batch's `completedAt` during which Revert is still
+     * allowed. Defaults to 24h, mirroring the same constant in
+     * `active.ts` (Decision #28). Exported as `revertExpiresAt` on each
+     * row so the UI can render the countdown without a second query.
+     */
+    revertWindowMs?: number;
+}
+/**
+ * `GET /api/translation-hub/bulk-translate`
+ *
+ * Paginated list of every bulk-translate batch the operator can see,
+ * sorted by `enqueuedAt DESC`. Powers the Bulk Translate Runs hub
+ * (see `views/BulkRunsHub`).
+ *
+ * Query params:
+ *   - `status` — comma-separated list (active|terminal|queued|running|
+ *     cancelling|success|failed|partial|reverted|cancelled). The
+ *     aliases `active` and `terminal` expand to the full status sets.
+ *   - `mode` — changed|force|canary
+ *   - `triggeredBy` — email exact match
+ *   - `since`, `until` — ISO timestamps on `enqueuedAt`
+ *   - `hasFailures` — `true` filters to batches with failed_units > 0
+ *   - `cursor` — opaque base64 from the previous response
+ *   - `limit` — page size (default 20, max 100)
+ *
+ * Response shape:
+ *   `{ batches: BulkTranslateBatchSummary[], nextCursor: string | null,
+ *     total: number }`
+ *
+ * The per-collection progress breakdown is NOT included here for
+ * performance; the Runs hub drill-down fetches it via `/:id/status`
+ * when a row is expanded. `collections: []` is returned for type
+ * compatibility with the shared `BulkTranslateBatchSummary` shape.
+ */
+export declare const getBulkTranslateListHandler: (options?: BulkListHandlerOptions) => PayloadHandler;

package/dist/endpoints/translation-hub/list.js

@@ -0,0 +1,182 @@
+import { DEFAULT_BULK_TRANSLATE_BATCHES_COLLECTION_SLUG } from '../../bulk-translate-batches-collection.js';
+import { DEFAULT_BULK_TRANSLATE_UNITS_COLLECTION_SLUG } from '../../bulk-translate-units-collection.js';
+import { computeLiveBatchCounts } from '../../lib/batch-counts.js';
+import { decodeCursor, encodeCursor, errorResponse, isEditorOrAdmin, unauthorizedResponse } from './_helpers.js';
+const DEFAULT_REVERT_WINDOW_MS = 24 * 60 * 60 * 1000;
+const ACTIVE_STATUSES = [
+    'queued',
+    'running',
+    'cancelling'
+];
+const TERMINAL_STATUSES = [
+    'success',
+    'failed',
+    'partial',
+    'reverted',
+    'cancelled'
+];
+/**
+ * `GET /api/translation-hub/bulk-translate`
+ *
+ * Paginated list of every bulk-translate batch the operator can see,
+ * sorted by `enqueuedAt DESC`. Powers the Bulk Translate Runs hub
+ * (see `views/BulkRunsHub`).
+ *
+ * Query params:
+ *   - `status` — comma-separated list (active|terminal|queued|running|
+ *     cancelling|success|failed|partial|reverted|cancelled). The
+ *     aliases `active` and `terminal` expand to the full status sets.
+ *   - `mode` — changed|force|canary
+ *   - `triggeredBy` — email exact match
+ *   - `since`, `until` — ISO timestamps on `enqueuedAt`
+ *   - `hasFailures` — `true` filters to batches with failed_units > 0
+ *   - `cursor` — opaque base64 from the previous response
+ *   - `limit` — page size (default 20, max 100)
+ *
+ * Response shape:
+ *   `{ batches: BulkTranslateBatchSummary[], nextCursor: string | null,
+ *     total: number }`
+ *
+ * The per-collection progress breakdown is NOT included here for
+ * performance; the Runs hub drill-down fetches it via `/:id/status`
+ * when a row is expanded. `collections: []` is returned for type
+ * compatibility with the shared `BulkTranslateBatchSummary` shape.
+ */ export const getBulkTranslateListHandler = (options = {})=>async (req)=>{
+        const batchesSlug = options.batchesCollectionSlug ?? DEFAULT_BULK_TRANSLATE_BATCHES_COLLECTION_SLUG;
+        const unitsSlug = options.unitsCollectionSlug ?? DEFAULT_BULK_TRANSLATE_UNITS_COLLECTION_SLUG;
+        const revertWindowMs = options.revertWindowMs ?? DEFAULT_REVERT_WINDOW_MS;
+        if (!req.user) {
+            return unauthorizedResponse(req);
+        }
+        if (!isEditorOrAdmin(req.user)) {
+            return errorResponse('forbidden', "You don't have permission to view bulk-translation history. Contact an admin.", 403);
+        }
+        const url = new URL(req.url ?? 'http://localhost');
+        const params = url.searchParams;
+        const limitRaw = params.get('limit');
+        let limit = limitRaw ? Number.parseInt(limitRaw, 10) : 20;
+        if (!Number.isFinite(limit) || limit <= 0) limit = 20;
+        if (limit > 100) limit = 100;
+        const offset = decodeCursor(params.get('cursor') ?? undefined);
+        const page = Math.floor(offset / limit) + 1;
+        const andClauses = [];
+        // status filter — expand aliases
+        const statusParam = params.get('status');
+        if (statusParam) {
+            const raw = statusParam.split(',').map((s)=>s.trim()).filter(Boolean);
+            const expanded = new Set();
+            for (const s of raw){
+                if (s === 'active') {
+                    for (const x of ACTIVE_STATUSES)expanded.add(x);
+                } else if (s === 'terminal') {
+                    for (const x of TERMINAL_STATUSES)expanded.add(x);
+                } else {
+                    expanded.add(s);
+                }
+            }
+            if (expanded.size > 0) {
+                andClauses.push({
+                    status: {
+                        in: Array.from(expanded)
+                    }
+                });
+            }
+        }
+        const modeParam = params.get('mode');
+        if (modeParam) {
+            andClauses.push({
+                mode: {
+                    equals: modeParam
+                }
+            });
+        }
+        const triggeredByParam = params.get('triggeredBy');
+        if (triggeredByParam) {
+            andClauses.push({
+                triggeredByEmail: {
+                    equals: triggeredByParam
+                }
+            });
+        }
+        const sinceParam = params.get('since');
+        if (sinceParam) {
+            andClauses.push({
+                enqueuedAt: {
+                    greater_than_equal: sinceParam
+                }
+            });
+        }
+        const untilParam = params.get('until');
+        if (untilParam) {
+            andClauses.push({
+                enqueuedAt: {
+                    less_than_equal: untilParam
+                }
+            });
+        }
+        const hasFailuresParam = params.get('hasFailures');
+        if (hasFailuresParam === 'true') {
+            andClauses.push({
+                failedUnits: {
+                    greater_than: 0
+                }
+            });
+        }
+        const where = andClauses.length > 0 ? {
+            and: andClauses
+        } : undefined;
+        const result = await req.payload.find({
+            collection: batchesSlug,
+            where,
+            sort: '-enqueuedAt',
+            page,
+            limit,
+            depth: 0,
+            overrideAccess: true
+        });
+        // Live counts per batch — source of truth is `bulk_translate_units`,
+        // not the cached `completed_units / failed_units / skipped_units`
+        // columns on the batch row (which drift on retries / cancels /
+        // admin SDK interventions). See `lib/batch-counts.ts`.
+        const batchIds = result.docs.map((r)=>String(r.id));
+        const liveCounts = await computeLiveBatchCounts(req.payload, unitsSlug, batchIds);
+        const batches = result.docs.map((row)=>{
+            const completedAtMs = row.completedAt ? Date.parse(row.completedAt) : null;
+            const revertExpiresAt = completedAtMs !== null ? new Date(completedAtMs + revertWindowMs).toISOString() : null;
+            const live = liveCounts.get(String(row.id));
+            // Use the live unit-derived total when it's > 0 — for in-flight
+            // and recently-completed batches the unit rows ARE the source of
+            // truth. Fall back to the cached `totalUnits` on the batch row
+            // only when the live count is 0 (empty batch / coordinator hasn't
+            // run yet) so the user sees the planned size, not "0 / 0".
+            const liveTotal = live?.total ?? 0;
+            const totalUnits = liveTotal > 0 ? liveTotal : Number(row.totalUnits ?? 0);
+            return {
+                id: String(row.id),
+                status: row.status,
+                mode: row.mode,
+                totalUnits,
+                completedUnits: live?.completed ?? 0,
+                failedUnits: live?.failed ?? 0,
+                estimatedCostUsd: row.estimatedCostUsd !== undefined ? Number(row.estimatedCostUsd) : undefined,
+                actualCostUsd: row.actualCostUsd !== undefined ? Number(row.actualCostUsd) : undefined,
+                createdAt: row.createdAt ?? row.enqueuedAt ?? new Date(0).toISOString(),
+                startedAt: row.startedAt ?? null,
+                completedAt: row.completedAt ?? null,
+                etaSeconds: null,
+                collections: [],
+                revertExpiresAt,
+                revertedAt: row.revertedAt ?? null,
+                triggeredByEmail: row.triggeredByEmail ?? null,
+                // 1.2.8: editor variant uses this to set the "you" chip on
+                // rows the viewer owns (`EditorRecentRunsPanel`).
+                triggeredByUserId: row.triggeredByUserId != null ? String(row.triggeredByUserId) : null
+            };
+        });
+        const nextCursor = batches.length === limit ? encodeCursor(offset + limit) : null;
+        return Response.json({
+            batches,
+            nextCursor,
+            total: result.totalDocs
+        });
+    };

package/dist/endpoints/translation-hub/preflight.d.ts

@@ -0,0 +1,19 @@
+import type { PayloadHandler } from 'payload';
+export interface BulkPreflightHandlerOptions {
+    dailySpendCollectionSlug?: string;
+}
+/**
+ * `GET /api/translation-hub/bulk-translate/preflight`
+ *
+ * Returns a snapshot of the work the operator would dispatch if they
+ * confirmed a bulk-translate run: scope (collections × locales),
+ * document counts, today's USD spend vs cap, and whether TOTP is
+ * required + enrolled for this user.
+ *
+ * The cost estimate is intentionally omitted in v1 — the trigger UI
+ * tolerates `undefined` (renders a "cost loading" placeholder) and the
+ * real estimator path runs at enqueue-time inside the coordinator.
+ * Adding a true preflight estimate would re-run the diff + provider
+ * pricing fetch on every modal open, which is too expensive.
+ */
+export declare const getBulkTranslatePreflightHandler: (options?: BulkPreflightHandlerOptions) => PayloadHandler;

package/dist/endpoints/translation-hub/preflight.js

@@ -0,0 +1,141 @@
+import { DEFAULT_TRANSLATION_DAILY_SPEND_COLLECTION_SLUG } from '../../translation-daily-spend-collection.js';
+import { errorResponse, getAiTranslateConfig, getBulkConfig, isEditorOrAdmin, unauthorizedResponse } from './_helpers.js';
+import { estimateBatchCost, resolveScope } from './enqueue.js';
+/**
+ * `GET /api/translation-hub/bulk-translate/preflight`
+ *
+ * Returns a snapshot of the work the operator would dispatch if they
+ * confirmed a bulk-translate run: scope (collections × locales),
+ * document counts, today's USD spend vs cap, and whether TOTP is
+ * required + enrolled for this user.
+ *
+ * The cost estimate is intentionally omitted in v1 — the trigger UI
+ * tolerates `undefined` (renders a "cost loading" placeholder) and the
+ * real estimator path runs at enqueue-time inside the coordinator.
+ * Adding a true preflight estimate would re-run the diff + provider
+ * pricing fetch on every modal open, which is too expensive.
+ */ export const getBulkTranslatePreflightHandler = (options = {})=>async (req)=>{
+        const dailySlug = options.dailySpendCollectionSlug ?? DEFAULT_TRANSLATION_DAILY_SPEND_COLLECTION_SLUG;
+        if (!req.user) {
+            return unauthorizedResponse(req);
+        }
+        if (!isEditorOrAdmin(req.user)) {
+            return errorResponse('forbidden', "You don't have permission to start a bulk translation. Contact an admin.", 403);
+        }
+        const config = getAiTranslateConfig(req.payload);
+        const bulkConfig = getBulkConfig(req.payload);
+        if (!config || !bulkConfig) {
+            return errorResponse('not_configured', "Bulk translation isn't set up for this site. Contact engineering.", 404);
+        }
+        const excludeSet = new Set(bulkConfig.excludeCollections ?? []);
+        const collections = (config.collections ?? []).filter((slug)=>!excludeSet.has(slug));
+        const globals = (config.globals ?? []).filter((slug)=>!excludeSet.has(slug));
+        const targetLocales = config.targetLocales ?? [];
+        // Per-collection counts. `total` = docs in the collection;
+        // `changed` is a best-effort guess that matches `total` (the real
+        // diff-skip evaluation happens inside the coordinator at enqueue
+        // time, not preflight). The UI uses these for proportions only.
+        const perCollection = [];
+        let totalDocs = 0;
+        for (const slug of collections){
+            try {
+                const result = await req.payload.count({
+                    collection: slug,
+                    overrideAccess: true
+                });
+                const count = Number(result.totalDocs ?? 0);
+                perCollection.push({
+                    slug,
+                    label: slug,
+                    changed: count,
+                    total: count
+                });
+                totalDocs += count;
+            } catch  {
+                perCollection.push({
+                    slug,
+                    label: slug,
+                    changed: 0,
+                    total: 0
+                });
+            }
+        }
+        // Globals contribute exactly one "document" each.
+        for (const slug of globals){
+            perCollection.push({
+                slug,
+                label: slug,
+                changed: 1,
+                total: 1
+            });
+            totalDocs += 1;
+        }
+        // Daily spend lookup — keyed by ISO date string (YYYY-MM-DD).
+        const today = new Date().toISOString().slice(0, 10);
+        let spentUsd = 0;
+        try {
+            const result = await req.payload.find({
+                collection: dailySlug,
+                where: {
+                    and: [
+                        {
+                            date: {
+                                equals: today
+                            }
+                        },
+                        {
+                            consumerKey: {
+                                equals: 'default'
+                            }
+                        }
+                    ]
+                },
+                limit: 1,
+                depth: 0,
+                overrideAccess: true
+            });
+            const row = result.docs[0];
+            spentUsd = Number(row?.spendUsd ?? 0);
+        } catch  {
+            spentUsd = 0;
+        }
+        const capUsd = Number(bulkConfig.dailyUsdCap ?? 0);
+        const tomorrow = new Date();
+        tomorrow.setUTCHours(24, 0, 0, 0);
+        const resetsAt = tomorrow.toISOString();
+        const requireTotp = bulkConfig.requireTotp === true;
+        const userTotp = req.user?.totp;
+        const totpEnrolled = !!userTotp?.enabled;
+        // Real cost estimate — reuse the enqueue handler's estimator so
+        // preflight and enqueue agree on the number. Caps at 500 docs per
+        // collection inside `estimateBatchCost`; bounded wall-clock.
+        let estimatedCostUsd;
+        try {
+            const resolved = resolveScope({}, config, bulkConfig);
+            const result = await estimateBatchCost(req.payload, config, resolved);
+            estimatedCostUsd = result.estimatedCostUsd;
+        } catch (err) {
+            req.payload.logger?.warn?.(`[ai-translate] preflight: estimate failed: ${err instanceof Error ? err.message : String(err)}`);
+            estimatedCostUsd = undefined;
+        }
+        return Response.json({
+            scope: {
+                collections,
+                globals,
+                locales: targetLocales,
+                sourceLocale: config.sourceLocale
+            },
+            documents: {
+                total: totalDocs * Math.max(1, targetLocales.length),
+                perCollection
+            },
+            estimatedCostUsd,
+            dailySpend: {
+                spentUsd,
+                capUsd,
+                resetsAt
+            },
+            requireTotp,
+            totpEnrolled
+        });
+    };

package/dist/endpoints/translation-hub/retry-failed.d.ts

@@ -0,0 +1,38 @@
+import type { PayloadHandler } from 'payload';
+export interface BulkRetryFailedBody {
+    /**
+     * Failure codes to exclude from this retry (e.g. permanent classes
+     * a human reviewed and decided not to re-run). Optional.
+     */
+    skipErrorCodes?: string[];
+    /**
+     * When set, only retry failed units in this collection or global. Used
+     * by the tree-grouped DrillDown's per-bucket "Retry N failed" CTA so
+     * the editor can retry one collection's subset without touching the
+     * others. Optional — omitted means "all failed units in the batch."
+     */
+    collection?: string;
+    /**
+     * When set alongside `collection`, only retry failed units for THIS
+     * document. Used by the per-doc Retry button. Combined with
+     * `collection` rather than alone because a docId is only meaningful
+     * within a collection. Optional.
+     */
+    documentId?: string;
+}
+export interface BulkRetryFailedHandlerOptions {
+    batchesCollectionSlug?: string;
+    unitsCollectionSlug?: string;
+    workerTaskSlug?: string;
+}
+/**
+ * `POST /api/translation-hub/bulk-translate/:id/retry-failed`
+ *
+ * Re-enqueues all `failed` units for the batch back to `pending`.
+ * Refuses when the batch is non-terminal — there's no semantic way
+ * to "retry failed" while units are still running.
+ *
+ * Daily-cap is re-checked (F-SEC-TOTP-BYPASS — the cap applies to all
+ * translate paths, not just first-enqueue).
+ */
+export declare const getBulkTranslateRetryFailedHandler: (options?: BulkRetryFailedHandlerOptions) => PayloadHandler;