bunqueue 2.8.60 → 2.9.0

package/dist/client/queue/dlqOps.d.ts

@@ -18,6 +18,8 @@ export declare function retryDlqByFilterEmbedded(queue: string, filter: DlqFilte
 export declare function retryDlqEmbedded(queue: string, id?: string): number;
 /** Purge DLQ (embedded) */
 export declare function purgeDlqEmbedded(queue: string): number;
+/** Remove one DLQ entry in embedded mode. */
+export declare function removeDlqJobEmbedded(queue: string, id: string): boolean;
 /** Set stall config (embedded only) */
 export declare function setStallConfigEmbedded(queue: string, config: Record<string, unknown>): void;
 /** Get stall config (embedded only) */

package/dist/client/queue/dlqOps.js

@@ -50,6 +50,10 @@ export function retryDlqEmbedded(queue, id) {
 export function purgeDlqEmbedded(queue) {
     return getSharedManager().purgeDlq(queue);
 }
+/** Remove one DLQ entry in embedded mode. */
+export function removeDlqJobEmbedded(queue, id) {
+    return getSharedManager().removeDlqJob(queue, jobId(id));
+}
 /** Set stall config (embedded only) */
 export function setStallConfigEmbedded(queue, config) {
     const manager = getSharedManager();

package/dist/client/queue/helpers.js

@@ -20,6 +20,8 @@ export function getDlqContext(manager) {
         shards: getShards(manager),
         jobIndex: manager.getJobIndex(),
         jobResults: manager.jobResults,
+        dependencyResults: manager.dependencyResults,
+        customIdMap: manager.customIdMap,
         jobLogs: manager.jobLogs,
         // #110-class: without storage, retryDlqByFilter's deleteDlqEntry/insertJob
         // silently no-op — filtered retries were never persisted in embedded mode

package/dist/client/queue/runtime/configuration.d.ts

@@ -21,6 +21,10 @@ export declare class QueueConfiguration<T> extends QueueControl<T> {
     retryDlqByFilterAsync(filter: DlqFilter): Promise<number>;
     purgeDlq(): number;
     purgeDlqAsync(): Promise<number>;
+    /** Remove one DLQ entry and resolve when the removal completes. */
+    removeDlqJob(id: string): Promise<boolean>;
+    /** Explicit async alias for removeDlqJob. */
+    removeDlqJobAsync(id: string): Promise<boolean>;
     retryCompleted(id?: string): number;
     retryCompletedAsync(id?: string): Promise<number>;
     setGlobalConcurrency(concurrency: number): void;

package/dist/client/queue/runtime/configuration.js

@@ -61,6 +61,14 @@ export class QueueConfiguration extends QueueControl {
     purgeDlqAsync() {
         return dlqOps.purgeDlqAsync(this.ctx);
     }
+    /** Remove one DLQ entry and resolve when the removal completes. */
+    removeDlqJob(id) {
+        return dlqOps.removeDlqJobAsync(this.ctx, id);
+    }
+    /** Explicit async alias for removeDlqJob. */
+    removeDlqJobAsync(id) {
+        return this.removeDlqJob(id);
+    }
     retryCompleted(id) {
         return dlqOps.retryCompleted(this.ctx, id);
     }

package/dist/client/worker/runtime/execution.js

@@ -39,15 +39,10 @@ export class WorkerExecution extends WorkerPolling {
             if (this.groupLimiter)
                 this.groupLimiter.decrement(job);
             if (this.running && !this._closing)
-                this.poll();
+                this.scheduleProcessing();
         });
-        if (this.activeJobs < this.opts.concurrency && !this._closing && !this.processingScheduled) {
-            this.processingScheduled = true;
-            setImmediate(() => {
-                this.processingScheduled = false;
-                void this.tryProcess();
-            });
-        }
+        if (this.activeJobs < this.opts.concurrency && !this._closing)
+            this.scheduleProcessing();
         return true;
     }
     registerWithServer() {

package/dist/client/worker/runtime/polling.d.ts

@@ -3,6 +3,7 @@ import { WorkerBuffer } from './buffer';
 import type { PulledJob, WorkerDelivery } from './state';
 export declare abstract class WorkerPolling<T = unknown, R = unknown> extends WorkerBuffer<T, R> {
     protected poll(): void;
+    protected scheduleProcessing(): void;
     protected tryProcess(): Promise<void>;
     protected doPullBatch(): Promise<PulledJob[]>;
     private scheduleRateLimitPoll;

package/dist/client/worker/runtime/polling.js

@@ -16,6 +16,15 @@ export class WorkerPolling extends WorkerBuffer {
         }
         void this.tryProcess();
     }
+    scheduleProcessing() {
+        if (!this.running || this._closing || this.processingScheduled)
+            return;
+        this.processingScheduled = true;
+        setImmediate(() => {
+            this.processingScheduled = false;
+            void this.tryProcess();
+        });
+    }
     async tryProcess() {
         if (!this.running || this._closing)
             return;

package/dist/config/resolve.d.ts

@@ -16,6 +16,20 @@ export interface ResolvedConfig {
     tlsKeyFile: string | undefined;
     authTokens: string[];
     dataPath: string | undefined;
+    storageDriver: 'memory' | 'sqlite' | 'postgres';
+    postgresUrl: string | undefined;
+    postgresNamespace: string;
+    postgresBrokerId: string | undefined;
+    postgresPoolSize: number;
+    postgresLeaseDurationMs: number;
+    postgresPollIntervalMs: number;
+    postgresStatementTimeoutMs: number;
+    postgresLockTimeoutMs: number;
+    postgresIdleTransactionTimeoutMs: number;
+    postgresMaxConcurrentOperations: number;
+    postgresMaxQueuedOperations: number;
+    postgresMaxSnapshotJobs: number;
+    postgresMaxSnapshotPayloadBytes: number;
     corsOrigins: string[];
     requireAuthForMetrics: boolean;
     maxPrometheusQueues: number;

package/dist/config/resolve.js

@@ -8,6 +8,19 @@ import { DEFAULTS as S3_DEFAULTS } from '../infrastructure/backup/s3BackupConfig
 /** Resolve server config: config file > env vars > defaults */
 export function resolveServerConfig(fileConfig) {
     const fc = fileConfig;
+    const dataPath = fc?.storage?.dataPath ??
+        Bun.env.BUNQUEUE_DATA_PATH ??
+        Bun.env.BQ_DATA_PATH ??
+        Bun.env.DATA_PATH ??
+        Bun.env.SQLITE_PATH;
+    const postgresUrl = fc?.storage?.url ?? Bun.env.BUNQUEUE_POSTGRES_URL;
+    const storageDriver = fc?.storage?.driver
+        ? resolveStorageDriver(fc.storage.driver, postgresUrl, dataPath)
+        : fc?.storage?.url
+            ? 'postgres'
+            : fc?.storage?.dataPath
+                ? 'sqlite'
+                : resolveStorageDriver(Bun.env.BUNQUEUE_STORAGE_DRIVER, postgresUrl, dataPath);
     return {
         tcpPort: fc?.server?.tcpPort ?? parseInt(Bun.env.TCP_PORT ?? '6789', 10),
         httpPort: fc?.server?.httpPort ?? parseInt(Bun.env.HTTP_PORT ?? '6790', 10),
@@ -17,11 +30,30 @@ export function resolveServerConfig(fileConfig) {
         tlsCertFile: fc?.server?.tlsCertFile ?? Bun.env.TLS_CERT_FILE,
         tlsKeyFile: fc?.server?.tlsKeyFile ?? Bun.env.TLS_KEY_FILE,
         authTokens: fc?.auth?.tokens ?? Bun.env.AUTH_TOKENS?.split(',').filter(Boolean) ?? [],
-        dataPath: fc?.storage?.dataPath ??
-            Bun.env.BUNQUEUE_DATA_PATH ??
-            Bun.env.BQ_DATA_PATH ??
-            Bun.env.DATA_PATH ??
-            Bun.env.SQLITE_PATH,
+        dataPath,
+        storageDriver,
+        postgresUrl,
+        postgresNamespace: fc?.storage?.namespace ?? Bun.env.BUNQUEUE_POSTGRES_NAMESPACE ?? 'default',
+        postgresBrokerId: fc?.storage?.brokerId ?? Bun.env.BUNQUEUE_BROKER_ID,
+        postgresPoolSize: positiveInteger(fc?.storage?.poolSize ?? parseInt(Bun.env.BUNQUEUE_POSTGRES_POOL_SIZE ?? '4', 10), 4),
+        postgresLeaseDurationMs: positiveInteger(fc?.storage?.leaseDurationMs ??
+            parseInt(Bun.env.BUNQUEUE_POSTGRES_LEASE_DURATION_MS ?? '30000', 10), 30_000),
+        postgresPollIntervalMs: positiveInteger(fc?.storage?.pollIntervalMs ??
+            parseInt(Bun.env.BUNQUEUE_POSTGRES_POLL_INTERVAL_MS ?? '250', 10), 250),
+        postgresStatementTimeoutMs: positiveInteger(fc?.storage?.statementTimeoutMs ??
+            parseInt(Bun.env.BUNQUEUE_POSTGRES_STATEMENT_TIMEOUT_MS ?? '30000', 10), 30_000),
+        postgresLockTimeoutMs: positiveInteger(fc?.storage?.lockTimeoutMs ??
+            parseInt(Bun.env.BUNQUEUE_POSTGRES_LOCK_TIMEOUT_MS ?? '5000', 10), 5_000),
+        postgresIdleTransactionTimeoutMs: positiveInteger(fc?.storage?.idleTransactionTimeoutMs ??
+            parseInt(Bun.env.BUNQUEUE_POSTGRES_IDLE_TRANSACTION_TIMEOUT_MS ?? '30000', 10), 30_000),
+        postgresMaxConcurrentOperations: positiveInteger(fc?.storage?.maxConcurrentOperations ??
+            parseInt(Bun.env.BUNQUEUE_POSTGRES_MAX_CONCURRENT_OPERATIONS ?? '16', 10), 16),
+        postgresMaxQueuedOperations: nonNegativeInteger(fc?.storage?.maxQueuedOperations ??
+            parseInt(Bun.env.BUNQUEUE_POSTGRES_MAX_QUEUED_OPERATIONS ?? '128', 10), 128),
+        postgresMaxSnapshotJobs: positiveInteger(fc?.storage?.maxSnapshotJobs ??
+            parseInt(Bun.env.BUNQUEUE_POSTGRES_MAX_SNAPSHOT_JOBS ?? '100000', 10), 100_000),
+        postgresMaxSnapshotPayloadBytes: positiveInteger(fc?.storage?.maxSnapshotPayloadBytes ??
+            parseInt(Bun.env.BUNQUEUE_POSTGRES_MAX_SNAPSHOT_PAYLOAD_BYTES ?? '268435456', 10), 256 * 1024 * 1024),
         corsOrigins: fc?.cors?.origins ?? Bun.env.CORS_ALLOW_ORIGIN?.split(',').filter(Boolean) ?? [],
         requireAuthForMetrics: fc?.auth?.requireAuthForMetrics ?? Bun.env.METRICS_AUTH === 'true',
         maxPrometheusQueues: nonNegativeInteger(fc?.telemetry?.maxPrometheusQueues ?? parseInt(Bun.env.METRICS_MAX_QUEUES ?? '100', 10), 100),
@@ -31,9 +63,22 @@ export function resolveServerConfig(fileConfig) {
         statsIntervalMs: fc?.timeouts?.stats ?? parseInt(Bun.env.STATS_INTERVAL_MS ?? '300000', 10),
     };
 }
+function resolveStorageDriver(configured, postgresUrl, dataPath) {
+    if (configured === 'memory' || configured === 'sqlite' || configured === 'postgres') {
+        return configured;
+    }
+    if (configured)
+        throw new Error(`Unsupported storage driver: ${configured}`);
+    if (postgresUrl)
+        return 'postgres';
+    return dataPath ? 'sqlite' : 'memory';
+}
 function nonNegativeInteger(value, fallback) {
     return Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
 }
+function positiveInteger(value, fallback) {
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
 /**
  * Resolve server TLS options from resolved config. Returns null when TLS is
  * not configured; throws when only one of cert/key is set (fail fast at

package/dist/config/types.d.ts

@@ -20,7 +20,25 @@ export interface BunqueueConfig {
         requireAuthForMetrics?: boolean;
     };
     storage?: {
+        /** Persistence backend. Inferred from url/dataPath when omitted. */
+        driver?: 'memory' | 'sqlite' | 'postgres';
         dataPath?: string;
+        /** PostgreSQL connection URL. Required when driver is postgres. */
+        url?: string;
+        /** Isolates independent bunqueue installations sharing one PostgreSQL database. */
+        namespace?: string;
+        /** Stable identifier for this broker process; generated automatically when omitted. */
+        brokerId?: string;
+        poolSize?: number;
+        leaseDurationMs?: number;
+        pollIntervalMs?: number;
+        statementTimeoutMs?: number;
+        lockTimeoutMs?: number;
+        idleTransactionTimeoutMs?: number;
+        maxConcurrentOperations?: number;
+        maxQueuedOperations?: number;
+        maxSnapshotJobs?: number;
+        maxSnapshotPayloadBytes?: number;
     };
     telemetry?: {
         /** Maximum queue label values exposed to Prometheus; zero disables per-queue series. */

package/dist/domain/queue/dlqShard.d.ts

@@ -44,6 +44,8 @@ export declare class DlqShard {
     getFiltered(queue: string, filter: DlqFilter): DlqEntry[];
     /** Remove entry from DLQ by job ID */
     remove(queue: string, jobId: JobId): DlqEntry | null;
+    /** Remove every entry with the same job ID from one queue. */
+    removeAll(queue: string, jobId: JobId): DlqEntry[];
     /** Get entries ready for auto-retry */
     getAutoRetryEntries(queue: string, now?: number): DlqEntry[];
     /** Get expired entries for cleanup */

package/dist/domain/queue/dlqShard.js

@@ -135,6 +135,22 @@ export class DlqShard {
         this.stats.decrementDlq();
         return entries.splice(idx, 1)[0];
     }
+    /** Remove every entry with the same job ID from one queue. */
+    removeAll(queue, jobId) {
+        const entries = this.dlq.get(queue);
+        if (!entries)
+            return [];
+        const removed = [];
+        const remaining = [];
+        for (const entry of entries) {
+            (entry.job.id === jobId ? removed : remaining).push(entry);
+        }
+        if (removed.length === 0)
+            return removed;
+        this.dlq.set(queue, remaining);
+        this.stats.decrementDlq(removed.length);
+        return removed;
+    }
     /** Get entries ready for auto-retry */
     getAutoRetryEntries(queue, now = Date.now()) {
         const entries = this.dlq.get(queue);

package/dist/domain/queue/shard/dlq.d.ts

@@ -18,6 +18,7 @@ export declare class ShardDlq extends ShardDependencies {
     getDlq(queue: string, count?: number): Job[];
     getDlqFiltered(queue: string, filter: DlqFilter): DlqEntry[];
     removeFromDlq(queue: string, jobId: JobId): DlqEntry | null;
+    removeAllFromDlq(queue: string, jobId: JobId): DlqEntry[];
     getAutoRetryEntries(queue: string, now?: number): DlqEntry[];
     getExpiredEntries(queue: string, now?: number): DlqEntry[];
     purgeExpired(queue: string, now?: number): number;

package/dist/domain/queue/shard/dlq.js

@@ -56,6 +56,9 @@ export class ShardDlq extends ShardDependencies {
     removeFromDlq(queue, jobId) {
         return this.dlqManager.remove(queue, jobId);
     }
+    removeAllFromDlq(queue, jobId) {
+        return this.dlqManager.removeAll(queue, jobId);
+    }
     getAutoRetryEntries(queue, now = Date.now()) {
         return this.dlqManager.getAutoRetryEntries(queue, now);
     }

package/dist/domain/types/commands/dlq.d.ts

@@ -21,6 +21,11 @@ export interface PurgeDlqCommand extends BaseCommand {
     readonly cmd: 'PurgeDlq';
     readonly queue: string;
 }
+export interface RemoveDlqJobCommand extends BaseCommand {
+    readonly cmd: 'RemoveDlqJob';
+    readonly queue: string;
+    readonly jobId: string;
+}
 export interface RetryCompletedCommand extends BaseCommand {
     readonly cmd: 'RetryCompleted';
     readonly queue: string;

package/dist/domain/types/commands/union.d.ts

@@ -9,5 +9,5 @@ import type * as Monitoring from './monitoring';
 import type * as Protocol from './protocol';
 import type * as Query from './query';
 import type * as Workers from './workers';
-export type Command = Core.PushCommand | Core.PushBatchCommand | Core.PushFlowCommand | Core.PullCommand | Core.PullBatchCommand | Core.AckCommand | Core.AckBatchCommand | Core.FailCommand | Query.GetJobCommand | Query.GetStateCommand | Query.GetResultCommand | Query.GetJobsCommand | Query.GetJobCountsCommand | Query.GetCountsPerPriorityCommand | Query.GetJobByCustomIdCommand | Query.CountCommand | Query.GetProgressCommand | Query.GetChildrenValuesCommand | Management.CancelCommand | Management.ProgressCommand | Management.UpdateCommand | Management.ChangePriorityCommand | Management.PromoteCommand | Management.WaitJobCommand | Management.MoveToDelayedCommand | Management.DiscardCommand | Management.PauseCommand | Management.ResumeCommand | Management.IsPausedCommand | Management.DrainCommand | Management.ObliterateCommand | Management.ListQueuesCommand | Management.CleanCommand | Dlq.DlqCommand | Dlq.GetDlqStatsCommand | Dlq.RetryDlqCommand | Dlq.PurgeDlqCommand | Dlq.RetryCompletedCommand | Dlq.SetDlqConfigCommand | Dlq.GetDlqConfigCommand | Limits.GetQueueLimitsCommand | Limits.GetDeduplicationJobIdCommand | Limits.RemoveDeduplicationKeyCommand | Limits.RemoveJobDeduplicationKeyCommand | Limits.MoveToWaitingChildrenCommand | Limits.RateLimitCommand | Limits.SetConcurrencyCommand | Limits.RateLimitClearCommand | Limits.ClearConcurrencyCommand | Limits.SetStallConfigCommand | Limits.GetStallConfigCommand | Cron.CronCommand | Cron.CronDeleteCommand | Cron.CronListCommand | Cron.CronGetCommand | Monitoring.AddLogCommand | Monitoring.GetLogsCommand | Monitoring.AddWebhookCommand | Monitoring.RemoveWebhookCommand | Monitoring.ListWebhooksCommand | Monitoring.StatsCommand | Monitoring.MetricsCommand | Monitoring.TrimEventsCommand | Monitoring.PrometheusCommand | Monitoring.StorageStatusCommand | Workers.HeartbeatCommand | Workers.JobHeartbeatCommand | Workers.JobHeartbeatBatchCommand | Workers.PingCommand | Workers.RegisterWorkerCommand | Workers.UnregisterWorkerCommand | Workers.ListWorkersCommand | Extended.ClearLogsCommand | Extended.ExtendLockCommand | Extended.ExtendLocksCommand | Extended.ChangeDelayCommand | Extended.SetWebhookEnabledCommand | Extended.CompactMemoryCommand | Extended.UpdateParentCommand | Extended.GetFailedChildrenValuesCommand | Extended.GetIgnoredChildrenFailuresCommand | Extended.RemoveChildDependencyCommand | Extended.RemoveUnprocessedChildrenCommand | Extended.MoveToWaitCommand | Extended.PromoteJobsCommand | Dashboard.DashboardOverviewCommand | Dashboard.DashboardQueuesCommand | Dashboard.DashboardQueueCommand | Protocol.AuthCommand | Protocol.HelloCommand | Protocol.SubscribeEventsCommand | Protocol.UnsubscribeEventsCommand;
+export type Command = Core.PushCommand | Core.PushBatchCommand | Core.PushFlowCommand | Core.PullCommand | Core.PullBatchCommand | Core.AckCommand | Core.AckBatchCommand | Core.FailCommand | Query.GetJobCommand | Query.GetStateCommand | Query.GetResultCommand | Query.GetJobsCommand | Query.GetJobCountsCommand | Query.GetCountsPerPriorityCommand | Query.GetJobByCustomIdCommand | Query.CountCommand | Query.GetProgressCommand | Query.GetChildrenValuesCommand | Management.CancelCommand | Management.ProgressCommand | Management.UpdateCommand | Management.ChangePriorityCommand | Management.PromoteCommand | Management.WaitJobCommand | Management.MoveToDelayedCommand | Management.DiscardCommand | Management.PauseCommand | Management.ResumeCommand | Management.IsPausedCommand | Management.DrainCommand | Management.ObliterateCommand | Management.ListQueuesCommand | Management.CleanCommand | Dlq.DlqCommand | Dlq.GetDlqStatsCommand | Dlq.RetryDlqCommand | Dlq.PurgeDlqCommand | Dlq.RemoveDlqJobCommand | Dlq.RetryCompletedCommand | Dlq.SetDlqConfigCommand | Dlq.GetDlqConfigCommand | Limits.GetQueueLimitsCommand | Limits.GetDeduplicationJobIdCommand | Limits.RemoveDeduplicationKeyCommand | Limits.RemoveJobDeduplicationKeyCommand | Limits.MoveToWaitingChildrenCommand | Limits.RateLimitCommand | Limits.SetConcurrencyCommand | Limits.RateLimitClearCommand | Limits.ClearConcurrencyCommand | Limits.SetStallConfigCommand | Limits.GetStallConfigCommand | Cron.CronCommand | Cron.CronDeleteCommand | Cron.CronListCommand | Cron.CronGetCommand | Monitoring.AddLogCommand | Monitoring.GetLogsCommand | Monitoring.AddWebhookCommand | Monitoring.RemoveWebhookCommand | Monitoring.ListWebhooksCommand | Monitoring.StatsCommand | Monitoring.MetricsCommand | Monitoring.TrimEventsCommand | Monitoring.PrometheusCommand | Monitoring.StorageStatusCommand | Workers.HeartbeatCommand | Workers.JobHeartbeatCommand | Workers.JobHeartbeatBatchCommand | Workers.PingCommand | Workers.RegisterWorkerCommand | Workers.UnregisterWorkerCommand | Workers.ListWorkersCommand | Extended.ClearLogsCommand | Extended.ExtendLockCommand | Extended.ExtendLocksCommand | Extended.ChangeDelayCommand | Extended.SetWebhookEnabledCommand | Extended.CompactMemoryCommand | Extended.UpdateParentCommand | Extended.GetFailedChildrenValuesCommand | Extended.GetIgnoredChildrenFailuresCommand | Extended.RemoveChildDependencyCommand | Extended.RemoveUnprocessedChildrenCommand | Extended.MoveToWaitCommand | Extended.PromoteJobsCommand | Dashboard.DashboardOverviewCommand | Dashboard.DashboardQueuesCommand | Dashboard.DashboardQueueCommand | Protocol.AuthCommand | Protocol.HelloCommand | Protocol.SubscribeEventsCommand | Protocol.UnsubscribeEventsCommand;
 export type CommandType = Command['cmd'];

package/dist/domain/types/cron.d.ts

@@ -78,6 +78,11 @@ export interface CronJobInput {
     /** Job options applied to each spawned job (retry/cleanup policy, etc.) */
     jobOptions?: CronJobOptions;
 }
+/** Validate the calendar/interval timing fields before scheduler mutation. */
+export declare function assertValidCronTiming(input: {
+    readonly schedule?: string | null;
+    readonly repeatEvery?: number | null;
+}): void;
 /** Create a new cron job */
 export declare function createCronJob(input: CronJobInput, nextRun: number): CronJob;
 /** Check if cron job has reached its execution limit */

package/dist/domain/types/cron.js

@@ -2,11 +2,22 @@
  * Cron job domain types
  */
 import { normalizeJobPayload } from '../job/payload';
-/** Create a new cron job */
-export function createCronJob(input, nextRun) {
-    if (!input.schedule && !input.repeatEvery) {
+/** Validate the calendar/interval timing fields before scheduler mutation. */
+export function assertValidCronTiming(input) {
+    if (input.repeatEvery !== undefined && input.repeatEvery !== null) {
+        if (typeof input.repeatEvery !== 'number' ||
+            !Number.isSafeInteger(input.repeatEvery) ||
+            input.repeatEvery < 1) {
+            throw new Error('Cron repeatEvery must be a positive safe integer number of milliseconds');
+        }
+    }
+    if (!input.schedule && (input.repeatEvery === undefined || input.repeatEvery === null)) {
         throw new Error('Cron job must have either schedule or repeatEvery');
     }
+}
+/** Create a new cron job */
+export function createCronJob(input, nextRun) {
+    assertValidCronTiming(input);
     const payload = normalizeJobPayload({ name: input.jobName, data: input.data });
     return {
         name: input.name,

package/dist/domain/types/dlq.d.ts

@@ -89,7 +89,7 @@ export interface DlqConfig {
 /** Default DLQ configuration */
 export declare const DEFAULT_DLQ_CONFIG: DlqConfig;
 /** Create a DLQ entry from a failed job */
-export declare function createDlqEntry(job: Job, reason: FailureReason, error: string | null, config?: DlqConfig): DlqEntry;
+export declare function createDlqEntry(job: Job, reason: FailureReason, error: string | null, config?: DlqConfig, now?: number): DlqEntry;
 /** Add attempt record to existing DLQ entry */
 export declare function addAttemptRecord(entry: DlqEntry, reason: FailureReason, error: string | null): void;
 /** Check if DLQ entry is expired */

package/dist/domain/types/dlq.js

@@ -63,8 +63,7 @@ export const DEFAULT_DLQ_CONFIG = {
     maxEntries: 10000,
 };
 /** Create a DLQ entry from a failed job */
-export function createDlqEntry(job, reason, error, config = DEFAULT_DLQ_CONFIG) {
-    const now = Date.now();
+export function createDlqEntry(job, reason, error, config = DEFAULT_DLQ_CONFIG, now = Date.now()) {
     const retained = getDlqRetryState(job);
     const alreadyEntered = retained?.enteredAt !== null && retained?.enteredAt !== undefined;
     const attemptRecord = createAttemptRecord(job, reason, error, now);

package/dist/domain/types/jobs/model.d.ts

@@ -83,7 +83,7 @@ export interface Job {
     readonly deduplicationReplace: boolean;
     readonly debounceId: string | null;
     readonly debounceTtl: number | null;
-    /** Whether each generation bypasses the persistence write buffer. */
+    /** Whether SQLite admission bypasses its write buffer; PostgreSQL is always transactional. */
     readonly durable?: boolean;
     timeline: JobTimelineEntry[];
 }

package/dist/infrastructure/cloud/commandHandler.js

@@ -7,6 +7,8 @@
  */
 import { cloudLog } from './logger';
 import { COMMANDS } from './commands';
+import { resolveCloudQueueAdapter } from './queueAdapter/registry';
+import { sanitizeServerError } from '../server/errors';
 /**
  * Normalize object keys: PascalCase/UpperCase → camelCase.
  * Skips user data fields (data, result, backoffConfig, repeat) — those are passed as-is.
@@ -51,7 +53,7 @@ export async function handleCommand(queueManager, cmd, context) {
                 type: 'command_result',
                 id: cmd.id,
                 success: false,
-                error: err instanceof Error ? err.message : String(err),
+                error: sanitizeServerError(err),
             };
         }
     }
@@ -66,7 +68,7 @@ export async function handleCommand(queueManager, cmd, context) {
         };
     }
     try {
-        const raw = await handler(queueManager, cmd, context);
+        const raw = await handler(resolveCloudQueueAdapter(queueManager), cmd, context);
         const data = camelKeys(raw);
         cloudLog.info('Remote command executed', { action: cmd.action, id: cmd.id });
         return { type: 'command_result', id: cmd.id, success: true, data };
@@ -81,7 +83,7 @@ export async function handleCommand(queueManager, cmd, context) {
             type: 'command_result',
             id: cmd.id,
             success: false,
-            error: err instanceof Error ? err.message : String(err),
+            error: sanitizeServerError(err),
         };
     }
 }

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

@@ -1,7 +1,7 @@
 export const INTEGRATION_COMMANDS = {
-    'cron:upsert': (queueManager, command) => {
-        queueManager.removeCron(command.name ?? '');
-        const cron = queueManager.addCron({
+    'cron:upsert': async (adapter, command) => {
+        await adapter.removeCron(command.name ?? '');
+        const cron = await adapter.addCron({
             name: command.name ?? '',
             jobName: 'default',
             queue: command.queue ?? '',
@@ -10,18 +10,18 @@ export const INTEGRATION_COMMANDS = {
         });
         return { name: cron.name, nextRun: cron.nextRun };
     },
-    'cron:delete': (queueManager, command) => ({
-        deleted: queueManager.removeCron(command.name ?? ''),
+    'cron:delete': async (adapter, command) => ({
+        deleted: await adapter.removeCron(command.name ?? ''),
     }),
-    'webhook:add': (queueManager, command) => {
-        const webhook = queueManager.webhookManager.add(command.url ?? '', command.events ?? [], command.queue ?? undefined, command.secret ?? undefined);
+    'webhook:add': (adapter, command) => {
+        const webhook = adapter.manager.webhookManager.add(command.url ?? '', command.events ?? [], command.queue ?? undefined, command.secret ?? undefined);
         return { id: webhook.id, url: webhook.url, events: webhook.events };
     },
-    'webhook:remove': (queueManager, command) => ({
-        removed: queueManager.webhookManager.remove(command.webhookId ?? ''),
+    'webhook:remove': (adapter, command) => ({
+        removed: adapter.manager.webhookManager.remove(command.webhookId ?? ''),
     }),
-    'webhook:set-enabled': (queueManager, command) => ({
-        updated: queueManager.webhookManager.setEnabled(command.webhookId ?? '', command.enabled ?? true),
+    'webhook:set-enabled': (adapter, command) => ({
+        updated: adapter.manager.webhookManager.setEnabled(command.webhookId ?? '', command.enabled ?? true),
     }),
     's3:backup': async (_queueManager, _command, context) => {
         if (!context?.triggerBackup)

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

@@ -1,16 +1,21 @@
 import { jobId } from '../../../domain/types/job';
 import { mapCloudCommandJob } from './jobMapper';
+function pageInteger(value, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.floor(value)));
+}
 export const JOB_COMMANDS = {
-    'job:cancel': async (queueManager, command) => {
-        const ok = await queueManager.cancel(jobId(command.jobId ?? ''));
+    'job:cancel': async (adapter, command) => {
+        const ok = await adapter.cancel(jobId(command.jobId ?? ''));
         return { cancelled: ok };
     },
-    'job:promote': async (queueManager, command) => {
-        const ok = await queueManager.promote(jobId(command.jobId ?? ''));
+    'job:promote': async (adapter, command) => {
+        const ok = await adapter.promote(jobId(command.jobId ?? ''));
         return { promoted: ok };
     },
-    'job:push': async (queueManager, command) => {
-        const job = await queueManager.push(command.queue ?? '', {
+    'job:push': async (adapter, command) => {
+        const job = await adapter.push(command.queue ?? '', {
             name: command.name ?? 'default',
             data: command.data ?? {},
             priority: command.priority,
@@ -18,80 +23,83 @@ export const JOB_COMMANDS = {
         });
         return { jobId: String(job.id), queue: command.queue };
     },
-    'job:priority': async (queueManager, command) => {
-        const ok = await queueManager.changePriority(jobId(command.jobId ?? ''), command.priority ?? 0);
+    'job:priority': async (adapter, command) => {
+        const ok = await adapter.changePriority(jobId(command.jobId ?? ''), command.priority ?? 0);
         return { changed: ok };
     },
-    'job:discard': async (queueManager, command) => {
-        const ok = await queueManager.discard(jobId(command.jobId ?? ''));
+    'job:discard': async (adapter, command) => {
+        const ok = await adapter.discard(jobId(command.jobId ?? ''));
         return { discarded: ok };
     },
-    'job:delay': async (queueManager, command) => {
-        await queueManager.changeDelay(jobId(command.jobId ?? ''), command.delay ?? 0);
+    'job:delay': async (adapter, command) => {
+        await adapter.changeDelay(jobId(command.jobId ?? ''), command.delay ?? 0);
         return { delayed: true };
     },
-    'job:updateData': async (queueManager, command) => {
-        const ok = await queueManager.updateJobData(jobId(command.jobId ?? ''), command.data);
+    'job:updateData': async (adapter, command) => {
+        const ok = await adapter.updateData(jobId(command.jobId ?? ''), command.data);
         return { updated: ok };
     },
-    'job:clearLogs': (queueManager, command) => {
-        queueManager.clearLogs(jobId(command.jobId ?? ''), command.keepLogs);
+    'job:clearLogs': async (adapter, command) => {
+        await adapter.clearLogs(jobId(command.jobId ?? ''), command.keepLogs);
         return { cleared: true };
     },
-    'job:retry': (queueManager, command) => {
+    'job:retry': async (adapter, command) => {
         if (command.queue) {
-            const count = queueManager.retryDlq(command.queue, command.jobId ? jobId(command.jobId) : undefined);
+            const count = await adapter.retryDlq(command.queue, command.jobId ? jobId(command.jobId) : undefined);
             return { retried: count };
         }
         return { retried: 0 };
     },
-    'job:logs': (queueManager, command) => ({
-        logs: queueManager.getLogs(jobId(command.jobId ?? '')),
+    'job:logs': async (adapter, command) => ({
+        logs: await adapter.getLogs(jobId(command.jobId ?? '')),
     }),
-    'job:result': (queueManager, command) => ({
-        result: queueManager.getResult(jobId(command.jobId ?? '')) ?? null,
+    'job:result': async (adapter, command) => ({
+        result: await adapter.getResult(jobId(command.jobId ?? '')),
     }),
-    'job:list': (queueManager, command) => {
-        const limit = command.limit ?? 50;
-        const offset = command.offset ?? 0;
+    'job:list': async (adapter, command) => {
+        const limit = pageInteger(command.limit, 50);
+        const offset = pageInteger(command.offset, 0);
+        const end = Math.min(Number.MAX_SAFE_INTEGER, offset + limit);
         const states = command.state
             ? command.state.split(',')
             : ['waiting', 'active', 'delayed', 'completed', 'failed'];
-        const jobs = queueManager.getJobs(command.queue ?? '', {
+        const jobs = await adapter.listJobs(command.queue ?? '', {
             state: states,
             start: offset,
-            end: offset + limit - 1,
+            end,
         });
+        const source = await adapter.readSnapshotSource();
+        const counts = source.queues.find(({ name }) => name === (command.queue ?? ''))?.counts;
         return {
             jobs: jobs.map(mapCloudCommandJob),
-            total: queueManager.count(command.queue ?? ''),
+            total: (counts?.waiting ?? 0) + (counts?.prioritized ?? 0) + (counts?.delayed ?? 0),
             offset,
             limit,
         };
     },
-    'job:get': async (queueManager, command) => {
+    'job:get': async (adapter, command) => {
         const id = jobId(command.jobId ?? '');
-        const job = await queueManager.getJob(id);
+        const job = await adapter.getJob(id);
         if (!job)
             return { job: null };
         return {
             job: {
                 ...mapCloudCommandJob(job),
-                logs: queueManager.getLogs(id),
-                result: queueManager.getResult(id) ?? null,
+                logs: await adapter.getLogs(id),
+                result: await adapter.getResult(id),
             },
         };
     },
-    'job:listAll': (queueManager, command) => {
+    'job:listAll': async (adapter, command) => {
         const limit = command.limit ?? 50;
         const offset = command.offset ?? 0;
         const states = command.state
             ? command.state.split(',')
             : ['waiting', 'active', 'delayed', 'completed', 'failed'];
         const allJobs = [];
-        for (const name of queueManager.listQueues()) {
-            const jobs = queueManager.getJobs(name, { state: states, start: 0, end: 999 });
-            for (const job of jobs)
+        const source = await adapter.readSnapshotSource();
+        for (const { job, state } of source.jobs) {
+            if (states.includes(state))
                 allJobs.push(mapCloudCommandJob(job));
         }
         allJobs.sort((a, b) => b.timestamp - a.timestamp);
@@ -102,10 +110,10 @@ export const JOB_COMMANDS = {
             limit,
         };
     },
-    'dlq:retry': (queueManager, command) => ({
-        retried: queueManager.retryDlq(command.queue ?? '', command.jobId ? jobId(command.jobId) : undefined),
+    'dlq:retry': async (adapter, command) => ({
+        retried: await adapter.retryDlq(command.queue ?? '', command.jobId ? jobId(command.jobId) : undefined),
     }),
-    'dlq:purge': (queueManager, command) => ({
-        purged: queueManager.purgeDlq(command.queue ?? ''),
+    'dlq:purge': async (adapter, command) => ({
+        purged: await adapter.purgeDlq(command.queue ?? ''),
     }),
 };