bunqueue 2.8.60 → 2.9.2

package/dist/infrastructure/scheduler/cron/persisted.d.ts

@@ -0,0 +1,5 @@
+import { type CronJob } from '../../../domain/types/cron';
+/** Reject persisted Croner-only syntax before any scheduler state is mutated. */
+export declare function assertPersistedCronSupported(cron: CronJob): void;
+/** Validate a persisted collection atomically before loading any definition. */
+export declare function assertPersistedCronsSupported(crons: readonly CronJob[]): void;

package/dist/infrastructure/scheduler/cron/persisted.js

@@ -0,0 +1,27 @@
+import { assertValidCronTiming } from '../../../domain/types/cron';
+import { expandCronShortcut, validateCronExpression } from '../cronParser';
+const NATIVE_CRON_MIGRATION_VERSION = '2.9.0';
+/** Reject persisted Croner-only syntax before any scheduler state is mutated. */
+export function assertPersistedCronSupported(cron) {
+    try {
+        assertValidCronTiming(cron);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Persisted cron ${JSON.stringify(cron.name)} has invalid timing: ${message}. ` +
+            `Update or remove it before upgrading to bunqueue ${NATIVE_CRON_MIGRATION_VERSION}.`);
+    }
+    if (!cron.schedule)
+        return;
+    const error = validateCronExpression(expandCronShortcut(cron.schedule), cron.timezone ?? undefined);
+    if (!error)
+        return;
+    throw new Error(`Persisted cron ${JSON.stringify(cron.name)} uses unsupported schedule ${JSON.stringify(cron.schedule)}. ` +
+        `Update or remove it before upgrading to bunqueue ${NATIVE_CRON_MIGRATION_VERSION}. ` +
+        `Bun.cron validation failed: ${error}`);
+}
+/** Validate a persisted collection atomically before loading any definition. */
+export function assertPersistedCronsSupported(crons) {
+    for (const cron of crons)
+        assertPersistedCronSupported(cron);
+}

package/dist/infrastructure/scheduler/cron/runtime.js

@@ -1,6 +1,8 @@
 import { createCronJob } from '../../../domain/types/cron';
 import { MinHeap } from '../../../shared/minHeap';
-import { expandCronShortcut, getNextCronRun, getNextIntervalRun, validateCronExpression, } from '../cronParser';
+import { expandCronShortcut, getNextCronRun, getNextIntervalRun } from '../cronParser';
+import { assertPersistedCronsSupported } from './persisted';
+import { assertValidCronInput } from './validation';
 const SAFETY_FALLBACK_MS = 60_000;
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 /** Registry, timers, and schedule mutation shared with cron execution. */
@@ -52,15 +54,7 @@ export class CronRuntime {
         }
     }
     add(input) {
-        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}`);
-        }
+        assertValidCronInput(input);
         const now = Date.now();
         const nextRun = input.schedule
             ? getNextCronRun(expandCronShortcut(input.schedule), now, input.timezone)
@@ -97,6 +91,7 @@ export class CronRuntime {
         return Array.from(this.cronJobs.values()).map((entry) => entry.cron);
     }
     load(crons) {
+        assertPersistedCronsSupported(crons);
         const now = Date.now();
         const entries = [];
         for (const cron of crons) {

package/dist/infrastructure/scheduler/cron/validation.d.ts

@@ -0,0 +1,3 @@
+import { type CronJobInput } from '../../../domain/types/cron';
+/** Reject invalid timing, calendar syntax, and timezones before state mutation. */
+export declare function assertValidCronInput(input: CronJobInput): void;

package/dist/infrastructure/scheduler/cron/validation.js

@@ -0,0 +1,11 @@
+import { assertValidCronTiming } from '../../../domain/types/cron';
+import { expandCronShortcut, validateCronExpression } from '../cronParser';
+/** Reject invalid timing, calendar syntax, and timezones before state mutation. */
+export function assertValidCronInput(input) {
+    assertValidCronTiming(input);
+    if (!input.schedule)
+        return;
+    const error = validateCronExpression(expandCronShortcut(input.schedule), input.timezone);
+    if (error)
+        throw new Error(`Invalid cron expression: ${error}`);
+}

package/dist/infrastructure/scheduler/cronParser.d.ts

@@ -1,6 +1,6 @@
 /**
  * Cron Expression Parser
- * Parses 5-6 field cron expressions and calculates next run time
+ * Parses 5-6 field cron expressions and calculates next run time with Bun.cron
  */
 /**
  * Validate a cron expression

package/dist/infrastructure/scheduler/cronParser.js

@@ -1,8 +1,102 @@
 /**
  * Cron Expression Parser
- * Parses 5-6 field cron expressions and calculates next run time
+ * Parses 5-6 field cron expressions and calculates next run time with Bun.cron
  */
-import { Cron } from 'croner';
+const CRON_FIELD_COUNT = 5;
+const CRON_WITH_SECONDS_FIELD_COUNT = 6;
+const MINUTE_MS = 60_000;
+const SECOND_MS = 1_000;
+function invalidSeconds(field, reason) {
+    throw new TypeError(`Invalid cron seconds field "${field}": ${reason}`);
+}
+function parseNumber(value, field, label) {
+    if (!/^\d+$/.test(value))
+        invalidSeconds(field, `${label} must be an integer`);
+    return Number(value);
+}
+/** Parse the leading seconds field supported by bunqueue's six-field contract. */
+function parseSeconds(field) {
+    const selected = new Set();
+    for (const segment of field.split(',')) {
+        if (!segment)
+            invalidSeconds(field, 'list entries cannot be empty');
+        const stepParts = segment.split('/');
+        if (stepParts.length > 2 || !stepParts[0] || stepParts[1] === '') {
+            invalidSeconds(field, `invalid segment "${segment}"`);
+        }
+        const base = stepParts[0];
+        const hasStep = stepParts.length === 2;
+        const step = hasStep ? parseNumber(stepParts[1], field, 'step') : 1;
+        if (step < 1 || step > 60)
+            invalidSeconds(field, 'step must be between 1 and 60');
+        let start;
+        let end;
+        if (base === '*') {
+            start = 0;
+            end = 59;
+        }
+        else if (base.includes('-')) {
+            const range = base.split('-');
+            if (range.length !== 2 || !range[0] || !range[1]) {
+                invalidSeconds(field, `invalid range "${base}"`);
+            }
+            start = parseNumber(range[0], field, 'range start');
+            end = parseNumber(range[1], field, 'range end');
+        }
+        else {
+            if (hasStep) {
+                invalidSeconds(field, 'steps require a wildcard or range');
+            }
+            start = parseNumber(base, field, 'value');
+            end = start;
+        }
+        if (start < 0 || start > 59 || end < 0 || end > 59) {
+            invalidSeconds(field, 'values must be between 0 and 59');
+        }
+        if (start > end)
+            invalidSeconds(field, 'range start must not exceed range end');
+        for (let value = start; value <= end; value += step)
+            selected.add(value);
+    }
+    return [...selected].sort((a, b) => a - b);
+}
+function parseCronExpression(expression) {
+    const trimmed = expression.trim();
+    if (trimmed.startsWith('@') && !/\s/.test(trimmed)) {
+        return { calendar: trimmed, seconds: null };
+    }
+    const fields = trimmed ? trimmed.split(/\s+/) : [];
+    if (fields.length === CRON_FIELD_COUNT) {
+        return { calendar: fields.join(' '), seconds: null };
+    }
+    if (fields.length === CRON_WITH_SECONDS_FIELD_COUNT) {
+        return { calendar: fields.slice(1).join(' '), seconds: parseSeconds(fields[0]) };
+    }
+    throw new TypeError('Cron expression must have 5 fields, or 6 fields with leading seconds');
+}
+function parseNativeCron(calendar, fromTime, timezone) {
+    return Bun.cron.parse(calendar, fromTime, timezone ? { tz: timezone } : undefined);
+}
+function getNextParsedRun(parsed, fromTime, timezone) {
+    if (parsed.seconds === null) {
+        return parseNativeCron(parsed.calendar, fromTime, timezone)?.getTime() ?? 0;
+    }
+    const currentMinute = Math.floor(fromTime / MINUTE_MS) * MINUTE_MS;
+    let matchingMinute = parseNativeCron(parsed.calendar, currentMinute - 1, timezone);
+    while (matchingMinute) {
+        const minuteStart = matchingMinute.getTime();
+        for (const second of parsed.seconds) {
+            const candidate = minuteStart + second * SECOND_MS;
+            if (candidate > fromTime)
+                return candidate;
+        }
+        const nextMinute = parseNativeCron(parsed.calendar, minuteStart, timezone);
+        if (!nextMinute || nextMinute.getTime() <= minuteStart)
+            return 0;
+        matchingMinute = nextMinute;
+    }
+    return 0;
+}
 /**
  * Validate a cron expression
  * @param expression - Cron expression (5 or 6 fields)
@@ -11,7 +105,10 @@ import { Cron } from 'croner';
  */
 export function validateCronExpression(expression, timezone) {
     try {
-        new Cron(expression, { timezone });
+        const parsed = parseCronExpression(expression);
+        if (getNextParsedRun(parsed, Date.now(), timezone) === 0) {
+            return 'Cron expression has no future occurrences';
+        }
         return null;
     }
     catch (err) {
@@ -26,9 +123,7 @@ export function validateCronExpression(expression, timezone) {
  * @returns Next run timestamp in milliseconds
  */
 export function getNextCronRun(expression, fromTime = Date.now(), timezone) {
-    const cron = new Cron(expression, { timezone });
-    const nextDate = cron.nextRun(new Date(fromTime));
-    return nextDate ? nextDate.getTime() : 0;
+    return getNextParsedRun(parseCronExpression(expression), fromTime, timezone);
 }
 /**
  * Calculate next run time from repeatEvery interval
@@ -72,20 +167,58 @@ export function expandCronShortcut(expression) {
  */
 export function describeCron(expression) {
     const expanded = expandCronShortcut(expression);
-    const parts = expanded.split(/\s+/);
-    if (parts.length < 5) {
+    const rawParts = expanded.trim().split(/\s+/);
+    const hasSeconds = rawParts.length === CRON_WITH_SECONDS_FIELD_COUNT;
+    const secondsField = hasSeconds ? rawParts[0] : null;
+    let seconds = null;
+    if (secondsField) {
+        try {
+            seconds = parseSeconds(secondsField);
+        }
+        catch {
+            return 'Invalid cron expression';
+        }
+    }
+    const parts = hasSeconds ? rawParts.slice(1) : rawParts;
+    if (parts.length !== CRON_FIELD_COUNT) {
         return 'Invalid cron expression';
     }
     const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+    const everyCalendarMinute = parts.every((part) => part === '*');
+    if (secondsField === '*' && everyCalendarMinute)
+        return 'Every second';
+    if (secondsField &&
+        /^\d+$/.test(secondsField) &&
+        /^\d+$/.test(minute) &&
+        /^\d+$/.test(hour) &&
+        dayOfMonth === '*' &&
+        month === '*' &&
+        dayOfWeek === '*') {
+        return `Every day at ${hour.padStart(2, '0')}:${minute.padStart(2, '0')}:${secondsField.padStart(2, '0')}`;
+    }
+    const usesCalendarShortcuts = seconds === null || (seconds.length === 1 && seconds[0] === 0);
     // Common patterns
-    if (minute === '0' && hour === '0' && dayOfMonth === '*' && month === '*' && dayOfWeek === '*') {
+    if (usesCalendarShortcuts &&
+        minute === '0' &&
+        hour === '0' &&
+        dayOfMonth === '*' &&
+        month === '*' &&
+        dayOfWeek === '*') {
         return 'Every day at midnight';
     }
-    if (minute === '0' && hour === '*' && dayOfMonth === '*' && month === '*' && dayOfWeek === '*') {
+    if (usesCalendarShortcuts &&
+        minute === '0' &&
+        hour === '*' &&
+        dayOfMonth === '*' &&
+        month === '*' &&
+        dayOfWeek === '*') {
         return 'Every hour';
     }
-    if (minute === '*' && hour === '*' && dayOfMonth === '*' && month === '*' && dayOfWeek === '*') {
+    if (usesCalendarShortcuts && everyCalendarMinute) {
         return 'Every minute';
     }
+    if (secondsField) {
+        return `At second ${secondsField}, minute ${minute}, hour ${hour} on day ${dayOfMonth} of ${month}, day of week ${dayOfWeek}`;
+    }
     return `At ${minute} ${hour} on day ${dayOfMonth} of ${month}, day of week ${dayOfWeek}`;
 }

package/dist/infrastructure/server/bootstrap.d.ts

@@ -5,7 +5,6 @@
  * agent, stats interval, crash handlers and graceful shutdown are always on.
  */
 import { type BunqueueConfig, type ResolvedConfig } from '../../config';
-/** Return a startup error when an enabled file backup has no file to snapshot. */
-export declare function backupStartupError(config: Pick<ResolvedConfig, 's3BackupEnabled' | 'dataPath'>): string | null;
+export { backupStartupError } from './storageManager';
 /** Boot the full server from resolved configuration. Runs until shutdown. */
-export declare function bootServer(fileConfig: BunqueueConfig | null, config: ResolvedConfig): void;
+export declare function bootServer(fileConfig: BunqueueConfig | null, config: ResolvedConfig): Promise<void>;

package/dist/infrastructure/server/bootstrap.js

@@ -4,24 +4,17 @@
  * `bunqueue start` via the CLI) so they cannot drift: S3 backup, cloud
  * agent, stats interval, crash handlers and graceful shutdown are always on.
  */
-import { QueueManager } from '../../application/queueManager';
 import { createTcpServer } from './tcp';
 import { createHttpServer } from './http';
 import { Logger, serverLog, statsLog } from '../../shared/logger';
-import { stopRateLimiter } from './rateLimiter';
 import { VERSION } from '../../shared/version';
 import { S3BackupManager } from '../backup';
 import { CloudAgent } from '../cloud';
 import { SHARD_COUNT } from '../../shared/hash';
 import { resolveCloudConfig, resolveBackupConfig, resolveTlsServerOptions, } from '../../config';
-/** Return a startup error when an enabled file backup has no file to snapshot. */
-export function backupStartupError(config) {
-    if (config.s3BackupEnabled && !config.dataPath) {
-        return ('S3 backup requires persistent SQLite storage. Set BUNQUEUE_DATA_PATH ' +
-            'or storage.dataPath before enabling S3_BACKUP_ENABLED.');
-    }
-    return null;
-}
+import { backupStartupError, createServerQueueManager, shutdownServerQueueManager, storageDisplay, storageStartupError, } from './storageManager';
+import { createServerShutdown } from './shutdownCoordinator';
+export { backupStartupError } from './storageManager';
 /** Print startup banner */
 function printBanner(config, cloudUrl) {
     const dim = '\x1b[2m';
@@ -46,9 +39,7 @@ function printBanner(config, cloudUrl) {
     const socketDisplay = hasUnixSockets
         ? `${green}enabled${reset} ${dim}(${config.tcpSocketPath ? 'TCP' : ''}${config.tcpSocketPath && config.httpSocketPath ? '+' : ''}${config.httpSocketPath ? 'HTTP' : ''})${reset}`
         : `${dim}disabled${reset}`;
-    const storageDisplay = config.dataPath
-        ? `${bold}SQLite${reset} ${dim}·${reset} ${config.dataPath}`
-        : `in-memory ${dim}· ephemeral${reset}`;
+    const persistenceDisplay = storageDisplay(config);
     console.log(`
 ${magenta}        (\\(\\        ${reset}
 ${magenta}        ( -.-)      ${bold}bunqueue${reset} ${dim}v${VERSION}${reset}
@@ -59,7 +50,7 @@ ${dim}────────────────────────
 ${row(active, 'TCP', tcpDisplay)}
 ${row(active, 'HTTP', httpDisplay)}
 ${row(hasUnixSockets ? active : inactive, 'Unix socket', socketDisplay)}
-${row(info, 'Storage', storageDisplay)}
+${row(info, 'Storage', persistenceDisplay)}
 ${row(config.s3BackupEnabled ? active : inactive, 'S3 Backup', config.s3BackupEnabled ? `${green}enabled${reset}` : `${dim}disabled${reset}`)}
 ${row(config.tlsCertFile ? active : inactive, 'TLS', config.tlsCertFile ? `${green}enabled${reset}` : `${dim}disabled${reset}`)}
 ${row(config.authTokens.length > 0 ? active : inactive, 'Auth', config.authTokens.length > 0 ? `${green}enabled${reset}` : `${dim}disabled${reset}`)}
@@ -71,7 +62,7 @@ ${dim}────────────────────────
 `);
 }
 /** Boot the full server from resolved configuration. Runs until shutdown. */
-export function bootServer(fileConfig, config) {
+export async function bootServer(fileConfig, config) {
     // Apply logging config before anything else
     const logFormat = fileConfig?.logging?.format ?? Bun.env.LOG_FORMAT;
     const logLevel = fileConfig?.logging?.level ?? Bun.env.LOG_LEVEL?.toLowerCase();
@@ -82,9 +73,9 @@ export function bootServer(fileConfig, config) {
         if (validLevels.includes(logLevel))
             Logger.setLevel(logLevel);
     }
-    const backupError = backupStartupError(config);
-    if (backupError) {
-        serverLog.error(backupError);
+    const startupError = storageStartupError(config) ?? backupStartupError(config);
+    if (startupError) {
+        serverLog.error(startupError);
         process.exitCode = 1;
         return;
     }
@@ -99,12 +90,18 @@ export function bootServer(fileConfig, config) {
         serverLog.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
     }
+    let queueManager;
+    try {
+        queueManager = await createServerQueueManager(config);
+    }
+    catch (error) {
+        serverLog.error('Failed to initialize storage', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        process.exitCode = 1;
+        return;
+    }
     printBanner(config, cloudConfig?.url);
-    // Create queue manager
-    const queueManager = new QueueManager({
-        dataPath: config.dataPath,
-        maxPrometheusQueues: config.maxPrometheusQueues,
-    });
     // Start TCP + HTTP servers; a bind failure must not leave a half-started process
     let tcpServer;
     let httpServer;
@@ -129,12 +126,12 @@ export function bootServer(fileConfig, config) {
     catch (err) {
         const msg = err instanceof Error ? err.message : 'Unknown error';
         console.error(`Failed to start server: ${msg}`);
-        queueManager.shutdown();
+        await shutdownServerQueueManager(queueManager);
         process.exit(1);
     }
     // Initialize S3 backup manager
     let backupManager = null;
-    if (config.dataPath) {
+    if (config.storageDriver === 'sqlite' && config.dataPath) {
         const backupConfig = resolveBackupConfig(fileConfig, config.dataPath);
         backupManager = new S3BackupManager({
             ...backupConfig,
@@ -171,40 +168,17 @@ export function bootServer(fileConfig, config) {
         httpPort: config.httpPort,
         shards: SHARD_COUNT,
     });
-    // Graceful shutdown
-    let shuttingDown = false;
-    const shutdown = async (signal) => {
-        if (shuttingDown)
-            return;
-        shuttingDown = true;
-        serverLog.info(`Received ${signal}, shutting down...`);
-        // Stop stats interval immediately
-        clearInterval(statsInterval);
-        tcpServer.stop();
-        httpServer.stop();
-        const shutdownTimeout = config.shutdownTimeoutMs;
-        const start = Date.now();
-        while (Date.now() - start < shutdownTimeout) {
-            const stats = queueManager.getStats();
-            if (stats.active === 0)
-                break;
-            serverLog.info(`Waiting for ${stats.active} active jobs...`);
-            await Bun.sleep(1000);
-        }
-        // Stop backup manager
-        if (backupManager) {
-            backupManager.stop();
-        }
-        // Stop Cloud agent (sends final shutdown snapshot)
-        if (cloudAgent) {
-            await cloudAgent.stop();
-        }
-        queueManager.emitDashboardEvent('server:shutdown', { signal });
-        queueManager.shutdown();
-        stopRateLimiter();
-        serverLog.info('Shutdown complete');
-        process.exit(0);
-    };
+    const shutdown = createServerShutdown({
+        shutdownTimeoutMs: config.shutdownTimeoutMs,
+        stopStats: () => clearInterval(statsInterval),
+        stopTcp: () => tcpServer.stop(),
+        stopHttp: () => httpServer.stop(),
+        getActiveJobs: () => queueManager.getStats().active,
+        ...(backupManager && { stopBackup: () => backupManager.stop() }),
+        emitShutdown: (signal) => queueManager.emitDashboardEvent('server:shutdown', { signal }),
+        ...(cloudAgent && { stopCloud: () => cloudAgent.stop() }),
+        shutdownStorage: () => shutdownServerQueueManager(queueManager),
+    });
     process.on('SIGINT', () => void shutdown('SIGINT'));
     process.on('SIGTERM', () => void shutdown('SIGTERM'));
     process.on('uncaughtException', (err) => {

package/dist/infrastructure/server/errors.d.ts

@@ -0,0 +1,4 @@
+/** Preserve actionable domain errors while redacting storage and network diagnostics. */
+export declare function sanitizeServerError(error: unknown): string;
+/** Keep bounded local diagnostics for redacted infrastructure failures. */
+export declare function serverErrorDiagnostics(error: unknown): Record<string, unknown>;

package/dist/infrastructure/server/errors.js

@@ -0,0 +1,54 @@
+const SQLSTATE_CODE = /^(?:[0-9][0-9A-Z]|F0|HV|P0|XX)[0-9A-Z]{3}$/;
+const INFRASTRUCTURE_CODE = /^(?:SQLITE|POSTGRES|ECONN|EAI_|ENET|EHOST|ETIMEDOUT|EPIPE|ENOTFOUND|EADDR|UND_ERR)/i;
+const INFRASTRUCTURE_MESSAGE = /(?:SQLITE|Postgres(?:SQL)?|SQLSTATE|database|duplicate key|\bconstraint\b|\brelation\b|\bdriver\b|connection (?:refused|reset|terminated)|getaddrinfo|\b(?:ECONN|EAI_|ENET|EHOST|ETIMEDOUT|EPIPE|ENOTFOUND|EADDR|UND_ERR)[A-Z_]*)/i;
+const HOST_ENDPOINT_MESSAGE = /(?:\b(?:localhost|[a-z0-9-]+(?:\.[a-z0-9-]+)+|\d{1,3}(?:\.\d{1,3}){3}):\d{2,5}\b|\[[0-9a-f:]+\]:\d{2,5})/i;
+const MAX_DIAGNOSTIC_LENGTH = 2_000;
+function errorField(error, field) {
+    if (typeof error !== 'object' || error === null || !(field in error))
+        return '';
+    const value = error[field];
+    return typeof value === 'string' ? value : '';
+}
+function bounded(value) {
+    return value.length <= MAX_DIAGNOSTIC_LENGTH
+        ? value
+        : `${value.slice(0, MAX_DIAGNOSTIC_LENGTH)}...`;
+}
+function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    if (typeof error !== 'object' || error === null || !('message' in error))
+        return 'Unknown error';
+    const message = error['message'];
+    return typeof message === 'string' ? message : 'Unknown error';
+}
+/** Preserve actionable domain errors while redacting storage and network diagnostics. */
+export function sanitizeServerError(error) {
+    const message = errorMessage(error);
+    const code = errorField(error, 'code');
+    const name = errorField(error, 'name');
+    const infrastructureError = SQLSTATE_CODE.test(code) ||
+        INFRASTRUCTURE_CODE.test(code) ||
+        /^(?:(?:Database|Postgres|SQLite|SQL).*Error|ConnectionError)$/i.test(name) ||
+        INFRASTRUCTURE_MESSAGE.test(message) ||
+        HOST_ENDPOINT_MESSAGE.test(message);
+    return infrastructureError ? 'Internal server error' : message;
+}
+/** Keep bounded local diagnostics for redacted infrastructure failures. */
+export function serverErrorDiagnostics(error) {
+    const diagnostic = { error: bounded(errorMessage(error)) };
+    for (const [source, target] of [
+        ['name', 'name'],
+        ['code', 'code'],
+        ['errno', 'sqlState'],
+        ['where', 'where'],
+        ['routine', 'routine'],
+    ]) {
+        const value = errorField(error, source);
+        if (value)
+            diagnostic[target] = bounded(value);
+    }
+    return diagnostic;
+}

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

@@ -1,8 +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;
+export declare function routeQueueControlCommand(command: Command, context: HandlerContext, requestId?: string): Response | Promise<Response> | null;
+export declare function routeDlqCommand(command: Command, context: HandlerContext, requestId?: string): Response | Promise<Response> | null;
+export declare function routeRateLimitCommand(command: Command, context: HandlerContext, requestId?: string): Response | Promise<Response> | null;
+export declare function routeCronCommand(command: Command, context: HandlerContext, requestId?: string): Response | Promise<Response> | null;
+export declare function routeConfigCommand(command: Command, context: HandlerContext, requestId?: string): Response | Promise<Response> | null;

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

@@ -1,7 +1,8 @@
 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 { handleDlq, handleGetDlqStats, handlePurgeDlq, handleRemoveDlqJob, handleRetryCompleted, handleRetryDlq, } from '../handlers/dlq';
 import { handleDrain, handlePause, handleResume } from '../handlers/management';
+import { handleGroupCommand, handleGroupsJobsCount } from '../handlers/groups';
 export function routeQueueControlCommand(command, context, requestId) {
     switch (command.cmd) {
         case 'Pause':
@@ -32,6 +33,8 @@ export function routeDlqCommand(command, context, requestId) {
             return handleRetryDlq(command, context, requestId);
         case 'PurgeDlq':
             return handlePurgeDlq(command, context, requestId);
+        case 'RemoveDlqJob':
+            return handleRemoveDlqJob(command, context, requestId);
         case 'RetryCompleted':
             return handleRetryCompleted(command, context, requestId);
         default:
@@ -40,6 +43,18 @@ export function routeDlqCommand(command, context, requestId) {
 }
 export function routeRateLimitCommand(command, context, requestId) {
     switch (command.cmd) {
+        case 'GetGroupsJobsCount':
+            return handleGroupsJobsCount(command, context, requestId);
+        case 'GetGroupJobsCount':
+        case 'GetGroupActiveCount':
+        case 'SetGroupRateLimit':
+        case 'GetGroupRateLimit':
+        case 'RemoveGroupRateLimit':
+        case 'GetGroupRateLimitTtl':
+        case 'SetGroupConcurrency':
+        case 'GetGroupConcurrency':
+        case 'RemoveGroupConcurrency':
+            return handleGroupCommand(command, context, requestId);
         case 'RateLimit':
             return handleRateLimit(command, context, requestId);
         case 'RateLimitClear':

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

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

package/dist/infrastructure/server/handler.js

@@ -4,6 +4,7 @@
  */
 import * as resp from '../../domain/types/response';
 import { constantTimeEqual } from '../../shared/hash';
+import { sanitizeServerError } from './errors';
 import { routeCoreCommand, routeQueryCommand, routeManagementCommand, routeQueueControlCommand, routeDlqCommand, routeRateLimitCommand, routeConfigCommand, routeCronCommand, routeMonitoringCommand, routeDashboardCommand, } from './handlerRoutes';
 /**
  * Handle authentication command
@@ -43,33 +44,30 @@ export async function handleCommand(cmd, ctx) {
         result = await routeManagementCommand(cmd, ctx, reqId);
         if (result)
             return result;
-        result = routeQueueControlCommand(cmd, ctx, reqId);
+        result = await routeQueueControlCommand(cmd, ctx, reqId);
         if (result)
             return result;
-        result = routeDlqCommand(cmd, ctx, reqId);
+        result = await routeDlqCommand(cmd, ctx, reqId);
         if (result)
             return result;
-        result = routeRateLimitCommand(cmd, ctx, reqId);
+        result = await routeRateLimitCommand(cmd, ctx, reqId);
         if (result)
             return result;
-        result = routeConfigCommand(cmd, ctx, reqId);
+        result = await routeConfigCommand(cmd, ctx, reqId);
         if (result)
             return result;
-        result = routeCronCommand(cmd, ctx, reqId);
+        result = await routeCronCommand(cmd, ctx, reqId);
         if (result)
             return result;
-        result = routeMonitoringCommand(cmd, ctx, reqId);
+        result = await routeMonitoringCommand(cmd, ctx, reqId);
         if (result)
             return result;
-        result = routeDashboardCommand(cmd, ctx, reqId);
+        result = await routeDashboardCommand(cmd, ctx, reqId);
         if (result)
             return result;
         return resp.error(`Unknown command: ${cmd.cmd}`, reqId);
     }
     catch (err) {
-        // Sanitize error messages to avoid leaking internal details to clients
-        const raw = err instanceof Error ? err.message : 'Unknown error';
-        const message = raw.includes('SQLITE') || raw.includes('database') ? 'Internal server error' : raw;
-        return resp.error(message, reqId);
+        return resp.error(sanitizeServerError(err), reqId);
     }
 }