bunqueue 2.8.60 → 2.9.0

package/dist/infrastructure/cloud/commands/queues.js

@@ -1,94 +1,94 @@
+import { DEFAULT_DLQ_CONFIG } from '../../../domain/types/dlq';
+import { DEFAULT_STALL_CONFIG } from '../../../domain/types/stall';
 import { mapCloudCommandJob } from './jobMapper';
 export const QUEUE_COMMANDS = {
-    'queue:pause': (queueManager, command) => {
-        queueManager.pause(command.queue ?? '');
+    'queue:pause': async (adapter, command) => {
+        await adapter.pause(command.queue ?? '', true);
         return { queue: command.queue, paused: true };
     },
-    'queue:resume': (queueManager, command) => {
-        queueManager.resume(command.queue ?? '');
+    'queue:resume': async (adapter, command) => {
+        await adapter.pause(command.queue ?? '', false);
         return { queue: command.queue, paused: false };
     },
-    'queue:drain': (queueManager, command) => {
-        const count = queueManager.drain(command.queue ?? '');
+    'queue:drain': async (adapter, command) => {
+        const count = await adapter.drain(command.queue ?? '');
         return { queue: command.queue, drained: count };
     },
-    'queue:clean': (queueManager, command) => {
-        const ids = queueManager.clean(command.queue ?? '', command.graceMs ?? 0, command.state, command.limit);
+    'queue:clean': async (adapter, command) => {
+        const ids = await adapter.clean(command.queue ?? '', command.graceMs ?? 0, command.state, command.limit);
         return { queue: command.queue, cleaned: ids.length, ids };
     },
-    'queue:obliterate': (queueManager, command) => {
-        queueManager.obliterate(command.queue ?? '');
+    'queue:obliterate': async (adapter, command) => {
+        await adapter.obliterate(command.queue ?? '');
         return { queue: command.queue, obliterated: true };
     },
-    'queue:promoteAll': async (queueManager, command) => {
+    'queue:promoteAll': async (adapter, command) => {
         const limit = command.limit ?? 1000;
-        const jobs = queueManager.getJobs(command.queue ?? '', {
-            state: ['delayed'],
-            start: 0,
-            end: limit - 1,
-        });
-        let promoted = 0;
-        for (const job of jobs) {
-            try {
-                await queueManager.promote(job.id);
-                promoted++;
-            }
-            catch {
-                // Skip jobs that can no longer be promoted.
-            }
-        }
+        const promoted = await adapter.promoteAll(command.queue ?? '', limit);
         return { queue: command.queue, promoted };
     },
-    'queue:retryCompleted': (queueManager, command) => {
-        const count = queueManager.retryCompleted(command.queue ?? '');
+    'queue:retryCompleted': async (adapter, command) => {
+        const count = await adapter.retryCompleted(command.queue ?? '');
         return { queue: command.queue, retried: count };
     },
-    'queue:rateLimit': (queueManager, command) => {
-        queueManager.setRateLimit(command.queue ?? '', command.max ?? 100);
+    'queue:rateLimit': async (adapter, command) => {
+        await adapter.setRateLimit(command.queue ?? '', command.max ?? 100);
         return { queue: command.queue, rateLimit: command.max ?? 100 };
     },
-    'queue:clearRateLimit': (queueManager, command) => {
-        queueManager.clearRateLimit(command.queue ?? '');
+    'queue:clearRateLimit': async (adapter, command) => {
+        await adapter.setRateLimit(command.queue ?? '', null);
         return { queue: command.queue, rateLimit: null };
     },
-    'queue:concurrency': (queueManager, command) => {
-        queueManager.setConcurrency(command.queue ?? '', command.concurrency ?? 10);
+    'queue:concurrency': async (adapter, command) => {
+        await adapter.setConcurrency(command.queue ?? '', command.concurrency ?? 10);
         return { queue: command.queue, concurrency: command.concurrency ?? 10 };
     },
-    'queue:clearConcurrency': (queueManager, command) => {
-        queueManager.clearConcurrency(command.queue ?? '');
+    'queue:clearConcurrency': async (adapter, command) => {
+        await adapter.setConcurrency(command.queue ?? '', null);
         return { queue: command.queue, concurrency: null };
     },
-    'queue:stallConfig': (queueManager, command) => {
-        queueManager.setStallConfig(command.queue ?? '', command.config ?? {});
+    'queue:stallConfig': async (adapter, command) => {
+        await adapter.setStallConfig(command.queue ?? '', command.config ?? {});
         return { queue: command.queue, stallConfig: command.config };
     },
-    'queue:dlqConfig': (queueManager, command) => {
-        queueManager.setDlqConfig(command.queue ?? '', command.config ?? {});
+    'queue:dlqConfig': async (adapter, command) => {
+        await adapter.setDlqConfig(command.queue ?? '', command.config ?? {});
         return { queue: command.queue, dlqConfig: command.config };
     },
-    'queue:detail': (queueManager, command) => {
+    'queue:detail': async (adapter, command) => {
         const queue = command.queue ?? '';
-        const counts = queueManager.getQueueJobCounts(queue);
-        const paused = queueManager.isPaused(queue);
-        const stallConfig = queueManager.getStallConfig(queue);
-        const dlqConfig = queueManager.getDlqConfig(queue);
-        const dlqEntries = queueManager.getDlqEntries(queue).slice(0, 50);
-        const jobs = queueManager.getJobs(queue, {
+        const source = await adapter.readSnapshotSource([queue]);
+        const view = source.queues.find(({ name }) => name === queue);
+        const counts = view?.counts ?? {
+            waiting: 0,
+            prioritized: 0,
+            delayed: 0,
+            active: 0,
+            completed: 0,
+            failed: 0,
+            'waiting-children': 0,
+            totalCompleted: 0,
+            totalFailed: 0,
+        };
+        const dlqEntries = source.dlqEntries.filter((entry) => entry.job.queue === queue).slice(0, 50);
+        const jobs = await adapter.listJobs(queue, {
             state: ['waiting', 'active', 'delayed', 'completed', 'failed'],
             start: 0,
-            end: 49,
+            end: 50,
         });
         return {
             queue,
-            paused,
+            paused: view?.paused ?? false,
             counts,
             stallConfig: {
-                enabled: stallConfig.enabled,
-                stallInterval: stallConfig.stallInterval,
-                maxStalls: stallConfig.maxStalls,
+                enabled: view?.stallConfig.enabled ?? DEFAULT_STALL_CONFIG.enabled,
+                stallInterval: view?.stallConfig.stallInterval ?? DEFAULT_STALL_CONFIG.stallInterval,
+                maxStalls: view?.stallConfig.maxStalls ?? DEFAULT_STALL_CONFIG.maxStalls,
+            },
+            dlqConfig: {
+                maxRetries: view?.dlqConfig.maxAutoRetries ?? DEFAULT_DLQ_CONFIG.maxAutoRetries,
+                maxAge: view?.dlqConfig.maxAge ?? DEFAULT_DLQ_CONFIG.maxAge ?? 0,
             },
-            dlqConfig: { maxRetries: dlqConfig.maxAutoRetries, maxAge: dlqConfig.maxAge ?? 0 },
             dlqEntries: dlqEntries.map((entry) => ({
                 jobId: String(entry.job.id),
                 reason: entry.reason,
@@ -99,28 +99,14 @@ export const QUEUE_COMMANDS = {
             jobs: jobs.map(mapCloudCommandJob),
         };
     },
-    'queue:list': (queueManager) => {
-        const queueNames = queueManager.listQueues();
-        const countsByQueue = queueManager.getAllQueueJobCounts();
-        const queues = queueNames.flatMap((name) => {
-            const counts = countsByQueue.get(name);
-            if (!counts)
-                return [];
-            return {
-                name,
-                waiting: counts.waiting,
-                prioritized: counts.prioritized,
-                delayed: counts.delayed,
-                active: counts.active,
-                completed: counts.completed,
-                failed: counts.failed,
-                'waiting-children': counts['waiting-children'],
-                paused: queueManager.isPaused(name),
-                totalCompleted: counts.totalCompleted,
-                totalFailed: counts.totalFailed,
-            };
-        });
+    'queue:list': async (adapter) => {
+        const source = await adapter.readSnapshotSource();
+        const queues = source.queues.map(({ name, counts, paused }) => ({
+            name,
+            ...counts,
+            paused,
+        }));
         return { queues };
     },
-    'stats:refresh': (queueManager) => queueManager.getStats(),
+    'stats:refresh': async (adapter) => (await adapter.readSnapshotSource()).stats,
 };

package/dist/infrastructure/cloud/queueAdapter/local.d.ts

@@ -0,0 +1,41 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CronJobInput } from '../../../domain/types/cron';
+import type { JobId } from '../../../domain/types/job';
+import type { CloudQueueAdapter, CloudSnapshotSource } from './types';
+/** SQLite/local Cloud strategy; delegates to the existing synchronous semantics. */
+export declare class LocalCloudQueueAdapter implements CloudQueueAdapter {
+    readonly manager: QueueManager;
+    constructor(manager: QueueManager);
+    pause(queue: string, paused: boolean): Promise<void>;
+    drain(queue: string): Promise<number>;
+    clean(queue: string, graceMs: number, state?: string, limit?: number): Promise<JobId[]>;
+    obliterate(queue: string): Promise<void>;
+    promoteAll(queue: string, limit: number): Promise<number>;
+    retryCompleted(queue: string): Promise<number>;
+    setRateLimit(queue: string, limit: number | null): Promise<void>;
+    setConcurrency(queue: string, limit: number | null): Promise<void>;
+    setStallConfig(queue: string, patch: Record<string, unknown>): Promise<void>;
+    setDlqConfig(queue: string, patch: Record<string, unknown>): Promise<void>;
+    listJobs(queue: string, options?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }): Promise<import("../../../domain/types").Job[]>;
+    getJob(id: JobId): Promise<import("../../../domain/types").Job | null>;
+    getLogs(id: JobId): Promise<import("../../../domain/types/worker").JobLogEntry[]>;
+    getResult(id: JobId): Promise<unknown>;
+    clearLogs(id: JobId, keepLogs?: number): Promise<void>;
+    retryDlq(queue: string, id?: JobId): Promise<number>;
+    purgeDlq(queue: string): Promise<number>;
+    push(queue: string, input: Parameters<QueueManager['push']>[1]): Promise<import("../../../domain/types").Job>;
+    cancel(id: JobId): Promise<boolean>;
+    promote(id: JobId): Promise<boolean>;
+    changePriority(id: JobId, priority: number): Promise<boolean>;
+    discard(id: JobId): Promise<boolean>;
+    changeDelay(id: JobId, delay: number): Promise<boolean>;
+    updateData(id: JobId, data: unknown): Promise<boolean>;
+    addCron(input: CronJobInput): Promise<import("../../../domain/types").CronJob>;
+    removeCron(name: string): Promise<boolean>;
+    readSnapshotSource(requestedQueues?: readonly string[]): Promise<CloudSnapshotSource>;
+}

package/dist/infrastructure/cloud/queueAdapter/local.js

@@ -0,0 +1,187 @@
+const SNAPSHOT_STATES = [
+    'waiting',
+    'active',
+    'delayed',
+    'failed',
+    'completed',
+    'prioritized',
+    'paused',
+    'waiting-children',
+];
+/** SQLite/local Cloud strategy; delegates to the existing synchronous semantics. */
+export class LocalCloudQueueAdapter {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    pause(queue, paused) {
+        if (paused)
+            this.manager.pause(queue);
+        else
+            this.manager.resume(queue);
+        return Promise.resolve();
+    }
+    drain(queue) {
+        return Promise.resolve(this.manager.drain(queue));
+    }
+    clean(queue, graceMs, state, limit) {
+        return Promise.resolve(this.manager.clean(queue, graceMs, state, limit));
+    }
+    obliterate(queue) {
+        this.manager.obliterate(queue);
+        return Promise.resolve();
+    }
+    async promoteAll(queue, limit) {
+        const jobs = this.manager.getJobs(queue, { state: ['delayed'], start: 0, end: limit });
+        let promoted = 0;
+        for (const job of jobs) {
+            try {
+                if (await this.manager.promote(job.id))
+                    promoted++;
+            }
+            catch {
+                // The job may have moved since the command selected it.
+            }
+        }
+        return promoted;
+    }
+    retryCompleted(queue) {
+        return Promise.resolve(this.manager.retryCompleted(queue));
+    }
+    setRateLimit(queue, limit) {
+        if (limit === null)
+            this.manager.clearRateLimit(queue);
+        else
+            this.manager.setRateLimit(queue, limit);
+        return Promise.resolve();
+    }
+    setConcurrency(queue, limit) {
+        if (limit === null)
+            this.manager.clearConcurrency(queue);
+        else
+            this.manager.setConcurrency(queue, limit);
+        return Promise.resolve();
+    }
+    setStallConfig(queue, patch) {
+        this.manager.setStallConfig(queue, patch);
+        return Promise.resolve();
+    }
+    setDlqConfig(queue, patch) {
+        this.manager.setDlqConfig(queue, patch);
+        return Promise.resolve();
+    }
+    listJobs(queue, options = {}) {
+        return Promise.resolve(this.manager.getJobs(queue, options));
+    }
+    async getJob(id) {
+        return await this.manager.getJob(id);
+    }
+    getLogs(id) {
+        return Promise.resolve(this.manager.getLogs(id));
+    }
+    getResult(id) {
+        return Promise.resolve(this.manager.getResult(id) ?? null);
+    }
+    clearLogs(id, keepLogs) {
+        this.manager.clearLogs(id, keepLogs);
+        return Promise.resolve();
+    }
+    retryDlq(queue, id) {
+        return Promise.resolve(this.manager.retryDlq(queue, id));
+    }
+    purgeDlq(queue) {
+        return Promise.resolve(this.manager.purgeDlq(queue));
+    }
+    async push(queue, input) {
+        return await this.manager.push(queue, input);
+    }
+    async cancel(id) {
+        return await this.manager.cancel(id);
+    }
+    async promote(id) {
+        return await this.manager.promote(id);
+    }
+    async changePriority(id, priority) {
+        return await this.manager.changePriority(id, priority);
+    }
+    async discard(id) {
+        return await this.manager.discard(id);
+    }
+    async changeDelay(id, delay) {
+        return await this.manager.changeDelay(id, delay);
+    }
+    async updateData(id, data) {
+        return await this.manager.updateJobData(id, data);
+    }
+    addCron(input) {
+        return Promise.resolve(this.manager.addCron(input));
+    }
+    removeCron(name) {
+        return Promise.resolve(this.manager.removeCron(name));
+    }
+    readSnapshotSource(requestedQueues = []) {
+        const queueNames = new Set([...this.manager.listQueues(), ...requestedQueues]);
+        const counts = this.manager.getQueueJobCountsBatch(queueNames);
+        const queues = [];
+        const jobs = [];
+        const dlqEntries = [];
+        for (const name of queueNames) {
+            try {
+                const queueCounts = counts.get(name);
+                if (!queueCounts)
+                    continue;
+                const limits = this.manager.getQueueLimits(name);
+                queues.push({
+                    name,
+                    counts: queueCounts,
+                    paused: this.manager.isPaused(name),
+                    rateLimit: limits.rateLimit,
+                    concurrencyLimit: limits.concurrencyLimit,
+                    stallConfig: this.manager.getStallConfig(name),
+                    dlqConfig: this.manager.getDlqConfig(name),
+                });
+            }
+            catch {
+                // Preserve the local collector's per-queue best-effort behavior.
+            }
+            for (const state of SNAPSHOT_STATES) {
+                try {
+                    for (const job of this.manager.getJobs(name, { state: [state], start: 0, end: 1000 })) {
+                        jobs.push({ job, state });
+                    }
+                }
+                catch {
+                    // Preserve the local collector's per-state best-effort behavior.
+                }
+            }
+            try {
+                dlqEntries.push(...this.manager.getDlqEntries(name));
+            }
+            catch {
+                // Preserve the local collector's per-queue best-effort behavior.
+            }
+        }
+        const jobResults = new Map();
+        for (const [id, result] of this.manager.getAllJobResults()) {
+            jobResults.set(String(id), result);
+        }
+        const jobLogs = new Map();
+        for (const [id, logs] of this.manager.getAllJobLogs())
+            jobLogs.set(String(id), logs);
+        return Promise.resolve({
+            stats: this.manager.getStats(),
+            queues,
+            jobs,
+            dlqEntries,
+            workers: this.manager.workerManager.list(),
+            workerStats: this.manager.workerManager.getStats(),
+            crons: this.manager.listCrons(),
+            jobResults,
+            jobLogs,
+            activeLocks: [...this.manager.getAllJobLocks().values()].map((lock) => ({
+                ...lock,
+                jobId: String(lock.jobId),
+            })),
+        });
+    }
+}

package/dist/infrastructure/cloud/queueAdapter/postgres.d.ts

@@ -0,0 +1,42 @@
+import { PostgresQueueManager } from '../../../application/postgresQueueManager';
+import type { CronJobInput } from '../../../domain/types/cron';
+import type { JobId } from '../../../domain/types/job';
+import type { CloudQueueAdapter, CloudSnapshotSource } from './types';
+/** PostgreSQL Cloud strategy; every shared surface goes through durable APIs. */
+export declare class PostgresCloudQueueAdapter implements CloudQueueAdapter {
+    readonly manager: PostgresQueueManager;
+    constructor(manager: PostgresQueueManager);
+    pause: (queue: string, paused: boolean) => Promise<void>;
+    drain: (queue: string) => Promise<number>;
+    clean: (queue: string, graceMs: number, state?: string, limit?: number) => Promise<JobId[]>;
+    obliterate: (queue: string) => Promise<void>;
+    promoteAll: (queue: string, limit: number) => Promise<number>;
+    retryCompleted: (queue: string) => Promise<number>;
+    setRateLimit: (queue: string, limit: number | null) => Promise<void>;
+    setConcurrency: (queue: string, limit: number | null) => Promise<void>;
+    setStallConfig: (queue: string, patch: Record<string, unknown>) => Promise<void>;
+    setDlqConfig: (queue: string, patch: Record<string, unknown>) => Promise<void>;
+    listJobs: (queue: string, options?: {
+        state?: string | string[];
+        start?: number;
+        end?: number;
+        asc?: boolean;
+    }) => Promise<import("../../../domain/types").Job[]>;
+    getJob: (id: JobId) => Promise<import("../../../domain/types").Job | null>;
+    getLogs: (id: JobId) => Promise<import("../../../domain/types/worker").JobLogEntry[]>;
+    getResult: (id: JobId) => Promise<unknown>;
+    clearLogs: (id: JobId, keepLogs?: number) => Promise<void>;
+    retryDlq: (queue: string, id?: JobId) => Promise<number>;
+    purgeDlq: (queue: string) => Promise<number>;
+    push: (queue: string, input: Parameters<PostgresQueueManager["push"]>[1]) => Promise<import("../../../domain/types").Job>;
+    cancel: (id: JobId) => Promise<boolean>;
+    promote: (id: JobId) => Promise<boolean>;
+    changePriority: (id: JobId, priority: number) => Promise<boolean>;
+    discard: (id: JobId) => Promise<boolean>;
+    changeDelay: (id: JobId, delay: number) => Promise<boolean>;
+    updateData: (id: JobId, data: unknown) => Promise<boolean>;
+    addCron: (input: CronJobInput) => Promise<import("../../../domain/types").CronJob>;
+    removeCron: (name: string) => Promise<boolean>;
+    readSnapshotSource(requestedQueues?: readonly string[]): Promise<CloudSnapshotSource>;
+    private toSnapshotSource;
+}

package/dist/infrastructure/cloud/queueAdapter/postgres.js

@@ -0,0 +1,188 @@
+import { DEFAULT_DLQ_CONFIG } from '../../../domain/types/dlq';
+import { DEFAULT_STALL_CONFIG } from '../../../domain/types/stall';
+const EMPTY_COUNTS = {
+    waiting: 0,
+    prioritized: 0,
+    delayed: 0,
+    active: 0,
+    completed: 0,
+    failed: 0,
+    waitingChildren: 0,
+};
+function queueCounts(model) {
+    const result = new Map();
+    for (const row of model.counts) {
+        const counts = result.get(row.queue) ?? { ...EMPTY_COUNTS };
+        if (row.state === 'waiting-children')
+            counts.waitingChildren = row.count;
+        else
+            counts[row.state] = row.count;
+        result.set(row.queue, counts);
+    }
+    return result;
+}
+function queueTotals(model) {
+    const result = new Map();
+    for (const row of model.totals) {
+        const totals = result.get(row.queue) ?? { completed: 0n, failed: 0n };
+        totals[row.metricType] = row.count;
+        result.set(row.queue, totals);
+    }
+    return result;
+}
+function cloudCounts(counts, totals) {
+    return {
+        waiting: counts.waiting,
+        prioritized: counts.prioritized,
+        delayed: counts.delayed,
+        active: counts.active,
+        completed: counts.completed,
+        failed: counts.failed,
+        'waiting-children': counts.waitingChildren,
+        totalCompleted: Number(totals.completed),
+        totalFailed: Number(totals.failed),
+    };
+}
+function defaultQueueState(queue) {
+    return {
+        queue,
+        paused: false,
+        rateLimit: null,
+        rateDurationMs: null,
+        rateWindowStartedAt: null,
+        rateExpiresAt: null,
+        rateCount: 0,
+        concurrencyLimit: null,
+        stallConfig: DEFAULT_STALL_CONFIG,
+        dlqConfig: DEFAULT_DLQ_CONFIG,
+    };
+}
+/** PostgreSQL Cloud strategy; every shared surface goes through durable APIs. */
+export class PostgresCloudQueueAdapter {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    pause = (queue, paused) => this.manager.pauseDurable(queue, paused);
+    drain = (queue) => this.manager.drainDurable(queue);
+    clean = (queue, graceMs, state, limit) => this.manager.cleanDurable(queue, graceMs, state, limit);
+    obliterate = (queue) => this.manager.obliterateDurable(queue);
+    promoteAll = (queue, limit) => this.manager.promoteJobs(queue, limit);
+    retryCompleted = (queue) => this.manager.retryCompletedDurable(queue);
+    setRateLimit = (queue, limit) => this.manager.setRateLimitDurable(queue, limit, null);
+    setConcurrency = (queue, limit) => this.manager.setConcurrencyDurable(queue, limit);
+    setStallConfig = (queue, patch) => this.manager.setStallConfigDurable(queue, patch);
+    setDlqConfig = (queue, patch) => this.manager.setDlqConfigDurable(queue, patch);
+    listJobs = (queue, options) => this.manager.listCloudJobsDurable(queue, options);
+    getJob = (id) => this.manager.getJob(id);
+    getLogs = (id) => this.manager.getLogsDurable(id);
+    getResult = (id) => this.manager.getCloudResultDurable(id);
+    clearLogs = (id, keepLogs) => this.manager.clearLogsDurable(id, keepLogs);
+    retryDlq = (queue, id) => this.manager.retryDlqDurable(queue, id);
+    purgeDlq = (queue) => this.manager.purgeDlqDurable(queue);
+    push = (queue, input) => this.manager.push(queue, input);
+    cancel = (id) => this.manager.cancel(id);
+    promote = (id) => this.manager.promote(id);
+    changePriority = (id, priority) => this.manager.changePriority(id, priority);
+    discard = (id) => this.manager.discard(id);
+    changeDelay = (id, delay) => this.manager.changeDelay(id, delay);
+    updateData = (id, data) => this.manager.updateJobData(id, data);
+    addCron = (input) => this.manager.addCronDurable(input);
+    removeCron = (name) => this.manager.removeCronDurable(name);
+    async readSnapshotSource(requestedQueues = []) {
+        const model = await this.manager.readCloudSnapshotDurable();
+        const counts = queueCounts(model);
+        const totals = queueTotals(model);
+        const names = new Set([
+            ...model.queueStates.map(({ queue }) => queue),
+            ...counts.keys(),
+            ...totals.keys(),
+            ...model.jobs.map(({ job }) => job.queue),
+            ...requestedQueues,
+        ]);
+        const states = new Map(model.queueStates.map((state) => [state.queue, state]));
+        const queues = [...names].sort().map((name) => {
+            const state = states.get(name) ?? defaultQueueState(name);
+            const rateExpired = state.rateExpiresAt !== null && state.rateExpiresAt <= Date.now();
+            return {
+                name,
+                counts: cloudCounts(counts.get(name) ?? EMPTY_COUNTS, totals.get(name) ?? { completed: 0n, failed: 0n }),
+                paused: state.paused,
+                rateLimit: rateExpired ? null : state.rateLimit,
+                concurrencyLimit: state.concurrencyLimit,
+                stallConfig: state.stallConfig,
+                dlqConfig: state.dlqConfig,
+            };
+        });
+        return this.toSnapshotSource(model, queues);
+    }
+    toSnapshotSource(model, queues) {
+        const aggregate = [...queueCounts(model).values()].reduce((sum, counts) => ({
+            waiting: sum.waiting + counts.waiting,
+            prioritized: sum.prioritized + counts.prioritized,
+            delayed: sum.delayed + counts.delayed,
+            active: sum.active + counts.active,
+            completed: sum.completed + counts.completed,
+            failed: sum.failed + counts.failed,
+            waitingChildren: sum.waitingChildren + counts.waitingChildren,
+        }), { ...EMPTY_COUNTS });
+        const durableTotals = [...queueTotals(model).values()].reduce((sum, item) => ({
+            completed: sum.completed + item.completed,
+            failed: sum.failed + item.failed,
+        }), { completed: 0n, failed: 0n });
+        const localStats = this.manager.getCloudProcessStats();
+        const now = Date.now();
+        const activeWorkers = model.workers.filter((worker) => now - worker.lastSeen < 30_000);
+        const workerStats = {
+            total: model.workers.length,
+            active: activeWorkers.length,
+            totalProcessed: model.workers.reduce((sum, worker) => sum + worker.processedJobs, 0),
+            totalFailed: model.workers.reduce((sum, worker) => sum + worker.failedJobs, 0),
+            activeJobs: model.workers.reduce((sum, worker) => sum + worker.activeJobs, 0),
+            concurrencySlots: activeWorkers.reduce((sum, worker) => sum + worker.concurrency, 0),
+        };
+        const jobResults = new Map(model.results.map(({ jobId: id, result }) => [String(id), result]));
+        return {
+            stats: {
+                ...localStats,
+                waiting: aggregate.waiting,
+                prioritized: aggregate.prioritized,
+                delayed: aggregate.delayed,
+                active: aggregate.active,
+                completed: aggregate.completed,
+                dlq: aggregate.failed,
+                'waiting-children': aggregate.waitingChildren,
+                totalCompleted: durableTotals.completed,
+                totalFailed: durableTotals.failed,
+                cronJobs: model.crons.length,
+                cronPending: model.crons.filter((cron) => cron.nextRun <= now).length,
+            },
+            queues,
+            jobs: model.jobs.map((row) => ({ job: row.job, state: row.state })),
+            dlqEntries: model.jobs.flatMap((row) => (row.dlqEntry ? [row.dlqEntry] : [])),
+            workers: model.workers,
+            workerStats,
+            crons: model.crons,
+            jobResults,
+            jobLogs: model.logs,
+            activeLocks: model.jobs.flatMap((row) => {
+                if (row.state !== 'active' || !row.token || !row.leaseOwner || row.leaseUntil === null) {
+                    return [];
+                }
+                const lastRenewalAt = row.job.lastHeartbeat || row.job.startedAt || row.job.createdAt;
+                return [
+                    {
+                        jobId: String(row.job.id),
+                        owner: row.leaseOwner,
+                        token: row.token,
+                        createdAt: row.job.startedAt ?? row.job.createdAt,
+                        expiresAt: row.leaseUntil,
+                        lastRenewalAt,
+                        renewalCount: row.leaseRenewals,
+                        ttl: Math.max(0, row.leaseUntil - lastRenewalAt),
+                    },
+                ];
+            }),
+        };
+    }
+}

package/dist/infrastructure/cloud/queueAdapter/registry.d.ts

@@ -0,0 +1,4 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CloudQueueAdapter } from './types';
+/** Resolve one complete engine strategy and cache it for the manager lifetime. */
+export declare function resolveCloudQueueAdapter(manager: QueueManager): CloudQueueAdapter;

package/dist/infrastructure/cloud/queueAdapter/registry.js

@@ -0,0 +1,15 @@
+import { PostgresQueueManager } from '../../../application/postgresQueueManager';
+import { LocalCloudQueueAdapter } from './local';
+import { PostgresCloudQueueAdapter } from './postgres';
+const adapters = new WeakMap();
+/** Resolve one complete engine strategy and cache it for the manager lifetime. */
+export function resolveCloudQueueAdapter(manager) {
+    const existing = adapters.get(manager);
+    if (existing)
+        return existing;
+    const adapter = manager instanceof PostgresQueueManager
+        ? new PostgresCloudQueueAdapter(manager)
+        : new LocalCloudQueueAdapter(manager);
+    adapters.set(manager, adapter);
+    return adapter;
+}