bunqueue 2.8.60 → 2.9.0

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,6 +1,6 @@
 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';
 export function routeQueueControlCommand(command, context, requestId) {
     switch (command.cmd) {
@@ -32,6 +32,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:

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);
     }
 }

package/dist/infrastructure/server/handlers/advanced/dependencies.js

@@ -1,12 +1,13 @@
 import { jobId } from '../../../../domain/types/job';
 import * as response from '../../../../domain/types/response';
+import { sanitizeServerError } from '../../errors';
 export async function handleGetFailedChildrenValues(command, context, requestId) {
     try {
         const values = await context.queueManager.getFailedChildrenValues(jobId(command.id));
         return { ok: true, values, reqId: requestId };
     }
-    catch {
-        return { ok: true, values: {}, reqId: requestId };
+    catch (error) {
+        return response.error(sanitizeServerError(error), requestId);
     }
 }
 export async function handleGetIgnoredChildrenFailures(command, context, requestId) {
@@ -14,8 +15,8 @@ export async function handleGetIgnoredChildrenFailures(command, context, request
         const values = await context.queueManager.getIgnoredChildrenFailures(jobId(command.id));
         return { ok: true, values, reqId: requestId };
     }
-    catch {
-        return { ok: true, values: {}, reqId: requestId };
+    catch (error) {
+        return response.error(sanitizeServerError(error), requestId);
     }
 }
 export async function handleRemoveChildDependency(command, context, requestId) {
@@ -24,7 +25,7 @@ export async function handleRemoveChildDependency(command, context, requestId) {
         return { ok: true, removed, reqId: requestId };
     }
     catch (error) {
-        return response.error(error instanceof Error ? error.message : String(error), requestId);
+        return response.error(sanitizeServerError(error), requestId);
     }
 }
 export async function handleRemoveUnprocessedChildren(command, context, requestId) {
@@ -33,6 +34,6 @@ export async function handleRemoveUnprocessedChildren(command, context, requestI
         return response.ok(undefined, requestId);
     }
     catch (error) {
-        return response.error(error instanceof Error ? error.message : String(error), requestId);
+        return response.error(sanitizeServerError(error), requestId);
     }
 }

package/dist/infrastructure/server/handlers/advanced/jobs.js

@@ -1,6 +1,7 @@
 import { jobId } from '../../../../domain/types/job';
 import * as response from '../../../../domain/types/response';
 import { validateNumericField } from '../../protocol';
+import { sanitizeServerError } from '../../errors';
 export async function handleUpdate(command, context, requestId) {
     const success = await context.queueManager.updateJobData(jobId(command.id), command.data);
     if (success)
@@ -35,7 +36,7 @@ export async function handleUpdateParent(command, context, requestId) {
         return response.ok(undefined, requestId);
     }
     catch (error) {
-        return response.error(error instanceof Error ? error.message : 'Failed to update parent', requestId);
+        return response.error(sanitizeServerError(error), requestId);
     }
 }
 export async function handleMoveToDelayed(command, context, requestId) {
@@ -69,13 +70,22 @@ export async function handleWaitJob(command, context, requestId) {
         return response.error(timeoutError, requestId);
     const timeout = command.timeout ?? 30000;
     const job = await context.queueManager.getJob(id);
-    if (!job)
-        return response.error('Job not found', requestId);
+    if (!job) {
+        const completion = await context.queueManager.getCompletionAsync(id);
+        if (!completion.found)
+            return response.error('Job not found', requestId);
+        return {
+            ok: true,
+            completed: true,
+            result: completion.result,
+            reqId: requestId,
+        };
+    }
     if (job.completedAt) {
         return {
             ok: true,
             completed: true,
-            result: context.queueManager.getResult(id),
+            result: await context.queueManager.getResultAsync(id),
             reqId: requestId,
         };
     }
@@ -84,7 +94,7 @@ export async function handleWaitJob(command, context, requestId) {
         return {
             ok: true,
             completed: true,
-            result: context.queueManager.getResult(id),
+            result: await context.queueManager.getResultAsync(id),
             reqId: requestId,
         };
     }
@@ -121,7 +131,10 @@ export async function handleMoveToWait(command, context, requestId) {
         const job = await context.queueManager.getJob(id);
         if (!job)
             return response.error('Job not found', requestId);
-        const count = context.queueManager.retryDlq(job.queue, id);
+        const manager = context.queueManager;
+        const count = manager.retryDlqDurable
+            ? await manager.retryDlqDurable(job.queue, id)
+            : manager.retryDlq(job.queue, id);
         return count > 0
             ? response.ok(undefined, requestId)
             : response.error('Failed job not in DLQ', requestId);

package/dist/infrastructure/server/handlers/advanced/queue.d.ts

@@ -3,40 +3,40 @@ import type { Response } from '../../../../domain/types/response';
 import type { HandlerContext } from '../../types';
 export declare function handleIsPaused(command: Extract<Command, {
     cmd: 'IsPaused';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleObliterate(command: Extract<Command, {
     cmd: 'Obliterate';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleListQueues(_command: Extract<Command, {
     cmd: 'ListQueues';
 }>, context: HandlerContext, requestId?: string): Response;
 export declare function handleClean(command: Extract<Command, {
     cmd: 'Clean';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleCount(command: Extract<Command, {
     cmd: 'Count';
 }>, context: HandlerContext, requestId?: string): Response;
 export declare function handleRateLimit(command: Extract<Command, {
     cmd: 'RateLimit';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleRateLimitClear(command: Extract<Command, {
     cmd: 'RateLimitClear';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleSetConcurrency(command: Extract<Command, {
     cmd: 'SetConcurrency';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleClearConcurrency(command: Extract<Command, {
     cmd: 'ClearConcurrency';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleSetStallConfig(command: Extract<Command, {
     cmd: 'SetStallConfig';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleGetStallConfig(command: Extract<Command, {
     cmd: 'GetStallConfig';
 }>, context: HandlerContext, requestId?: string): Response;
 export declare function handleSetDlqConfig(command: Extract<Command, {
     cmd: 'SetDlqConfig';
-}>, context: HandlerContext, requestId?: string): Response;
+}>, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleGetDlqConfig(command: Extract<Command, {
     cmd: 'GetDlqConfig';
 }>, context: HandlerContext, requestId?: string): Response;

package/dist/infrastructure/server/handlers/advanced/queue.js

@@ -1,14 +1,26 @@
 import * as response from '../../../../domain/types/response';
 import { sanitizeConfigNumbers, toFiniteNumber } from './configNumbers';
 export function handleIsPaused(command, context, requestId) {
+    const manager = context.queueManager;
+    if (manager.isPausedDurable) {
+        return manager.isPausedDurable(command.queue).then((paused) => ({
+            ok: true,
+            paused,
+            reqId: requestId,
+        }));
+    }
     return {
         ok: true,
-        paused: context.queueManager.isPaused(command.queue),
+        paused: manager.isPaused(command.queue),
         reqId: requestId,
     };
 }
 export function handleObliterate(command, context, requestId) {
-    context.queueManager.obliterate(command.queue);
+    const manager = context.queueManager;
+    if (manager.obliterateDurable) {
+        return manager.obliterateDurable(command.queue).then(() => response.ok(undefined, requestId));
+    }
+    manager.obliterate(command.queue);
     return response.ok(undefined, requestId);
 }
 export function handleListQueues(_command, context, requestId) {
@@ -19,15 +31,24 @@ export function handleListQueues(_command, context, requestId) {
     };
 }
 export function handleClean(command, context, requestId) {
-    const ids = context.queueManager.clean(command.queue, command.grace, command.state, command.limit);
+    const manager = context.queueManager;
+    if (manager.cleanDurable) {
+        return manager
+            .cleanDurable(command.queue, command.grace, command.state, command.limit)
+            .then((ids) => cleanResponse(manager, command.queue, command.state, ids, requestId));
+    }
+    const ids = manager.clean(command.queue, command.grace, command.state, command.limit);
+    return cleanResponse(manager, command.queue, command.state, ids, requestId);
+}
+function cleanResponse(manager, queue, state, ids, requestId) {
     if (ids.length > 0) {
-        context.queueManager.emitDashboardEvent('queue:cleaned', {
-            queue: command.queue,
-            state: command.state,
+        manager.emitDashboardEvent('queue:cleaned', {
+            queue,
+            state,
             count: ids.length,
         });
     }
-    return { ok: true, count: ids.length, ids, reqId: requestId };
+    return { ok: true, count: ids.length, ids: [...ids], reqId: requestId };
 }
 export function handleCount(command, context, requestId) {
     return { ok: true, count: context.queueManager.count(command.queue), reqId: requestId };
@@ -38,8 +59,19 @@ export function handleRateLimit(command, context, requestId) {
         return response.error('limit must be a finite number', requestId);
     const duration = toFiniteNumber(command.duration);
     const ttl = toFiniteNumber(command.ttl);
-    context.queueManager.setRateLimit(command.queue, limit, duration, ttl);
-    context.queueManager.emitDashboardEvent('ratelimit:set', {
+    const manager = context.queueManager;
+    if (manager.setRateLimitDurable) {
+        return manager.setRateLimitDurable(command.queue, limit, duration ?? 1000, ttl).then(() => {
+            manager.emitDashboardEvent('ratelimit:set', {
+                queue: command.queue,
+                max: limit,
+                duration: duration ?? 1000,
+            });
+            return response.ok(undefined, requestId);
+        });
+    }
+    manager.setRateLimit(command.queue, limit, duration, ttl);
+    manager.emitDashboardEvent('ratelimit:set', {
         queue: command.queue,
         max: limit,
         ...(duration !== undefined && { duration }),
@@ -48,24 +80,48 @@ export function handleRateLimit(command, context, requestId) {
     return response.ok(undefined, requestId);
 }
 export function handleRateLimitClear(command, context, requestId) {
-    context.queueManager.clearRateLimit(command.queue);
-    context.queueManager.emitDashboardEvent('ratelimit:cleared', { queue: command.queue });
+    const manager = context.queueManager;
+    if (manager.setRateLimitDurable) {
+        return manager.setRateLimitDurable(command.queue, null, null).then(() => {
+            manager.emitDashboardEvent('ratelimit:cleared', { queue: command.queue });
+            return response.ok(undefined, requestId);
+        });
+    }
+    manager.clearRateLimit(command.queue);
+    manager.emitDashboardEvent('ratelimit:cleared', { queue: command.queue });
     return response.ok(undefined, requestId);
 }
 export function handleSetConcurrency(command, context, requestId) {
     const limit = toFiniteNumber(command.limit);
     if (limit === undefined)
         return response.error('limit must be a finite number', requestId);
-    context.queueManager.setConcurrency(command.queue, limit);
-    context.queueManager.emitDashboardEvent('concurrency:set', {
+    const manager = context.queueManager;
+    if (manager.setConcurrencyDurable) {
+        return manager.setConcurrencyDurable(command.queue, limit).then(() => {
+            manager.emitDashboardEvent('concurrency:set', {
+                queue: command.queue,
+                concurrency: limit,
+            });
+            return response.ok(undefined, requestId);
+        });
+    }
+    manager.setConcurrency(command.queue, limit);
+    manager.emitDashboardEvent('concurrency:set', {
         queue: command.queue,
         concurrency: limit,
     });
     return response.ok(undefined, requestId);
 }
 export function handleClearConcurrency(command, context, requestId) {
-    context.queueManager.clearConcurrency(command.queue);
-    context.queueManager.emitDashboardEvent('concurrency:cleared', { queue: command.queue });
+    const manager = context.queueManager;
+    if (manager.setConcurrencyDurable) {
+        return manager.setConcurrencyDurable(command.queue, null).then(() => {
+            manager.emitDashboardEvent('concurrency:cleared', { queue: command.queue });
+            return response.ok(undefined, requestId);
+        });
+    }
+    manager.clearConcurrency(command.queue);
+    manager.emitDashboardEvent('concurrency:cleared', { queue: command.queue });
     return response.ok(undefined, requestId);
 }
 export function handleSetStallConfig(command, context, requestId) {
@@ -74,12 +130,16 @@ export function handleSetStallConfig(command, context, requestId) {
         'maxStalls',
         'gracePeriod',
     ]);
-    context.queueManager.setStallConfig(command.queue, config);
-    context.queueManager.emitDashboardEvent('config:stall-changed', {
-        queue: command.queue,
-        config,
-    });
-    return response.ok(undefined, requestId);
+    const manager = context.queueManager;
+    const complete = () => {
+        manager.emitDashboardEvent('config:stall-changed', { queue: command.queue, config });
+        return response.ok(undefined, requestId);
+    };
+    if (manager.setStallConfigDurable) {
+        return manager.setStallConfigDurable(command.queue, config).then(complete);
+    }
+    manager.setStallConfig(command.queue, config);
+    return complete();
 }
 export function handleGetStallConfig(command, context, requestId) {
     return {
@@ -95,12 +155,16 @@ export function handleSetDlqConfig(command, context, requestId) {
         'maxAge',
         'maxEntries',
     ]);
-    context.queueManager.setDlqConfig(command.queue, config);
-    context.queueManager.emitDashboardEvent('config:dlq-changed', {
-        queue: command.queue,
-        config,
-    });
-    return response.ok(undefined, requestId);
+    const manager = context.queueManager;
+    const complete = () => {
+        manager.emitDashboardEvent('config:dlq-changed', { queue: command.queue, config });
+        return response.ok(undefined, requestId);
+    };
+    if (manager.setDlqConfigDurable) {
+        return manager.setDlqConfigDurable(command.queue, config).then(complete);
+    }
+    manager.setDlqConfig(command.queue, config);
+    return complete();
 }
 export function handleGetDlqConfig(command, context, requestId) {
     return {

package/dist/infrastructure/server/handlers/core.js

@@ -1,8 +1,10 @@
 /** Core command handlers for push, pull, acknowledgement, and failure. */
 import * as resp from '../../../domain/types/response';
 import { jobId, normalizeLegacyJobPayload } from '../../../domain/types/job';
+import { tcpLog } from '../../../shared/logger';
+import { sanitizeServerError, serverErrorDiagnostics } from '../errors';
 import { validateQueueName, validateJobData, validateJobOptions, validateNumericField, } from '../protocol';
-import { validatePushBatchJobs } from './pushBatchValidation';
+import { validatePushBatchJobs, validatePushDependencies } from './pushBatchValidation';
 /** Handle PUSH command */
 export async function handlePush(cmd, ctx, reqId) {
     const queueError = validateQueueName(cmd.queue);
@@ -22,23 +24,10 @@ export async function handlePush(cmd, ctx, reqId) {
     });
     if (optionsError)
         return resp.error(optionsError, reqId);
-    // Validate dependsOn references exist
-    if (cmd.dependsOn && cmd.dependsOn.length > 0) {
-        for (const depId of cmd.dependsOn) {
-            const depJobId = jobId(depId);
-            const exists = ctx.queueManager.getJobIndex().has(depJobId) ||
-                ctx.queueManager.getCompletedJobs().has(depJobId) ||
-                // A removeOnComplete parent that completed is recorded only here (its row
-                // is deleted and it leaves jobIndex/completedJobs). The readiness path and
-                // dependency processor already honor depCompletions; the gate must too, or
-                // a late dependent is wrongly rejected with "Dependency job not found".
-                ctx.queueManager.getDepCompletions().has(depJobId);
-            if (!exists) {
-                return resp.error(`Dependency job not found: ${depId}`, reqId);
-            }
-        }
-    }
     try {
+        const dependencyError = await validatePushDependencies(cmd.dependsOn, ctx);
+        if (dependencyError)
+            return resp.error(dependencyError, reqId);
         const payload = normalizeLegacyJobPayload(cmd);
         const job = await ctx.queueManager.push(cmd.queue, {
             name: payload.name,
@@ -77,8 +66,7 @@ export async function handlePush(cmd, ctx, reqId) {
         return resp.ok(job.id, reqId);
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return resp.error(message, reqId);
+        return resp.error(sanitizeServerError(err), reqId);
     }
 }
 /** Handle PUSHB (batch push) command */
@@ -88,15 +76,20 @@ export async function handlePushBatch(cmd, ctx, reqId) {
         return resp.error(queueError, reqId);
     // PUSH parity: per-job data/option bounds + dependsOn existence gate
     // (extended to earlier same-batch custom ids for intra-batch chains).
-    const jobsError = validatePushBatchJobs(cmd.jobs, ctx);
-    if (jobsError)
-        return resp.error(jobsError, reqId);
-    const inputs = cmd.jobs.map((job) => {
-        const payload = normalizeLegacyJobPayload(job);
-        return { ...job, name: payload.name, data: payload.data };
-    });
-    const ids = await ctx.queueManager.pushBatch(cmd.queue, inputs);
-    return resp.batch(ids, reqId);
+    try {
+        const jobsError = await validatePushBatchJobs(cmd.jobs, ctx);
+        if (jobsError)
+            return resp.error(jobsError, reqId);
+        const inputs = cmd.jobs.map((job) => {
+            const payload = normalizeLegacyJobPayload(job);
+            return { ...job, name: payload.name, data: payload.data };
+        });
+        const ids = await ctx.queueManager.pushBatch(cmd.queue, inputs);
+        return resp.batch(ids, reqId);
+    }
+    catch (error) {
+        return resp.error(sanitizeServerError(error), reqId);
+    }
 }
 /** Handle PULL command */
 export async function handlePull(cmd, ctx, reqId) {
@@ -169,7 +162,7 @@ export async function handleAck(cmd, ctx, reqId) {
         return outcome ? resp.data(outcome, reqId) : resp.ok(undefined, reqId);
     }
     catch (err) {
-        return resp.error(err instanceof Error ? err.message : String(err), reqId);
+        return resp.error(sanitizeServerError(err), reqId);
     }
 }
 /** Handle ACKB (batch ack) command - supports optional results and tokens */
@@ -210,7 +203,15 @@ export async function handleAckBatch(cmd, ctx, reqId) {
         return outcome ? resp.data(outcome, reqId) : resp.ok(undefined, reqId);
     }
     catch (err) {
-        return resp.error(err instanceof Error ? err.message : String(err), reqId);
+        const message = sanitizeServerError(err);
+        if (message === 'Internal server error') {
+            tcpLog.error('ACKB failed', {
+                ...serverErrorDiagnostics(err),
+                batchSize: ids.length,
+                ...(reqId && { reqId }),
+            });
+        }
+        return resp.error(message, reqId);
     }
 }
 /** Handle FAIL command */
@@ -229,6 +230,6 @@ export async function handleFail(cmd, ctx, reqId) {
         return outcome ? resp.data(outcome, reqId) : resp.ok(undefined, reqId);
     }
     catch (err) {
-        return resp.error(err instanceof Error ? err.message : String(err), reqId);
+        return resp.error(sanitizeServerError(err), reqId);
     }
 }

package/dist/infrastructure/server/handlers/cron.d.ts

@@ -8,16 +8,16 @@ import type { HandlerContext } from '../types';
 /** Handle Cron command - add cron job */
 export declare function handleCron(cmd: Extract<Command, {
     cmd: 'Cron';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle CronGet command - get single cron job by name */
 export declare function handleCronGet(cmd: Extract<Command, {
     cmd: 'CronGet';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle CronDelete command - delete cron job */
 export declare function handleCronDelete(cmd: Extract<Command, {
     cmd: 'CronDelete';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle CronList command - list cron jobs */
 export declare function handleCronList(_cmd: Extract<Command, {
     cmd: 'CronList';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;