bunqueue 2.8.60 → 2.9.0

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

@@ -0,0 +1,87 @@
+import type { QueueManager } from '../../../application/queueManager';
+import type { CronJob, CronJobInput } from '../../../domain/types/cron';
+import type { DlqConfig, DlqEntry } from '../../../domain/types/dlq';
+import type { Job, JobId } from '../../../domain/types/job';
+import type { StallConfig } from '../../../domain/types/stall';
+import type { JobLogEntry, Worker } from '../../../domain/types/worker';
+export interface CloudQueueCounts {
+    waiting: number;
+    prioritized: number;
+    delayed: number;
+    active: number;
+    completed: number;
+    failed: number;
+    'waiting-children': number;
+    totalCompleted: number;
+    totalFailed: number;
+}
+export interface CloudQueueSource {
+    readonly name: string;
+    readonly counts: CloudQueueCounts;
+    readonly paused: boolean;
+    readonly rateLimit: number | null;
+    readonly concurrencyLimit: number | null;
+    readonly stallConfig: StallConfig;
+    readonly dlqConfig: DlqConfig;
+}
+export interface CloudSourceJob {
+    readonly job: Job;
+    readonly state: string;
+}
+export interface CloudSourceLock {
+    readonly jobId: string;
+    readonly owner: string;
+    readonly token: string;
+    readonly createdAt: number;
+    readonly expiresAt: number;
+    readonly lastRenewalAt: number;
+    readonly renewalCount: number;
+    readonly ttl: number;
+}
+export interface CloudSnapshotSource {
+    readonly stats: ReturnType<QueueManager['getStats']>;
+    readonly queues: readonly CloudQueueSource[];
+    readonly jobs: readonly CloudSourceJob[];
+    readonly dlqEntries: readonly DlqEntry[];
+    readonly workers: readonly Worker[];
+    readonly workerStats: ReturnType<QueueManager['workerManager']['getStats']>;
+    readonly crons: readonly CronJob[];
+    readonly jobResults: ReadonlyMap<string, unknown>;
+    readonly jobLogs: ReadonlyMap<string, readonly JobLogEntry[]>;
+    readonly activeLocks: readonly CloudSourceLock[];
+}
+export interface CloudQueueAdapter {
+    readonly 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<Job[]>;
+    getJob(id: JobId): Promise<Job | null>;
+    getLogs(id: JobId): Promise<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<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<CronJob>;
+    removeCron(name: string): Promise<boolean>;
+    readSnapshotSource(requestedQueues?: readonly string[]): Promise<CloudSnapshotSource>;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/infrastructure/cloud/snapshot/analytics.d.ts

@@ -1,11 +1,13 @@
 import type { QueueManager } from '../../../application/queueManager';
 import type { CloudSnapshot } from '../types';
+import type { CloudSnapshotSource } from '../queueAdapter/types';
 export declare function collectQueueThroughput(queues: Array<{
     name: string;
     totalCompleted: number;
     totalFailed: number;
 }>): CloudSnapshot['queueThroughput'];
 export declare function collectWorkerUtilization(queueManager: QueueManager): CloudSnapshot['workerUtilization'];
+export declare function mapSnapshotWorkerUtilization(workers: CloudSnapshotSource['workers']): CloudSnapshot['workerUtilization'];
 export declare function collectDurationHistogram(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['durationHistogram'];
 export declare function collectQueueWaitTime(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['queueWaitTime'];
 export declare function collectQueueRetryRate(recentJobs: CloudSnapshot['recentJobs']): CloudSnapshot['queueRetryRate'];

package/dist/infrastructure/cloud/snapshot/analytics.js

@@ -35,6 +35,13 @@ export function collectWorkerUtilization(queueManager) {
         utilization: worker.concurrency > 0 ? Math.round((worker.activeJobs / worker.concurrency) * 100) / 100 : 0,
     }));
 }
+export function mapSnapshotWorkerUtilization(workers) {
+    return workers.map((worker) => ({
+        id: worker.id,
+        name: worker.name,
+        utilization: worker.concurrency > 0 ? Math.round((worker.activeJobs / worker.concurrency) * 100) / 100 : 0,
+    }));
+}
 export function collectDurationHistogram(recentJobs) {
     const histogram = { lt100ms: 0, lt1s: 0, lt10s: 0, lt60s: 0, gt60s: 0 };
     for (const job of recentJobs) {

package/dist/infrastructure/cloud/snapshot/collector.d.ts

@@ -1,6 +1,7 @@
 import type { QueueManager } from '../../../application/queueManager';
 import type { CloudSnapshot } from '../types';
 import type { CollectSnapshotParams } from '../types/collector';
+import type { CloudSnapshotSource } from '../queueAdapter/types';
 /** Cached host and runtime metadata. */
 export declare const SNAPSHOT_HOST: string;
 export declare const SNAPSHOT_RUNTIME: {
@@ -16,9 +17,12 @@ export declare function resolveRedaction(params: CollectSnapshotParams): {
 };
 /** Map cron definitions to their snapshot shape. */
 export declare function collectCrons(queueManager: QueueManager): CloudSnapshot['crons'];
+export declare function mapSnapshotCrons(crons: CloudSnapshotSource['crons']): CloudSnapshot['crons'];
 /** Back-fill failed-job timing from the last DLQ attempt. */
 export declare function enrichFailedJobDurations(recentJobs: CloudSnapshot['recentJobs'], dlqEntries: CloudSnapshot['dlqEntries']): void;
 /** Collect worker registry details and derived health fields. */
 export declare function collectWorkerDetails(queueManager: QueueManager, now: number): CloudSnapshot['workerDetails'];
+export declare function mapSnapshotWorkers(workers: CloudSnapshotSource['workers'], now: number): CloudSnapshot['workerDetails'];
 /** Collect results, logs, and active locks for the snapshot. */
 export declare function collectJobArtifacts(queueManager: QueueManager): Pick<CloudSnapshot, 'jobResults' | 'jobLogEntries' | 'activeLocks'>;
+export declare function mapSnapshotJobArtifacts(source: CloudSnapshotSource): Pick<CloudSnapshot, 'jobResults' | 'jobLogEntries' | 'activeLocks'>;

package/dist/infrastructure/cloud/snapshot/collector.js

@@ -16,7 +16,10 @@ export function resolveRedaction(params) {
 }
 /** Map cron definitions to their snapshot shape. */
 export function collectCrons(queueManager) {
-    return queueManager.listCrons().map((cron) => ({
+    return mapSnapshotCrons(queueManager.listCrons());
+}
+export function mapSnapshotCrons(crons) {
+    return crons.map((cron) => ({
         name: cron.name,
         queue: cron.queue,
         schedule: cron.schedule ?? null,
@@ -83,6 +86,34 @@ export function collectWorkerDetails(queueManager, now) {
         };
     });
 }
+export function mapSnapshotWorkers(workers, now) {
+    const workerTimeoutMs = 30_000;
+    return workers.map((worker) => {
+        const totalJobs = worker.processedJobs + worker.failedJobs;
+        return {
+            id: worker.id,
+            name: worker.name,
+            queues: worker.queues,
+            concurrency: worker.concurrency,
+            hostname: worker.hostname,
+            pid: worker.pid,
+            registeredAt: worker.registeredAt,
+            lastSeen: worker.lastSeen,
+            activeJobs: worker.activeJobs,
+            processedJobs: worker.processedJobs,
+            failedJobs: worker.failedJobs,
+            currentJob: worker.currentJob,
+            uptime: now - worker.registeredAt,
+            status: now - worker.lastSeen > workerTimeoutMs
+                ? 'stalled'
+                : worker.activeJobs > 0
+                    ? 'active'
+                    : 'idle',
+            errorRate: totalJobs > 0 ? +(worker.failedJobs / totalJobs).toFixed(4) : 0,
+            utilization: worker.concurrency > 0 ? +(worker.activeJobs / worker.concurrency).toFixed(4) : 0,
+        };
+    });
+}
 /** Collect results, logs, and active locks for the snapshot. */
 export function collectJobArtifacts(queueManager) {
     const jobResults = {};
@@ -103,3 +134,10 @@ export function collectJobArtifacts(queueManager) {
     }));
     return { jobResults, jobLogEntries, activeLocks };
 }
+export function mapSnapshotJobArtifacts(source) {
+    return {
+        jobResults: Object.fromEntries(source.jobResults),
+        jobLogEntries: Object.fromEntries([...source.jobLogs].map(([id, logs]) => [id, [...logs]])),
+        activeLocks: [...source.activeLocks],
+    };
+}

package/dist/infrastructure/cloud/snapshot/config.d.ts

@@ -1,5 +1,8 @@
 import type { QueueManager } from '../../../application/queueManager';
 import type { CloudSnapshot } from '../types';
+import type { CloudSnapshotSource } from '../queueAdapter/types';
 export declare function collectQueueConfigs(queueManager: QueueManager, queueNames: Set<string>): CloudSnapshot['queueConfigs'];
+export declare function mapSnapshotQueueConfigs(queues: CloudSnapshotSource['queues']): CloudSnapshot['queueConfigs'];
 export declare function collectWebhooks(queueManager: QueueManager): CloudSnapshot['webhooks'];
 export declare function collectTopErrors(queueManager: QueueManager, dlqQueueNames: string[]): CloudSnapshot['topErrors'];
+export declare function mapSnapshotTopErrors(entries: CloudSnapshotSource['dlqEntries']): CloudSnapshot['topErrors'];

package/dist/infrastructure/cloud/snapshot/config.js

@@ -33,6 +33,30 @@ export function collectQueueConfigs(queueManager, queueNames) {
     }
     return configs;
 }
+export function mapSnapshotQueueConfigs(queues) {
+    return Object.fromEntries(queues.map((queue) => [
+        queue.name,
+        {
+            paused: queue.paused,
+            rateLimit: queue.rateLimit,
+            concurrencyLimit: queue.concurrencyLimit,
+            concurrencyActive: queue.counts.active,
+            stallConfig: {
+                enabled: queue.stallConfig.enabled,
+                stallInterval: queue.stallConfig.stallInterval,
+                maxStalls: queue.stallConfig.maxStalls,
+                gracePeriod: queue.stallConfig.gracePeriod,
+            },
+            dlqConfig: {
+                autoRetry: queue.dlqConfig.autoRetry,
+                autoRetryInterval: queue.dlqConfig.autoRetryInterval,
+                maxRetries: queue.dlqConfig.maxAutoRetries,
+                maxAge: queue.dlqConfig.maxAge ?? 0,
+                maxEntries: queue.dlqConfig.maxEntries,
+            },
+        },
+    ]));
+}
 export function collectWebhooks(queueManager) {
     try {
         return queueManager.webhookManager.list().map((webhook) => ({
@@ -84,3 +108,22 @@ export function collectTopErrors(queueManager, dlqQueueNames) {
         .map(([message, data]) => ({ message, ...data }))
         .sort((a, b) => b.count - a.count);
 }
+export function mapSnapshotTopErrors(entries) {
+    const errors = new Map();
+    for (const entry of entries) {
+        const message = entry.error ?? entry.reason;
+        const current = errors.get(message);
+        if (!current) {
+            errors.set(message, { count: 1, queue: entry.job.queue, lastSeen: entry.enteredAt });
+            continue;
+        }
+        current.count++;
+        if (entry.enteredAt > current.lastSeen) {
+            current.lastSeen = entry.enteredAt;
+            current.queue = entry.job.queue;
+        }
+    }
+    return [...errors]
+        .map(([message, data]) => ({ message, ...data }))
+        .sort((a, b) => b.count - a.count);
+}

package/dist/infrastructure/cloud/snapshot/jobs.d.ts

@@ -1,5 +1,8 @@
 import type { QueueManager } from '../../../application/queueManager';
 import type { CloudSnapshot } from '../types';
 import type { RedactOptions } from '../types/redact';
+import type { CloudSnapshotSource } from '../queueAdapter/types';
+export declare function mapSnapshotJobs(jobs: CloudSnapshotSource['jobs'], redact: RedactOptions): CloudSnapshot['recentJobs'];
+export declare function mapSnapshotDlqEntries(source: CloudSnapshotSource['dlqEntries'], redact: RedactOptions): CloudSnapshot['dlqEntries'];
 export declare function collectLiveJobs(queueManager: QueueManager, queueNames: string[], redact: RedactOptions): CloudSnapshot['recentJobs'];
 export declare function collectDlqEntries(queueManager: QueueManager, dlqQueueNames: string[], redact: RedactOptions): CloudSnapshot['dlqEntries'];

package/dist/infrastructure/cloud/snapshot/jobs.js

@@ -87,6 +87,37 @@ function mapJobExtended(job) {
 function mapJobToSnapshot(job, state, redact) {
     return { ...mapJobCore(job, state, redact), ...mapJobExtended(job) };
 }
+export function mapSnapshotJobs(jobs, redact) {
+    return jobs.map(({ job, state }) => mapJobToSnapshot(job, state, redact));
+}
+export function mapSnapshotDlqEntries(source, redact) {
+    return source
+        .map((entry) => ({
+        jobId: String(entry.job.id),
+        queue: entry.job.queue,
+        reason: entry.reason,
+        error: entry.error,
+        enteredAt: entry.enteredAt,
+        retryCount: entry.retryCount,
+        lastRetryAt: entry.lastRetryAt ?? undefined,
+        nextRetryAt: entry.nextRetryAt ?? undefined,
+        expiresAt: entry.expiresAt ?? undefined,
+        jobAttempts: entry.job.attempts,
+        jobMaxAttempts: entry.job.maxAttempts,
+        jobData: redact.includeJobData ? redactData(entry.job.data, redact.redactFields) : undefined,
+        jobCreatedAt: entry.job.createdAt,
+        jobPriority: entry.job.priority,
+        attemptHistory: entry.attempts.map((attempt) => ({
+            attempt: attempt.attempt,
+            startedAt: attempt.startedAt,
+            failedAt: attempt.failedAt,
+            reason: attempt.reason,
+            error: attempt.error,
+            duration: attempt.duration,
+        })),
+    }))
+        .sort((left, right) => right.enteredAt - left.enteredAt);
+}
 export function collectLiveJobs(queueManager, queueNames, redact) {
     if (queueNames.length === 0)
         return [];
@@ -94,7 +125,7 @@ export function collectLiveJobs(queueManager, queueNames, redact) {
     for (const name of queueNames) {
         for (const state of ALL_STATES) {
             try {
-                const queueJobs = queueManager.getJobs(name, { state: [state], start: 0, end: 999 });
+                const queueJobs = queueManager.getJobs(name, { state: [state], start: 0, end: 1000 });
                 for (const job of queueJobs)
                     jobs.push(mapJobToSnapshot(job, state, redact));
             }

package/dist/infrastructure/cloud/snapshotCollector.js

@@ -9,63 +9,48 @@ import { throughputTracker } from '../../application/throughputTracker';
 import { latencyTracker } from '../../application/latencyTracker';
 import { getTaskErrorStats } from '../../application/backgroundTasks';
 import { VERSION } from '../../shared/version';
+import { clientStorageStatus } from '../../shared/storageHealth';
 import { cloudLog } from './logger';
-import { SNAPSHOT_HOST, SNAPSHOT_RUNTIME, collectCrons, collectJobArtifacts, collectWorkerDetails, enrichFailedJobDurations, resolveRedaction, } from './snapshot/collector';
-import { collectLiveJobs, collectDlqEntries, collectTopErrors, collectQueueConfigs, collectWebhooks, collectQueueThroughput, collectWorkerUtilization, collectDurationHistogram, collectQueueWaitTime, collectQueueRetryRate, collectBacklogVelocity, collectStallDetails, collectPriorityDistribution, } from './snapshotHelpers';
+import { SNAPSHOT_HOST, SNAPSHOT_RUNTIME, enrichFailedJobDurations, mapSnapshotCrons, mapSnapshotJobArtifacts, mapSnapshotWorkers, resolveRedaction, } from './snapshot/collector';
+import { collectWebhooks, collectQueueThroughput, collectDurationHistogram, collectQueueWaitTime, collectQueueRetryRate, collectBacklogVelocity, collectStallDetails, collectPriorityDistribution, mapSnapshotDlqEntries, mapSnapshotJobs, mapSnapshotQueueConfigs, mapSnapshotTopErrors, mapSnapshotWorkerUtilization, } from './snapshotHelpers';
+import { resolveCloudQueueAdapter } from './queueAdapter/registry';
 /** Collect a snapshot. Light data always fresh, heavy data cached between refreshes. */
 export async function collectSnapshot(params) {
     const t0 = performance.now();
     const { queueManager, instanceId, instanceName, startedAt, sequenceId, serverHandles } = params;
     const { redactFields, includeJobData } = resolveRedaction(params);
+    const source = await resolveCloudQueueAdapter(queueManager).readSnapshotSource();
     // ─── MCP operations (drain buffer into snapshot) ───
     const mcpData = serverHandles?.getMcpOperations?.();
     // ─── Light data (O(SHARD_COUNT), every snapshot) ───
-    const stats = queueManager.getStats();
+    const stats = source.stats;
     const memStats = queueManager.getMemoryStats();
-    const workerStats = queueManager.workerManager.getStats();
+    const workerStats = source.workerStats;
     const rates = throughputTracker.getRates();
     const percentiles = latencyTracker.getPercentiles();
     const averages = latencyTracker.getAverages();
-    const storage = queueManager.getStorageStatus();
+    const storage = clientStorageStatus(queueManager.getStorageStatus());
     const mem = process.memoryUsage();
-    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,
-        };
-    });
-    const crons = collectCrons(queueManager);
+    const queues = source.queues.map(({ name, counts, paused }) => ({ name, ...counts, paused }));
+    const crons = mapSnapshotCrons(source.crons);
     // ─── Full data (every snapshot) ───
     const allQueueNames = queues.map((q) => q.name);
-    const dlqQueues = queues.filter((q) => q.failed > 0);
-    // Live jobs: waiting/active/delayed/failed — bounded by processing capacity
-    const recentJobs = collectLiveJobs(queueManager, allQueueNames, {
+    const recentJobs = mapSnapshotJobs(source.jobs, {
+        redactFields,
+        includeJobData,
+    });
+    const dlqEntries = mapSnapshotDlqEntries(source.dlqEntries, {
         redactFields,
         includeJobData,
     });
-    const dlqEntries = collectDlqEntries(queueManager, dlqQueues.map((q) => q.name), { redactFields, includeJobData });
     enrichFailedJobDurations(recentJobs, dlqEntries);
-    const topErrors = collectTopErrors(queueManager, dlqQueues.map((q) => q.name));
-    const workerDetails = collectWorkerDetails(queueManager, Date.now());
-    const queueConfigs = collectQueueConfigs(queueManager, new Set(queueNames));
+    const topErrors = mapSnapshotTopErrors(source.dlqEntries);
+    const workerDetails = mapSnapshotWorkers(source.workers, Date.now());
+    const queueConfigs = mapSnapshotQueueConfigs(source.queues);
     const webhooks = collectWebhooks(queueManager);
     const s3Backup = serverHandles?.getBackupStatus?.() ?? null;
     const telemetry = queueManager.getCloudTelemetry(allQueueNames);
-    const { jobResults, jobLogEntries, activeLocks } = collectJobArtifacts(queueManager);
+    const { jobResults, jobLogEntries, activeLocks } = mapSnapshotJobArtifacts(source);
     const result = {
         instanceId,
         instanceName,
@@ -126,7 +111,7 @@ export async function collectSnapshot(params) {
         // Analytics
         queueThroughput: collectQueueThroughput(queues),
         durationHistogram: collectDurationHistogram(recentJobs),
-        workerUtilization: collectWorkerUtilization(queueManager),
+        workerUtilization: mapSnapshotWorkerUtilization(source.workers),
         sqliteStats: serverHandles?.getSqliteStats?.() ?? null,
         runtime: SNAPSHOT_RUNTIME,
         queueWaitTime: collectQueueWaitTime(recentJobs),

package/dist/infrastructure/cloud/snapshotHelpers.d.ts

@@ -1,5 +1,5 @@
-export { collectBacklogVelocity, collectDurationHistogram, collectPriorityDistribution, collectQueueRetryRate, collectQueueThroughput, collectQueueWaitTime, collectWorkerUtilization, } from './snapshot/analytics';
-export { collectQueueConfigs, collectTopErrors, collectWebhooks } from './snapshot/config';
-export { collectDlqEntries, collectLiveJobs } from './snapshot/jobs';
+export { collectBacklogVelocity, collectDurationHistogram, collectPriorityDistribution, collectQueueRetryRate, collectQueueThroughput, collectQueueWaitTime, collectWorkerUtilization, mapSnapshotWorkerUtilization, } from './snapshot/analytics';
+export { collectQueueConfigs, collectTopErrors, collectWebhooks, mapSnapshotQueueConfigs, mapSnapshotTopErrors, } from './snapshot/config';
+export { collectDlqEntries, collectLiveJobs, mapSnapshotDlqEntries, mapSnapshotJobs, } from './snapshot/jobs';
 export { collectStallDetails } from './snapshot/stalls';
 export type { RedactOptions } from './types/redact';

package/dist/infrastructure/cloud/snapshotHelpers.js

@@ -1,4 +1,4 @@
-export { collectBacklogVelocity, collectDurationHistogram, collectPriorityDistribution, collectQueueRetryRate, collectQueueThroughput, collectQueueWaitTime, collectWorkerUtilization, } from './snapshot/analytics';
-export { collectQueueConfigs, collectTopErrors, collectWebhooks } from './snapshot/config';
-export { collectDlqEntries, collectLiveJobs } from './snapshot/jobs';
+export { collectBacklogVelocity, collectDurationHistogram, collectPriorityDistribution, collectQueueRetryRate, collectQueueThroughput, collectQueueWaitTime, collectWorkerUtilization, mapSnapshotWorkerUtilization, } from './snapshot/analytics';
+export { collectQueueConfigs, collectTopErrors, collectWebhooks, mapSnapshotQueueConfigs, mapSnapshotTopErrors, } from './snapshot/config';
+export { collectDlqEntries, collectLiveJobs, mapSnapshotDlqEntries, mapSnapshotJobs, } from './snapshot/jobs';
 export { collectStallDetails } from './snapshot/stalls';

package/dist/infrastructure/cloud/statsRefresh.js

@@ -7,6 +7,7 @@ import { hostname, arch, platform, cpus } from 'os';
 import { throughputTracker } from '../../application/throughputTracker';
 import { latencyTracker } from '../../application/latencyTracker';
 import { VERSION } from '../../shared/version';
+import { clientStorageStatus } from '../../shared/storageHealth';
 /** Cached hostname — computed once */
 const HOST = hostname();
 /** Cached runtime info — computed once */
@@ -22,7 +23,7 @@ export function buildStatsRefresh(qm) {
     const rates = throughputTracker.getRates();
     const percentiles = latencyTracker.getPercentiles();
     const averages = latencyTracker.getAverages();
-    const storage = qm.getStorageStatus();
+    const storage = clientStorageStatus(qm.getStorageStatus());
     const mem = process.memoryUsage();
     const workerStats = qm.workerManager.getStats();
     const queueNames = qm.listQueues();

package/dist/infrastructure/cloud/types/command.d.ts

@@ -1,4 +1,4 @@
-import type { QueueManager } from '../../../application/queueManager';
+import type { CloudQueueAdapter } from '../queueAdapter/types';
 import type { CloudSnapshot } from './snapshot';
 /** Incoming command from the dashboard. */
 export interface CloudCommand {
@@ -41,4 +41,4 @@ export interface CommandContext {
     getSnapshot?: () => Promise<CloudSnapshot>;
     triggerBackup?: () => Promise<unknown>;
 }
-export type CloudCommandHandler = (queueManager: QueueManager, command: CloudCommand, context?: CommandContext) => unknown;
+export type CloudCommandHandler = (adapter: CloudQueueAdapter, command: CloudCommand, context?: CommandContext) => unknown;

package/dist/infrastructure/persistence/postgres/admission.d.ts

@@ -0,0 +1,18 @@
+import type { TransactionSQL } from 'bun';
+import { type Job, type JobId } from '../../../domain/types/job';
+import { type PostgresContext } from './context';
+import type { PostgresAdmissionResult } from './admissionResult';
+export interface AdmitPostgresJobOptions {
+    readonly rejectExisting?: boolean;
+    readonly linkParent?: boolean;
+    readonly dependencyLocksHeld?: boolean;
+    readonly queueLifecycleLocksHeld?: boolean;
+    readonly dependencyExistenceCheckDeferred?: boolean;
+    readonly completionConsumerExemptions?: readonly JobId[];
+    /** Flow caller already holds identity locks and batches completion, queue, and event writes. */
+    readonly preparedFlow?: {
+        readonly now: number;
+    };
+}
+/** Insert one job inside the caller's transaction and return its authoritative generation. */
+export declare function admitPostgresJob(tx: TransactionSQL, ctx: PostgresContext, job: Job, options?: AdmitPostgresJobOptions): Promise<PostgresAdmissionResult>;