bunqueue 2.8.59 → 2.9.0

package/dist/client/workflow/waitFor.js

@@ -23,6 +23,7 @@ const TIMEOUT_ENQUEUE_RETRY_MS = 5_000;
  */
 export function scheduleTimeoutCheck(deps, execId, workflowName, nodeIdx, ms) {
     const arm = (requestedDelay) => {
+        deps.assertActive();
         const delay = Math.min(Math.max(requestedDelay, 0), MAX_TIMER_MS);
         // Replacing a live timer for the same execution — re-entering a waitFor node used
         // to leak the previous one, which then fired against a node the run had left.
@@ -30,6 +31,11 @@ export function scheduleTimeoutCheck(deps, execId, workflowName, nodeIdx, ms) {
         if (previous)
             clock().clearTimeout(previous);
         const timer = clock().setTimeout(() => {
+            if (!deps.isActive()) {
+                if (deps.timers.get(execId) === timer)
+                    deps.timers.delete(execId);
+                return;
+            }
             const jobData = { executionId: execId, workflowName, nodeIndex: nodeIdx };
             const published = () => {
                 // Keep the handle in the map while add() is pending. signal() and close() use
@@ -40,6 +46,10 @@ export function scheduleTimeoutCheck(deps, execId, workflowName, nodeIdx, ms) {
             const failed = () => {
                 if (deps.timers.get(execId) !== timer)
                     return;
+                if (!deps.isActive()) {
+                    deps.timers.delete(execId);
+                    return;
+                }
                 arm(TIMEOUT_ENQUEUE_RETRY_MS);
             };
             try {
@@ -75,6 +85,7 @@ export function clearTimers(timers) {
  * short-circuits without treating the pause as an error.
  */
 export async function runWaitFor(deps, exec, node, idx, wf) {
+    deps.assertActive();
     if (hasSignal(exec.signals, node.event)) {
         await deps.advance(exec, idx + 1, wf);
         return;
@@ -92,11 +103,14 @@ export async function runWaitFor(deps, exec, node, idx, wf) {
             // (refund, release stock) work the approver just authorised.
             const fresh = deps.store.get(exec.id);
             if (fresh && hasSignal(fresh.signals, node.event)) {
+                deps.assertActive();
                 exec.signals = fresh.signals;
                 await deps.advance(exec, idx + 1, wf);
                 return;
             }
+            deps.assertActive();
             deps.emitter?.emitSignal('signal:timeout', exec.id, exec.workflowName, node.event);
+            deps.assertActive();
             const timeoutReason = `Signal "${node.event}" timed out after ${node.timeout}ms`;
             exec.steps[waitKey] = {
                 status: 'failed',
@@ -106,30 +120,26 @@ export async function runWaitFor(deps, exec, node, idx, wf) {
             };
             exec.state = 'failed';
             exec.failureReason = timeoutReason;
-            // Unguarded on purpose, same reasoning as the failure write in `executor.ts`. Disk
-            // still says `waiting`, which `listRecoverable()` covers, so `recoverWaiting`
-            // recomputes the remaining time, re-enqueues, and the gate times out again rather
-            // than leaving a run that looks settled and was never unwound.
-            //
-            // A throw here skips the compensate CALL below but not the compensation: it
-            // propagates into `runNode`'s catch, which compensates anyway. That is the generic
-            // path the `WaitForSignalError` sentinel below exists to avoid on the normal route,
-            // so the outcome is a redundant route, not a missing rollback.
-            deps.store.update(exec);
+            // Persist failure before starting rollback. The lifecycle guard leaves the
+            // durable row waiting if force-close won, so replacement recovery re-evaluates
+            // the same elapsed deadline without starting an old executor's compensation.
+            deps.updateFn(exec);
             // Compensate here, then signal completion via the WaitForSignalError sentinel
             // so processStep short-circuits (return null) instead of re-running
             // compensation through its generic catch path.
             await deps.compensate(exec, wf);
+            deps.assertActive();
             deps.emitter?.emitWorkflow('workflow:failed', exec.id, exec.workflowName, 'failed');
             throw new WaitForSignalError(node.event);
         }
-        deps.store.update(exec);
+        deps.updateFn(exec);
         remaining = node.timeout - (clock().now() - waitingSince);
     }
     // Park transactionally. Between the in-memory check above and this point a signal
     // can land: it would be recorded with no parked run left to claim the resume,
     // hanging the execution forever. parkForSignal() re-reads the persisted signals
     // and only transitions 'running' -> 'waiting' when none has arrived.
+    deps.assertActive();
     const park = deps.store.parkForSignal(exec.id, node.event);
     if (park.signalPresent) {
         exec.signals = park.signals;
@@ -143,8 +153,10 @@ export async function runWaitFor(deps, exec, node, idx, wf) {
     }
     exec.state = 'waiting';
     if (node.timeout !== undefined) {
+        deps.assertActive();
         deps.scheduleTimeoutCheck(exec.id, exec.workflowName, idx, remaining);
     }
+    deps.assertActive();
     deps.emitter?.emitWorkflow('workflow:waiting', exec.id, exec.workflowName, 'waiting');
     throw new WaitForSignalError(node.event);
 }

package/dist/client/workflow/workflowDecisions.d.ts

@@ -4,7 +4,7 @@ import type { Execution } from './types';
  * Return an already persisted decision, or evaluate and persist it before the caller
  * performs any effects selected by that decision.
  */
-export declare function resolveDecision<T>(exec: Execution, key: string, evaluate: () => T | Promise<T>, updateFn: (exec: Execution) => void): Promise<T>;
+export declare function resolveDecision<T>(exec: Execution, key: string, evaluate: () => T | Promise<T>, updateFn: (exec: Execution) => void, assertActive: () => void): Promise<T>;
 export declare function branchDecisionKey(nodeIndex: number): string;
 export declare function forEachItemsDecisionKey(stepName: string): string;
 export declare function loopDecisionKey(kind: 'doUntil' | 'doWhile', firstStepName: string, iteration: number): string;

package/dist/client/workflow/workflowDecisions.js

@@ -4,11 +4,13 @@ const hasOwn = (value, key) => Object.hasOwn(value, key);
  * Return an already persisted decision, or evaluate and persist it before the caller
  * performs any effects selected by that decision.
  */
-export async function resolveDecision(exec, key, evaluate, updateFn) {
+export async function resolveDecision(exec, key, evaluate, updateFn, assertActive) {
+    assertActive();
     const decisions = (exec.decisions ??= {});
     if (hasOwn(decisions, key))
         return decisions[key];
     const value = await evaluate();
+    assertActive();
     decisions[key] = value;
     updateFn(exec);
     return value;

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)