bunqueue 2.8.54 → 2.8.57

package/dist/infrastructure/scheduler/cronScheduler.js

@@ -1,437 +1,4 @@
-/**
- * Cron Scheduler
- * Manages scheduled jobs and executes them on time
- * Uses min-heap for O(k log n) tick instead of O(n) full scan
- * Event-driven: uses precise setTimeout to wake exactly when the next cron is due
- */
-import { createCronJob, isAtLimit } from '../../domain/types/cron';
-import { validateCronExpression, getNextCronRun, getNextIntervalRun, expandCronShortcut, } from './cronParser';
-import { cronLog } from '../../shared/logger';
-import { MinHeap } from '../../shared/minHeap';
-/** Safety fallback interval (60s) - catches edge cases like timer drift */
-const SAFETY_FALLBACK_MS = 60_000;
-/**
- * Cron Scheduler
- * Event-driven: wakes exactly when the next cron is due via setTimeout
- * Safety fallback: setInterval(60s) catches missed events
- * Optimized with min-heap for O(k log n) tick where k = due crons
- * Uses lazy deletion with generation numbers for O(1) remove
- */
-export class CronScheduler {
-    /** Map for O(1) lookup by name with generation tracking */
-    cronJobs = new Map();
-    /** Min-heap ordered by nextRun for O(k log n) tick */
-    cronHeap = new MinHeap((a, b) => a.cron.nextRun - b.cron.nextRun);
-    /** Current generation counter */
-    generation = 0;
-    /** Precise timer targeting the next cron's nextRun */
-    nextTimer = null;
-    /** Safety fallback interval (60s) */
-    safetyInterval = null;
-    /** Whether the scheduler is running */
-    started = false;
-    pushJob = null;
-    persistCron = null;
-    hasWorkers = null;
-    dashboardEmit = null;
-    /** Track last fire time per cron for overlap detection */
-    lastFiredAt = new Map();
-    // Accept config for backward compatibility (no longer used internally)
-    constructor(_config) {
-        // noop - scheduler now uses precise setTimeout instead of configurable interval
-        void _config;
-    }
-    /**
-     * Set the push job callback
-     */
-    setPushCallback(callback) {
-        this.pushJob = callback;
-    }
-    /**
-     * Set the persist cron callback for saving state after execution
-     */
-    setPersistCallback(callback) {
-        this.persistCron = callback;
-    }
-    /**
-     * Set the worker check callback for skipIfNoWorker
-     */
-    setWorkerCheckCallback(callback) {
-        this.hasWorkers = callback;
-    }
-    /**
-     * Set the dashboard event emitter callback
-     */
-    setDashboardEmit(callback) {
-        this.dashboardEmit = callback;
-    }
-    /**
-     * Start the scheduler
-     * Uses precise setTimeout for the fast path + 60s safety fallback
-     */
-    start() {
-        if (this.started)
-            return;
-        this.started = true;
-        // Safety fallback: tick every 60s as last-resort for missed events
-        this.safetyInterval = setInterval(() => {
-            void this.tick();
-        }, SAFETY_FALLBACK_MS);
-        // Schedule precise timer for the next due cron
-        this.scheduleNext();
-    }
-    /**
-     * Stop the scheduler
-     */
-    stop() {
-        this.started = false;
-        if (this.nextTimer !== null) {
-            clearTimeout(this.nextTimer);
-            this.nextTimer = null;
-        }
-        if (this.safetyInterval !== null) {
-            clearInterval(this.safetyInterval);
-            this.safetyInterval = null;
-        }
-    }
-    /**
-     * Add a cron job
-     */
-    add(input) {
-        // Validate
-        if (!input.schedule && !input.repeatEvery) {
-            throw new Error('Cron job must have either schedule or repeatEvery');
-        }
-        if (input.schedule) {
-            const expanded = expandCronShortcut(input.schedule);
-            const error = validateCronExpression(expanded, input.timezone);
-            if (error) {
-                throw new Error(`Invalid cron expression: ${error}`);
-            }
-        }
-        // Calculate next run
-        const now = Date.now();
-        let nextRun;
-        if (input.schedule) {
-            const expanded = expandCronShortcut(input.schedule);
-            nextRun = getNextCronRun(expanded, now, input.timezone);
-        }
-        else {
-            nextRun = getNextIntervalRun(input.repeatEvery, now);
-        }
-        // Create cron job with generation tracking
-        const cron = createCronJob(input, nextRun);
-        // Preserve existing executions count when upserting
-        const existing = this.cronJobs.get(cron.name);
-        if (existing) {
-            cron.executions = existing.cron.executions;
-            // Reset per-name overlap tracking on upsert: the redefined cron starts
-            // fresh and must not be blocked by the previous definition's last fire (H10)
-            this.lastFiredAt.delete(cron.name);
-        }
-        // Handle immediately option: set nextRun to now so it fires on next tick
-        // Only on first creation, not on upsert (otherwise it overrides skipMissedOnRestart)
-        if (input.immediately && !existing) {
-            cron.nextRun = Date.now();
-        }
-        const gen = this.generation++;
-        this.cronJobs.set(cron.name, { cron, generation: gen });
-        this.cronHeap.push({ cron, generation: gen });
-        // Reschedule if this cron might be sooner than current timer
-        if (this.started) {
-            this.scheduleNext();
-        }
-        return cron;
-    }
-    /**
-     * Remove a cron job - O(1) with lazy deletion
-     * The heap entry becomes stale and will be skipped in tick()
-     */
-    remove(name) {
-        const entry = this.cronJobs.get(name);
-        if (!entry)
-            return false;
-        // Just remove from map - heap entry becomes stale (lazy deletion)
-        this.cronJobs.delete(name);
-        // Clear per-name overlap tracking so a future cron re-added with the same
-        // name isn't blocked by this cron's stale last-fire timestamp (fixes H10)
-        this.lastFiredAt.delete(name);
-        // Reschedule in case removed cron was the next timer target
-        if (this.started) {
-            this.scheduleNext();
-        }
-        return true;
-    }
-    /**
-     * Get a cron job by name
-     */
-    get(name) {
-        return this.cronJobs.get(name)?.cron;
-    }
-    /**
-     * List all cron jobs
-     */
-    list() {
-        return Array.from(this.cronJobs.values()).map((e) => e.cron);
-    }
-    /**
-     * Load cron jobs from storage
-     */
-    load(crons) {
-        const now = Date.now();
-        const entries = [];
-        for (const cron of crons) {
-            // Recalculate past nextRun to the future on restart (fixes #73)
-            // Default: always skip missed crons unless explicitly opted out
-            if ((cron.skipMissedOnRestart || cron.skipIfNoWorker) && cron.nextRun < now) {
-                if (cron.schedule) {
-                    cron.nextRun = getNextCronRun(cron.schedule, now, cron.timezone ?? undefined);
-                }
-                else if (cron.repeatEvery) {
-                    cron.nextRun = getNextIntervalRun(cron.repeatEvery, now);
-                }
-                // Persist the recalculated nextRun to the DB
-                this.persistCron?.(cron.name, cron.executions, cron.nextRun);
-            }
-            const gen = this.generation++;
-            this.cronJobs.set(cron.name, { cron, generation: gen });
-            entries.push({ cron, generation: gen });
-        }
-        // Rebuild heap from loaded crons - O(n)
-        this.cronHeap.buildFrom(entries);
-        // Reschedule if running
-        if (this.started) {
-            this.scheduleNext();
-        }
-    }
-    /**
-     * Schedule a precise setTimeout for the next due cron
-     * Called after every mutation (add, remove, load, tick)
-     */
-    scheduleNext() {
-        if (!this.started)
-            return;
-        // Cancel existing precise timer
-        if (this.nextTimer !== null) {
-            clearTimeout(this.nextTimer);
-            this.nextTimer = null;
-        }
-        // Find next non-stale entry, popping stale ones from the heap
-        while (!this.cronHeap.isEmpty) {
-            const entry = this.cronHeap.peek();
-            if (!entry)
-                return;
-            // Check if stale (cron was removed or updated since this heap entry was created)
-            if (this.cronJobs.get(entry.cron.name)?.generation !== entry.generation) {
-                this.cronHeap.pop(); // Remove stale entry and continue looking
-                continue;
-            }
-            const delay = Math.max(0, entry.cron.nextRun - Date.now());
-            this.nextTimer = setTimeout(() => {
-                this.nextTimer = null;
-                void this.tick();
-            }, delay);
-            return;
-        }
-    }
-    /**
-     * Check and execute due cron jobs
-     * O(k log n) where k = number of due crons, instead of O(n) full scan
-     * Skips stale entries (lazy deletion) automatically
-     */
-    async tick() {
-        if (!this.pushJob)
-            return;
-        const now = Date.now();
-        const toReinsert = [];
-        const toRemove = [];
-        // Process only due crons from heap - O(k log n)
-        while (!this.cronHeap.isEmpty) {
-            const entry = this.cronHeap.peek();
-            if (!entry || entry.cron.nextRun > now)
-                break;
-            // Remove from heap
-            this.cronHeap.pop();
-            // Check if stale (cron was removed or updated)
-            const current = this.cronJobs.get(entry.cron.name);
-            if (current?.generation !== entry.generation) {
-                // Stale entry, skip
-                continue;
-            }
-            const cron = entry.cron;
-            // Check if at limit
-            if (isAtLimit(cron)) {
-                toRemove.push(cron.name);
-                continue;
-            }
-            try {
-                // Calculate new state BEFORE pushing job
-                const newExecutions = cron.executions + 1;
-                const executionTime = Date.now();
-                // The slot this fire was scheduled for (anchor for fixed-rate intervals)
-                const scheduledRun = cron.nextRun;
-                let newNextRun;
-                if (cron.schedule) {
-                    const expanded = expandCronShortcut(cron.schedule);
-                    newNextRun = getNextCronRun(expanded, executionTime, cron.timezone ?? undefined);
-                }
-                else if (cron.repeatEvery) {
-                    // Fixed-rate: anchor to the scheduled slot, not wall-clock now, so a
-                    // slow/late job does not cumulatively drift the schedule forward (M4)
-                    newNextRun = getNextIntervalRun(cron.repeatEvery, scheduledRun);
-                }
-                else {
-                    newNextRun = executionTime;
-                }
-                // Skip decision comes BEFORE the executions increment: a skipped fire
-                // pushes no job, so it must not consume the maxLimit budget (a cron
-                // with maxLimit=N must deliver N jobs, not N-minus-skips — worst case
-                // skipIfNoWorker used to burn the whole budget with zero deliveries).
-                // The schedule still advances so the heap doesn't hot-loop on it.
-                const skipReason = this.getSkipReason(cron, now);
-                if (skipReason) {
-                    if (this.persistCron) {
-                        try {
-                            this.persistCron(cron.name, cron.executions, newNextRun);
-                        }
-                        catch (persistErr) {
-                            // Benign here: nothing was pushed, in-memory advance is enough;
-                            // the next successful persist catches the row up.
-                            cronLog.error('Failed to persist cron nextRun on skip', {
-                                name: cron.name,
-                                error: String(persistErr),
-                            });
-                        }
-                    }
-                    cron.nextRun = newNextRun;
-                    this.dashboardEmit?.('cron:skipped', {
-                        name: cron.name,
-                        queue: cron.queue,
-                        reason: skipReason,
-                    });
-                    toReinsert.push(entry);
-                    continue;
-                }
-                // PERSIST STATE FIRST (before pushing job to prevent duplicates)
-                if (this.persistCron) {
-                    try {
-                        this.persistCron(cron.name, newExecutions, newNextRun);
-                    }
-                    catch (persistErr) {
-                        // Persist failed - do NOT push job, retry on next tick
-                        cronLog.error('Failed to persist cron state, skipping job push', {
-                            name: cron.name,
-                            error: String(persistErr),
-                        });
-                        this.dashboardEmit?.('cron:missed', {
-                            name: cron.name,
-                            queue: cron.queue,
-                            error: String(persistErr),
-                        });
-                        toReinsert.push(entry);
-                        continue;
-                    }
-                }
-                // Update in-memory state AFTER successful persist
-                cron.executions = newExecutions;
-                cron.nextRun = newNextRun;
-                // NOW push the job (state already persisted, safe from duplicates)
-                await this.fireCronJob(cron, now);
-                // Re-insert with same generation (not stale)
-                toReinsert.push(entry);
-            }
-            catch (err) {
-                // Push failed but state was already persisted
-                // Job is lost but cron state is consistent - no duplicates on retry
-                cronLog.error('Failed to push cron job (state already persisted)', {
-                    name: cron.name,
-                    error: String(err),
-                });
-                this.dashboardEmit?.('cron:missed', {
-                    name: cron.name,
-                    queue: cron.queue,
-                    error: String(err),
-                });
-                // Re-insert to continue scheduling (next execution will work)
-                toReinsert.push(entry);
-            }
-        }
-        // Re-insert processed crons with updated nextRun
-        for (const entry of toReinsert) {
-            this.cronHeap.push(entry);
-        }
-        // Remove limit-reached crons from map
-        for (const name of toRemove) {
-            this.cronJobs.delete(name);
-        }
-        // Schedule next precise wake-up
-        this.scheduleNext();
-    }
-    /** Fire a cron job with overlap and worker detection */
-    /**
-     * Reasons a due cron must not push right now. Evaluated BEFORE the
-     * executions increment in tick(), so skips never consume maxLimit budget.
-     */
-    getSkipReason(cron, now) {
-        // skipIfNoWorker: skip if no workers registered for this queue
-        if (cron.skipIfNoWorker && this.hasWorkers && !this.hasWorkers(cron.queue)) {
-            return 'no-worker';
-        }
-        // Overlap detection: skip if last fire was within repeatEvery window
-        const lastFire = this.lastFiredAt.get(cron.name);
-        const interval = cron.repeatEvery ?? 60000;
-        if (lastFire && now - lastFire < interval * 0.8) {
-            return 'overlap';
-        }
-        return null;
-    }
-    async fireCronJob(cron, now) {
-        // preventOverlap: auto-set uniqueKey to block pushes while previous job is active
-        const effectiveUniqueKey = cron.uniqueKey ?? (cron.preventOverlap ? `cron:${cron.name}` : undefined);
-        const opts = cron.jobOptions;
-        await this.pushJob(cron.queue, {
-            data: cron.data,
-            priority: cron.priority,
-            uniqueKey: effectiveUniqueKey,
-            dedup: cron.dedup ?? undefined,
-            maxAttempts: opts?.maxAttempts,
-            backoff: opts?.backoff,
-            timeout: opts?.timeout,
-            delay: opts?.delay,
-            stallTimeout: opts?.stallTimeout,
-            removeOnComplete: opts?.removeOnComplete,
-            removeOnFail: opts?.removeOnFail,
-        });
-        this.lastFiredAt.set(cron.name, now);
-        this.dashboardEmit?.('cron:fired', { name: cron.name, queue: cron.queue });
-    }
-    /**
-     * Get scheduler stats
-     * O(1) for nextRun using min-heap peek (skips stale entries)
-     */
-    getStats() {
-        // Find first non-stale entry for nextRun
-        let nextRun = null;
-        // Peek and skip stale entries to find valid nextRun
-        // This is typically O(1) as stale entries are cleaned during tick()
-        const entry = this.cronHeap.peek();
-        if (entry) {
-            const current = this.cronJobs.get(entry.cron.name);
-            if (current?.generation === entry.generation && !isAtLimit(entry.cron)) {
-                nextRun = entry.cron.nextRun;
-            }
-        }
-        // Count pending (crons not at limit) - still O(n) but called rarely
-        let pending = 0;
-        for (const { cron } of this.cronJobs.values()) {
-            if (!isAtLimit(cron)) {
-                pending++;
-            }
-        }
-        return {
-            total: this.cronJobs.size,
-            pending,
-            nextRun,
-        };
-    }
+import { CronExecution } from './cron/execution';
+/** Event-driven cron scheduler façade. */
+export class CronScheduler extends CronExecution {
 }

package/dist/infrastructure/scheduler/types/cronScheduler.d.ts

@@ -0,0 +1,16 @@
+import type { CronJob } from '../../../domain/types/cron';
+import type { JobInput } from '../../../domain/types/job';
+export interface CronSchedulerConfig {
+    /** @deprecated The scheduler now uses a precise event-driven timer. */
+    checkIntervalMs?: number;
+}
+export type PushJobCallback = (queue: string, input: JobInput) => Promise<void>;
+export type PersistCronCallback = (name: string, executions: number, nextRun: number) => void;
+export interface CronHeapEntry {
+    cron: CronJob;
+    generation: number;
+}
+export interface CronRegistryEntry {
+    cron: CronJob;
+    generation: number;
+}

package/dist/infrastructure/scheduler/types/cronScheduler.js

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

package/dist/infrastructure/server/bootstrap.js

@@ -161,6 +161,9 @@ export function bootServer(fileConfig, config) {
             getWsClientCount: () => httpServer.getWsClientCount(),
             getSseClientCount: () => httpServer.getSseClientCount(),
             getBackupStatus: () => backupManager?.getStatus() ?? null,
+            ...(config.s3BackupEnabled && backupManager
+                ? { triggerBackup: () => backupManager.backup() }
+                : {}),
         });
     }
     queueManager.emitDashboardEvent('server:started', {

package/dist/infrastructure/server/handler-routes/control.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from '../../../domain/types/command';
+import type { Response } from '../../../domain/types/response';
+import type { HandlerContext } from '../types';
+export declare function routeQueueControlCommand(command: Command, context: HandlerContext, requestId?: string): Response | null;
+export declare function routeDlqCommand(command: Command, context: HandlerContext, requestId?: string): Response | null;
+export declare function routeRateLimitCommand(command: Command, context: HandlerContext, requestId?: string): Response | null;
+export declare function routeCronCommand(command: Command, context: HandlerContext, requestId?: string): Response | null;
+export declare function routeConfigCommand(command: Command, context: HandlerContext, requestId?: string): Response | null;

package/dist/infrastructure/server/handler-routes/control.js

@@ -0,0 +1,82 @@
+import { handleClean, handleClearConcurrency, handleGetDlqConfig, handleGetStallConfig, handleIsPaused, handleListQueues, handleObliterate, handleRateLimit, handleRateLimitClear, handleSetConcurrency, handleSetDlqConfig, handleSetStallConfig, } from '../handlers/advanced';
+import { handleCron, handleCronDelete, handleCronGet, handleCronList } from '../handlers/cron';
+import { handleDlq, handleGetDlqStats, handlePurgeDlq, handleRetryCompleted, handleRetryDlq, } from '../handlers/dlq';
+import { handleDrain, handlePause, handleResume } from '../handlers/management';
+export function routeQueueControlCommand(command, context, requestId) {
+    switch (command.cmd) {
+        case 'Pause':
+            return handlePause(command, context, requestId);
+        case 'Resume':
+            return handleResume(command, context, requestId);
+        case 'IsPaused':
+            return handleIsPaused(command, context, requestId);
+        case 'Drain':
+            return handleDrain(command, context, requestId);
+        case 'Obliterate':
+            return handleObliterate(command, context, requestId);
+        case 'ListQueues':
+            return handleListQueues(command, context, requestId);
+        case 'Clean':
+            return handleClean(command, context, requestId);
+        default:
+            return null;
+    }
+}
+export function routeDlqCommand(command, context, requestId) {
+    switch (command.cmd) {
+        case 'Dlq':
+            return handleDlq(command, context, requestId);
+        case 'GetDlqStats':
+            return handleGetDlqStats(command, context, requestId);
+        case 'RetryDlq':
+            return handleRetryDlq(command, context, requestId);
+        case 'PurgeDlq':
+            return handlePurgeDlq(command, context, requestId);
+        case 'RetryCompleted':
+            return handleRetryCompleted(command, context, requestId);
+        default:
+            return null;
+    }
+}
+export function routeRateLimitCommand(command, context, requestId) {
+    switch (command.cmd) {
+        case 'RateLimit':
+            return handleRateLimit(command, context, requestId);
+        case 'RateLimitClear':
+            return handleRateLimitClear(command, context, requestId);
+        case 'SetConcurrency':
+            return handleSetConcurrency(command, context, requestId);
+        case 'ClearConcurrency':
+            return handleClearConcurrency(command, context, requestId);
+        default:
+            return null;
+    }
+}
+export function routeCronCommand(command, context, requestId) {
+    switch (command.cmd) {
+        case 'Cron':
+            return handleCron(command, context, requestId);
+        case 'CronGet':
+            return handleCronGet(command, context, requestId);
+        case 'CronDelete':
+            return handleCronDelete(command, context, requestId);
+        case 'CronList':
+            return handleCronList(command, context, requestId);
+        default:
+            return null;
+    }
+}
+export function routeConfigCommand(command, context, requestId) {
+    switch (command.cmd) {
+        case 'SetStallConfig':
+            return handleSetStallConfig(command, context, requestId);
+        case 'GetStallConfig':
+            return handleGetStallConfig(command, context, requestId);
+        case 'SetDlqConfig':
+            return handleSetDlqConfig(command, context, requestId);
+        case 'GetDlqConfig':
+            return handleGetDlqConfig(command, context, requestId);
+        default:
+            return null;
+    }
+}

package/dist/infrastructure/server/handler-routes/jobs.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from '../../../domain/types/command';
+import type { Response } from '../../../domain/types/response';
+import type { HandlerContext } from '../types';
+export declare function routeCoreCommand(command: Command, context: HandlerContext, requestId?: string): Promise<Response | null>;
+export declare function routeQueryCommand(command: Command, context: HandlerContext, requestId?: string): Promise<Response | null>;
+export declare function routeManagementCommand(command: Command, context: HandlerContext, requestId?: string): Promise<Response | null>;

package/dist/infrastructure/server/handler-routes/jobs.js

@@ -0,0 +1,110 @@
+import { handleChangeDelay, handleChangePriority, handleCount, handleDiscard, handleGetFailedChildrenValues, handleGetIgnoredChildrenFailures, handleMoveToDelayed, handleMoveToWait, handlePromote, handlePromoteJobs, handleRemoveChildDependency, handleRemoveUnprocessedChildren, handleUpdate, handleUpdateParent, handleWaitJob, } from '../handlers/advanced';
+import { handleAck, handleAckBatch, handleFail, handlePull, handlePullBatch, handlePush, handlePushBatch, } from '../handlers/core';
+import { handlePushFlow } from '../handlers/flow';
+import { handleGetDeduplicationJobId, handleGetQueueLimits, handleMoveToWaitingChildren, handleRemoveDeduplicationKey, handleRemoveJobDeduplicationKey, } from '../handlers/introspection';
+import { handleCancel, handleGetProgress, handleProgress } from '../handlers/management';
+import { handleExtendLock, handleExtendLocks } from '../handlers/monitoring';
+import { handleGetChildrenValues, handleGetCountsPerPriority, handleGetJob, handleGetJobByCustomId, handleGetJobCounts, handleGetJobs, handleGetResult, handleGetState, } from '../handlers/query';
+// biome-ignore lint/suspicious/useAwait: stable router API always returns a Promise.
+export async function routeCoreCommand(command, context, requestId) {
+    switch (command.cmd) {
+        case 'PUSH':
+            return handlePush(command, context, requestId);
+        case 'PUSHB':
+            return handlePushBatch(command, context, requestId);
+        case 'PUSHF':
+            return handlePushFlow(command, context, requestId);
+        case 'PULL':
+            return handlePull(command, context, requestId);
+        case 'PULLB':
+            return handlePullBatch(command, context, requestId);
+        case 'ACK':
+            return handleAck(command, context, requestId);
+        case 'ACKB':
+            return handleAckBatch(command, context, requestId);
+        case 'FAIL':
+            return handleFail(command, context, requestId);
+        default:
+            return null;
+    }
+}
+// biome-ignore lint/suspicious/useAwait: stable router API always returns a Promise.
+export async function routeQueryCommand(command, context, requestId) {
+    switch (command.cmd) {
+        case 'GetJob':
+            return handleGetJob(command, context, requestId);
+        case 'GetState':
+            return handleGetState(command, context, requestId);
+        case 'GetResult':
+            return handleGetResult(command, context, requestId);
+        case 'GetJobCounts':
+            return handleGetJobCounts(command, context, requestId);
+        case 'GetCountsPerPriority':
+            return handleGetCountsPerPriority(command, context, requestId);
+        case 'GetJobByCustomId':
+            return handleGetJobByCustomId(command, context, requestId);
+        case 'GetJobs':
+            return handleGetJobs(command, context, requestId);
+        case 'Count':
+            return handleCount(command, context, requestId);
+        case 'GetProgress':
+            return handleGetProgress(command, context, requestId);
+        case 'GetChildrenValues':
+            return handleGetChildrenValues(command, context, requestId);
+        case 'GetQueueLimits':
+            return handleGetQueueLimits(command, context, requestId);
+        case 'GetDeduplicationJobId':
+            return handleGetDeduplicationJobId(command, context, requestId);
+        default:
+            return null;
+    }
+}
+// biome-ignore lint/suspicious/useAwait: stable router API always returns a Promise.
+export async function routeManagementCommand(command, context, requestId) {
+    switch (command.cmd) {
+        case 'Cancel':
+            return handleCancel(command, context, requestId);
+        case 'Progress':
+            return handleProgress(command, context, requestId);
+        case 'Update':
+            return handleUpdate(command, context, requestId);
+        case 'UpdateParent':
+            return handleUpdateParent(command, context, requestId);
+        case 'ChangePriority':
+            return handleChangePriority(command, context, requestId);
+        case 'Promote':
+            return handlePromote(command, context, requestId);
+        case 'MoveToDelayed':
+            return handleMoveToDelayed(command, context, requestId);
+        case 'Discard':
+            return handleDiscard(command, context, requestId);
+        case 'WaitJob':
+            return handleWaitJob(command, context, requestId);
+        case 'ChangeDelay':
+            return handleChangeDelay(command, context, requestId);
+        case 'MoveToWait':
+            return handleMoveToWait(command, context, requestId);
+        case 'PromoteJobs':
+            return handlePromoteJobs(command, context, requestId);
+        case 'ExtendLock':
+            return handleExtendLock(command, context, requestId);
+        case 'ExtendLocks':
+            return handleExtendLocks(command, context, requestId);
+        case 'GetFailedChildrenValues':
+            return handleGetFailedChildrenValues(command, context, requestId);
+        case 'GetIgnoredChildrenFailures':
+            return handleGetIgnoredChildrenFailures(command, context, requestId);
+        case 'RemoveChildDependency':
+            return handleRemoveChildDependency(command, context, requestId);
+        case 'RemoveUnprocessedChildren':
+            return handleRemoveUnprocessedChildren(command, context, requestId);
+        case 'RemoveDeduplicationKey':
+            return handleRemoveDeduplicationKey(command, context, requestId);
+        case 'RemoveJobDeduplicationKey':
+            return handleRemoveJobDeduplicationKey(command, context, requestId);
+        case 'MoveToWaitingChildren':
+            return handleMoveToWaitingChildren(command, context, requestId);
+        default:
+            return null;
+    }
+}