bunqueue 2.8.60 → 2.9.2

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

@@ -4,12 +4,26 @@
  */
 import * as resp from '../../../domain/types/response';
 import { normalizeLegacyJobPayload } from '../../../domain/types/job';
+import { sanitizeServerError } from '../errors';
+function cronData(cron) {
+    return {
+        name: cron.name,
+        jobName: cron.jobName,
+        queue: cron.queue,
+        schedule: cron.schedule,
+        repeatEvery: cron.repeatEvery,
+        nextRun: cron.nextRun,
+        executions: cron.executions,
+        maxLimit: cron.maxLimit,
+        timezone: cron.timezone,
+        priority: cron.priority,
+    };
+}
 /** Handle Cron command - add cron job */
 export function handleCron(cmd, ctx, reqId) {
     try {
         const payload = normalizeLegacyJobPayload({ name: cmd.jobName, data: cmd.data });
-        const existing = ctx.queueManager.getCron(cmd.name);
-        const cron = ctx.queueManager.addCron({
+        const input = {
             name: cmd.name,
             jobName: payload.name,
             queue: cmd.queue,
@@ -26,80 +40,67 @@ export function handleCron(cmd, ctx, reqId) {
             skipIfNoWorker: cmd.skipIfNoWorker,
             preventOverlap: cmd.preventOverlap,
             jobOptions: cmd.jobOptions,
-        });
-        ctx.queueManager.emitDashboardEvent(existing ? 'cron:updated' : 'cron:created', {
-            name: cron.name,
-            queue: cron.queue,
-            pattern: cron.schedule ?? undefined,
-            every: cron.repeatEvery ?? undefined,
-            nextRun: cron.nextRun,
-        });
-        return {
-            ok: true,
-            cron: {
+        };
+        const manager = ctx.queueManager;
+        const complete = (cron, existed) => {
+            manager.emitDashboardEvent(existed ? 'cron:updated' : 'cron:created', {
                 name: cron.name,
-                jobName: cron.jobName,
                 queue: cron.queue,
-                schedule: cron.schedule,
-                repeatEvery: cron.repeatEvery,
+                pattern: cron.schedule ?? undefined,
+                every: cron.repeatEvery ?? undefined,
                 nextRun: cron.nextRun,
-                executions: cron.executions,
-                maxLimit: cron.maxLimit,
-                timezone: cron.timezone,
-                priority: cron.priority,
-            },
-            reqId,
+            });
+            return { ok: true, cron: cronData(cron), reqId };
         };
+        if (manager.addCronDurable && manager.getCronDurable) {
+            const addCronDurable = manager.addCronDurable.bind(manager);
+            const getCronDurable = manager.getCronDurable.bind(manager);
+            return (async () => {
+                const existed = (await getCronDurable(cmd.name)) !== undefined;
+                return complete(await addCronDurable(input), existed);
+            })();
+        }
+        const existing = manager.getCron(cmd.name);
+        return complete(manager.addCron(input), existing !== undefined);
     }
     catch (err) {
-        return resp.error(err instanceof Error ? err.message : 'Failed to add cron', reqId);
+        return resp.error(sanitizeServerError(err), reqId);
     }
 }
 /** Handle CronGet command - get single cron job by name */
 export function handleCronGet(cmd, ctx, reqId) {
-    const cron = ctx.queueManager.getCron(cmd.name);
-    if (!cron) {
-        return resp.error('Cron job not found', reqId);
-    }
-    return {
-        ok: true,
-        cron: {
-            name: cron.name,
-            jobName: cron.jobName,
-            queue: cron.queue,
-            schedule: cron.schedule,
-            repeatEvery: cron.repeatEvery,
-            nextRun: cron.nextRun,
-            executions: cron.executions,
-            maxLimit: cron.maxLimit,
-            timezone: cron.timezone,
-        },
-        reqId,
+    const manager = ctx.queueManager;
+    const complete = (cron) => {
+        if (!cron) {
+            return resp.error('Cron job not found', reqId);
+        }
+        return { ok: true, cron: cronData(cron), reqId };
     };
+    return manager.getCronDurable
+        ? manager.getCronDurable(cmd.name).then(complete)
+        : complete(manager.getCron(cmd.name));
 }
 /** Handle CronDelete command - delete cron job */
 export function handleCronDelete(cmd, ctx, reqId) {
-    const removed = ctx.queueManager.removeCron(cmd.name);
-    if (removed)
-        ctx.queueManager.emitDashboardEvent('cron:deleted', { name: cmd.name });
-    return removed ? resp.ok(undefined, reqId) : resp.error('Cron job not found', reqId);
+    const manager = ctx.queueManager;
+    const complete = (removed) => {
+        if (removed)
+            manager.emitDashboardEvent('cron:deleted', { name: cmd.name });
+        return removed ? resp.ok(undefined, reqId) : resp.error('Cron job not found', reqId);
+    };
+    return manager.removeCronDurable
+        ? manager.removeCronDurable(cmd.name).then(complete)
+        : complete(manager.removeCron(cmd.name));
 }
 /** Handle CronList command - list cron jobs */
 export function handleCronList(_cmd, ctx, reqId) {
-    const crons = ctx.queueManager.listCrons();
-    return {
+    const manager = ctx.queueManager;
+    const complete = (crons) => ({
         ok: true,
-        crons: crons.map((c) => ({
-            name: c.name,
-            jobName: c.jobName,
-            queue: c.queue,
-            schedule: c.schedule,
-            repeatEvery: c.repeatEvery,
-            nextRun: c.nextRun,
-            executions: c.executions,
-            maxLimit: c.maxLimit,
-            timezone: c.timezone,
-        })),
+        crons: crons.map(cronData),
         reqId,
-    };
+    });
+    return manager.listCronsDurable
+        ? manager.listCronsDurable().then(complete)
+        : complete(manager.listCrons());
 }

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

@@ -9,7 +9,7 @@ import type { HandlerContext } from '../types';
 /** Dashboard overview - single call for all dashboard data */
 export declare function handleDashboardOverview(_cmd: Extract<Command, {
     cmd: 'DashboardOverview';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Dashboard queues - all queues with per-queue stats */
 export declare function handleDashboardQueues(_cmd: Extract<Command, {
     cmd: 'DashboardQueues';

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

@@ -7,17 +7,30 @@ import * as resp from '../../../domain/types/response';
 import { throughputTracker } from '../../../application/throughputTracker';
 import { latencyTracker } from '../../../application/latencyTracker';
 import { pausedView } from '../../../shared/pausedView';
+import { clientStorageStatus } from '../../../shared/storageHealth';
+const WORKER_TIMEOUT_MS = parseInt(Bun.env.WORKER_TIMEOUT_MS ?? '30000', 10);
 /** Dashboard overview - single call for all dashboard data */
 export function handleDashboardOverview(_cmd, ctx, reqId) {
-    const stats = ctx.queueManager.getStats();
+    const manager = ctx.queueManager;
+    if (manager.listWorkersDurable || manager.listCronsDurable) {
+        return Promise.all([
+            manager.listWorkersDurable
+                ? manager.listWorkersDurable()
+                : Promise.resolve(manager.workerManager.list()),
+            manager.listCronsDurable ? manager.listCronsDurable() : Promise.resolve(manager.listCrons()),
+        ]).then(([workers, crons]) => dashboardOverviewResponse(manager, workers, crons, reqId));
+    }
+    return dashboardOverviewResponse(manager, manager.workerManager.list(), manager.listCrons(), reqId);
+}
+function dashboardOverviewResponse(queueManager, workers, crons, reqId) {
+    const stats = queueManager.getStats();
     const rates = throughputTracker.getRates();
     const latencies = latencyTracker.getPercentiles();
     const avgLatencies = latencyTracker.getAverages();
-    const memStats = ctx.queueManager.getMemoryStats();
-    const workers = ctx.queueManager.workerManager.list();
-    const workerStats = ctx.queueManager.workerManager.getStats();
-    const crons = ctx.queueManager.listCrons();
-    const storage = ctx.queueManager.getStorageStatus();
+    const memStats = queueManager.getMemoryStats();
+    const now = Date.now();
+    const activeWorkers = workers.filter((worker) => now - worker.lastSeen < WORKER_TIMEOUT_MS);
+    const storage = clientStorageStatus(queueManager.getStorageStatus());
     const mem = process.memoryUsage();
     return resp.data({
         stats: {
@@ -44,8 +57,8 @@ export function handleDashboardOverview(_cmd, ctx, reqId) {
         },
         collections: memStats,
         workers: {
-            total: workerStats.total,
-            active: workerStats.active,
+            total: workers.length,
+            active: activeWorkers.length,
             list: workers.map((w) => ({
                 id: w.id,
                 name: w.name,

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

@@ -15,12 +15,15 @@ export declare function handleGetDlqStats(cmd: Extract<Command, {
 /** Handle RetryDlq command - retry DLQ jobs */
 export declare function handleRetryDlq(cmd: Extract<Command, {
     cmd: 'RetryDlq';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle PurgeDlq command - clear DLQ */
 export declare function handlePurgeDlq(cmd: Extract<Command, {
     cmd: 'PurgeDlq';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
+export declare function handleRemoveDlqJob(cmd: Extract<Command, {
+    cmd: 'RemoveDlqJob';
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle RetryCompleted command - retry completed jobs */
 export declare function handleRetryCompleted(cmd: Extract<Command, {
     cmd: 'RetryCompleted';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;

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

@@ -21,32 +21,58 @@ export function handleGetDlqStats(cmd, ctx, reqId) {
 /** Handle RetryDlq command - retry DLQ jobs */
 export function handleRetryDlq(cmd, ctx, reqId) {
     const jid = cmd.jobId ? jobId(cmd.jobId) : undefined;
+    const manager = ctx.queueManager;
+    if (manager.retryDlqDurable) {
+        return manager
+            .retryDlqDurable(cmd.queue, jid, cmd.count, cmd.filter)
+            .then((count) => retryDlqResponse(manager, cmd.queue, jid, count, reqId));
+    }
     // #111-class: honour the caller's `count` cap instead of retrying the whole DLQ.
     const count = cmd.filter
         ? ctx.queueManager.retryDlqByFilter(cmd.queue, cmd.filter)
         : ctx.queueManager.retryDlq(cmd.queue, jid, cmd.count);
+    return retryDlqResponse(manager, cmd.queue, jid, count, reqId);
+}
+function retryDlqResponse(manager, queue, jid, count, reqId) {
     if (count > 0) {
         const event = jid ? 'dlq:retried' : 'dlq:retry-all';
-        const data = { queue: cmd.queue, count };
+        const data = { queue, count };
         if (jid)
             data.jobId = String(jid);
-        ctx.queueManager.emitDashboardEvent(event, data);
+        manager.emitDashboardEvent(event, data);
     }
     return { ok: true, count, reqId };
 }
 /** Handle PurgeDlq command - clear DLQ */
 export function handlePurgeDlq(cmd, ctx, reqId) {
-    const count = ctx.queueManager.purgeDlq(cmd.queue);
-    if (count > 0)
-        ctx.queueManager.emitDashboardEvent('dlq:purged', { queue: cmd.queue, count });
-    return { ok: true, count, reqId };
+    const manager = ctx.queueManager;
+    const complete = (count) => {
+        if (count > 0)
+            manager.emitDashboardEvent('dlq:purged', { queue: cmd.queue, count });
+        return { ok: true, count, reqId };
+    };
+    return manager.purgeDlqDurable
+        ? manager.purgeDlqDurable(cmd.queue).then(complete)
+        : complete(manager.purgeDlq(cmd.queue));
+}
+export function handleRemoveDlqJob(cmd, ctx, reqId) {
+    const id = jobId(cmd.jobId);
+    const manager = ctx.queueManager;
+    return manager.removeDlqJobDurable
+        ? manager.removeDlqJobDurable(cmd.queue, id).then((removed) => resp.data({ removed }, reqId))
+        : resp.data({ removed: manager.removeDlqJob(cmd.queue, id) }, reqId);
 }
 /** Handle RetryCompleted command - retry completed jobs */
 export function handleRetryCompleted(cmd, ctx, reqId) {
     const jid = cmd.id ? jobId(cmd.id) : undefined;
-    const count = ctx.queueManager.retryCompleted(cmd.queue, jid, {
+    const options = {
         limit: cmd.count,
         timestamp: cmd.timestamp,
-    });
-    return { ok: true, count, reqId };
+    };
+    const manager = ctx.queueManager;
+    return manager.retryCompletedDurable
+        ? manager
+            .retryCompletedDurable(cmd.queue, jid, options)
+            .then((count) => ({ ok: true, count, reqId }))
+        : { ok: true, count: manager.retryCompleted(cmd.queue, jid, options), reqId };
 }

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

@@ -1,5 +1,6 @@
 import * as resp from '../../../domain/types/response';
 import { normalizeLegacyJobPayload } from '../../../domain/types/job';
+import { sanitizeServerError } from '../errors';
 /** Commit the whole graph in one broker operation; validation happens pre-mutation. */
 export async function handlePushFlow(cmd, ctx, reqId) {
     try {
@@ -11,6 +12,6 @@ export async function handlePushFlow(cmd, ctx, reqId) {
         return resp.data(result, reqId);
     }
     catch (error) {
-        return resp.error(error instanceof Error ? error.message : String(error), reqId);
+        return resp.error(sanitizeServerError(error), reqId);
     }
 }

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

@@ -0,0 +1,11 @@
+import type { Command } from '../../../domain/types/command';
+import type { Response } from '../../../domain/types/response';
+import type { HandlerContext } from '../types';
+type GroupCommand = Extract<Command, {
+    groupId: string;
+}>;
+export declare function handleGroupCommand(command: GroupCommand, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleGroupsJobsCount(command: Extract<Command, {
+    cmd: 'GetGroupsJobsCount';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export {};

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

@@ -0,0 +1,55 @@
+import { validatePositiveSafeInteger } from '../../../domain/types/group';
+import * as resp from '../../../domain/types/response';
+import { validateGroupId, validateQueueName } from '../protocol';
+function validate(command) {
+    const queueError = validateQueueName(command.queue);
+    if (queueError)
+        return queueError;
+    return validateGroupId(command.groupId, true);
+}
+export async function handleGroupCommand(command, context, requestId) {
+    const error = validate(command);
+    if (error)
+        return resp.error(error, requestId);
+    const manager = context.queueManager;
+    switch (command.cmd) {
+        case 'GetGroupJobsCount':
+            return resp.data({ count: await manager.getGroupJobsCount(command.queue, command.groupId) }, requestId);
+        case 'GetGroupActiveCount':
+            return resp.data({ count: await manager.getGroupActiveCount(command.queue, command.groupId) }, requestId);
+        case 'SetGroupRateLimit': {
+            const maxError = validatePositiveSafeInteger(command.max, 'max');
+            const durationError = validatePositiveSafeInteger(command.duration, 'duration');
+            const numericError = maxError ?? durationError;
+            if (numericError)
+                return resp.error(numericError, requestId);
+            await manager.setGroupRateLimit(command.queue, command.groupId, command.max, command.duration);
+            return resp.ok(undefined, requestId);
+        }
+        case 'GetGroupRateLimit':
+            return resp.data({ limit: await manager.getGroupRateLimit(command.queue, command.groupId) }, requestId);
+        case 'RemoveGroupRateLimit':
+            return resp.data({ removed: await manager.removeGroupRateLimit(command.queue, command.groupId) }, requestId);
+        case 'GetGroupRateLimitTtl':
+            return resp.data({
+                ttl: await manager.getGroupRateLimitTtl(command.queue, command.groupId, command.maxJobs),
+            }, requestId);
+        case 'SetGroupConcurrency': {
+            const concurrencyError = validatePositiveSafeInteger(command.concurrency, 'concurrency');
+            if (concurrencyError)
+                return resp.error(concurrencyError, requestId);
+            await manager.setGroupConcurrency(command.queue, command.groupId, command.concurrency);
+            return resp.ok(undefined, requestId);
+        }
+        case 'GetGroupConcurrency':
+            return resp.data({ concurrency: await manager.getGroupConcurrency(command.queue, command.groupId) }, requestId);
+        case 'RemoveGroupConcurrency':
+            return resp.data({ removed: await manager.removeGroupConcurrency(command.queue, command.groupId) }, requestId);
+    }
+}
+export async function handleGroupsJobsCount(command, context, requestId) {
+    const queueError = validateQueueName(command.queue);
+    if (queueError)
+        return resp.error(queueError, requestId);
+    return resp.data({ count: await context.queueManager.getGroupsJobsCount(command.queue) }, requestId);
+}

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

@@ -20,15 +20,15 @@ export declare function handleGetProgress(cmd: Extract<Command, {
 /** Handle Pause command */
 export declare function handlePause(cmd: Extract<Command, {
     cmd: 'Pause';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle Resume command */
 export declare function handleResume(cmd: Extract<Command, {
     cmd: 'Resume';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle Drain command */
 export declare function handleDrain(cmd: Extract<Command, {
     cmd: 'Drain';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Handle Stats command */
 export declare function handleStats(ctx: HandlerContext, reqId?: string): Response;
 /** Handle StorageStatus command - get real disk/storage health */
@@ -40,8 +40,8 @@ export declare function handleMetrics(ctx: HandlerContext, reqId?: string): Resp
 /** Handle the queue-scoped Metrics form. */
 export declare function handleQueueMetrics(cmd: Extract<Command, {
     cmd: 'Metrics';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;
 /** Trim one queue's durable lifecycle-event journal. */
 export declare function handleTrimEvents(cmd: Extract<Command, {
     cmd: 'TrimEvents';
-}>, ctx: HandlerContext, reqId?: string): Response;
+}>, ctx: HandlerContext, reqId?: string): Response | Promise<Response>;

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

@@ -7,6 +7,8 @@ import { jobId } from '../../../domain/types/job';
 import { throughputTracker } from '../../../application/throughputTracker';
 import { latencyTracker } from '../../../application/latencyTracker';
 import { validateQueueName } from '../protocol/validation';
+import { clientStorageStatus } from '../../../shared/storageHealth';
+import { sanitizeServerError } from '../errors';
 /** Handle Cancel command */
 export async function handleCancel(cmd, ctx, reqId) {
     const success = await ctx.queueManager.cancel(jobId(cmd.id));
@@ -48,18 +50,29 @@ export async function handleGetProgress(cmd, ctx, reqId) {
 }
 /** Handle Pause command */
 export function handlePause(cmd, ctx, reqId) {
-    ctx.queueManager.pause(cmd.queue);
+    const manager = ctx.queueManager;
+    if (manager.pauseDurable) {
+        return manager.pauseDurable(cmd.queue, true).then(() => resp.ok(undefined, reqId));
+    }
+    manager.pause(cmd.queue);
     return resp.ok(undefined, reqId);
 }
 /** Handle Resume command */
 export function handleResume(cmd, ctx, reqId) {
-    ctx.queueManager.resume(cmd.queue);
+    const manager = ctx.queueManager;
+    if (manager.pauseDurable) {
+        return manager.pauseDurable(cmd.queue, false).then(() => resp.ok(undefined, reqId));
+    }
+    manager.resume(cmd.queue);
     return resp.ok(undefined, reqId);
 }
 /** Handle Drain command */
 export function handleDrain(cmd, ctx, reqId) {
-    const count = ctx.queueManager.drain(cmd.queue);
-    return { ok: true, count, reqId };
+    const manager = ctx.queueManager;
+    if (manager.drainDurable) {
+        return manager.drainDurable(cmd.queue).then((count) => ({ ok: true, count, reqId }));
+    }
+    return { ok: true, count: manager.drain(cmd.queue), reqId };
 }
 /** Handle Stats command */
 export function handleStats(ctx, reqId) {
@@ -79,7 +92,7 @@ export function handleStats(ctx, reqId) {
 }
 /** Handle StorageStatus command - get real disk/storage health */
 export function handleStorageStatus(_cmd, ctx, reqId) {
-    const status = ctx.queueManager.getStorageStatus();
+    const status = clientStorageStatus(ctx.queueManager.getStorageStatus());
     return resp.data({ diskFull: status.diskFull, error: status.error, since: status.since }, reqId);
 }
 /** Handle Metrics command */
@@ -108,11 +121,18 @@ export function handleQueueMetrics(cmd, ctx, reqId) {
     if (cmd.type !== 'completed' && cmd.type !== 'failed') {
         return resp.error("Metrics type must be 'completed' or 'failed'", reqId);
     }
+    const manager = ctx.queueManager;
+    if (manager.getQueueMetricsDurable) {
+        return manager
+            .getQueueMetricsDurable(cmd.queue, cmd.type, cmd.start ?? 0, cmd.end ?? -1)
+            .then((metrics) => resp.data(metrics, reqId))
+            .catch((error) => resp.error(sanitizeServerError(error), reqId));
+    }
     try {
-        return resp.data(ctx.queueManager.getQueueMetrics(cmd.queue, cmd.type, cmd.start ?? 0, cmd.end ?? -1), reqId);
+        return resp.data(manager.getQueueMetrics(cmd.queue, cmd.type, cmd.start ?? 0, cmd.end ?? -1), reqId);
     }
     catch (error) {
-        return resp.error(error instanceof Error ? error.message : String(error), reqId);
+        return resp.error(sanitizeServerError(error), reqId);
     }
 }
 /** Trim one queue's durable lifecycle-event journal. */
@@ -120,10 +140,17 @@ export function handleTrimEvents(cmd, ctx, reqId) {
     const queueError = validateQueueName(cmd.queue);
     if (queueError)
         return resp.error(queueError, reqId);
+    const manager = ctx.queueManager;
+    if (manager.trimQueueEventsDurable) {
+        return manager
+            .trimQueueEventsDurable(cmd.queue, cmd.maxLength)
+            .then((removed) => resp.data({ removed }, reqId))
+            .catch((error) => resp.error(sanitizeServerError(error), reqId));
+    }
     try {
-        return resp.data({ removed: ctx.queueManager.trimQueueEvents(cmd.queue, cmd.maxLength) }, reqId);
+        return resp.data({ removed: manager.trimQueueEvents(cmd.queue, cmd.maxLength) }, reqId);
     }
     catch (error) {
-        return resp.error(error instanceof Error ? error.message : String(error), reqId);
+        return resp.error(sanitizeServerError(error), reqId);
     }
 }

package/dist/infrastructure/server/handlers/monitoring/health.d.ts

@@ -4,10 +4,10 @@ import type { Response } from '../../../../domain/types/response';
 import type { HandlerContext } from '../../types';
 export { PROTOCOL_VERSION };
 export declare const SUPPORTED_CAPABILITIES: ProtocolCapability[];
-export declare function handleAddLog(command: AddLogCommand, context: HandlerContext, requestId?: string): Response;
-export declare function handleGetLogs(command: GetLogsCommand, context: HandlerContext, requestId?: string): Response;
-export declare function handleHeartbeat(command: HeartbeatCommand, context: HandlerContext, requestId?: string): Response;
-export declare function handleJobHeartbeat(command: JobHeartbeatCommand, context: HandlerContext, requestId?: string): Response;
-export declare function handleJobHeartbeatBatch(command: JobHeartbeatBatchCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleAddLog(command: AddLogCommand, context: HandlerContext, requestId?: string): Response | Promise<Response>;
+export declare function handleGetLogs(command: GetLogsCommand, context: HandlerContext, requestId?: string): Response | Promise<Response>;
+export declare function handleHeartbeat(command: HeartbeatCommand, context: HandlerContext, requestId?: string): Response | Promise<Response>;
+export declare function handleJobHeartbeat(command: JobHeartbeatCommand, context: HandlerContext, requestId?: string): Response | Promise<Response>;
+export declare function handleJobHeartbeatBatch(command: JobHeartbeatBatchCommand, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handlePing(_command: PingCommand, _context: HandlerContext, requestId?: string): Response;
 export declare function handleHello(_command: HelloCommand, _context: HandlerContext, requestId?: string): Response;

package/dist/infrastructure/server/handlers/monitoring/health.js

@@ -5,18 +5,29 @@ import { VERSION } from '../../../../shared/version';
 export { PROTOCOL_VERSION };
 export const SUPPORTED_CAPABILITIES = [...PROTOCOL_CAPABILITIES];
 export function handleAddLog(command, context, requestId) {
-    const success = context.queueManager.addLog(jobId(command.id), command.message, command.level ?? 'info');
-    return success
+    const id = jobId(command.id);
+    const level = command.level ?? 'info';
+    const manager = context.queueManager;
+    const complete = (success) => success
         ? response.data({ added: true }, requestId)
         : response.error('Job not found', requestId);
+    return manager.addLogDurable
+        ? manager.addLogDurable(id, command.message, level).then(complete)
+        : complete(manager.addLog(id, command.message, level));
 }
 export function handleGetLogs(command, context, requestId) {
-    const all = context.queueManager.getLogs(jobId(command.id));
-    const total = all.length;
-    const logs = command.start === undefined && command.end === undefined
-        ? all
-        : all.slice(command.start ?? 0, (command.end ?? total - 1) + 1);
-    return response.data({ logs, count: total }, requestId);
+    const id = jobId(command.id);
+    const manager = context.queueManager;
+    const complete = (all) => {
+        const total = all.length;
+        const logs = command.start === undefined && command.end === undefined
+            ? all
+            : all.slice(command.start ?? 0, (command.end ?? total - 1) + 1);
+        return response.data({ logs, count: total }, requestId);
+    };
+    return manager.getLogsDurable
+        ? manager.getLogsDurable(id).then(complete)
+        : complete(manager.getLogs(id));
 }
 export function handleHeartbeat(command, context, requestId) {
     const stats = command.activeJobs !== undefined ||
@@ -28,15 +39,28 @@ export function handleHeartbeat(command, context, requestId) {
             failed: command.failed,
         }
         : undefined;
-    const success = context.queueManager.workerManager.heartbeat(command.id, stats);
-    if (success) {
-        context.queueManager.emitDashboardEvent('worker:heartbeat', { workerId: command.id });
-        return response.data({ ok: true }, requestId);
-    }
-    return response.error('Worker not found', requestId);
+    const manager = context.queueManager;
+    const complete = (success) => {
+        if (success) {
+            manager.emitDashboardEvent('worker:heartbeat', { workerId: command.id });
+            return response.data({ ok: true }, requestId);
+        }
+        return response.error('Worker not found', requestId);
+    };
+    return manager.heartbeatWorkerDurable
+        ? manager.heartbeatWorkerDurable(command.id, stats, context.clientId).then(complete)
+        : complete(manager.workerManager.heartbeat(command.id, stats));
 }
 export function handleJobHeartbeat(command, context, requestId) {
     const id = jobId(command.id);
+    const manager = context.queueManager;
+    if (manager.heartbeatDurable) {
+        return manager
+            .heartbeatDurable(id, command.token, command.duration)
+            .then((success) => success
+            ? response.data({ ok: true }, requestId)
+            : response.error('Job not found or not active (or invalid token)', requestId));
+    }
     if (command.duration && command.token) {
         const success = context.queueManager.renewJobLock(id, command.token, command.duration);
         return success
@@ -50,8 +74,13 @@ export function handleJobHeartbeat(command, context, requestId) {
 }
 export function handleJobHeartbeatBatch(command, context, requestId) {
     const ids = command.ids.map((id) => jobId(id));
-    const count = context.queueManager.jobHeartbeatBatch(ids, command.tokens);
-    return response.data({ ok: true, count }, requestId);
+    const manager = context.queueManager;
+    if (manager.heartbeatBatchDurable) {
+        return manager
+            .heartbeatBatchDurable(ids, command.tokens)
+            .then((count) => response.data({ ok: true, count }, requestId));
+    }
+    return response.data({ ok: true, count: manager.jobHeartbeatBatch(ids, command.tokens) }, requestId);
 }
 export function handlePing(_command, _context, requestId) {
     return response.data({ pong: true, time: Date.now() }, requestId);

package/dist/infrastructure/server/handlers/monitoring/operations.d.ts

@@ -2,7 +2,7 @@ import type { ClearLogsCommand, CompactMemoryCommand, ExtendLockCommand, ExtendL
 import type { Response } from '../../../../domain/types/response';
 import type { HandlerContext } from '../../types';
 export declare function handlePrometheus(_command: PrometheusCommand, context: HandlerContext, requestId?: string): Response;
-export declare function handleClearLogs(command: ClearLogsCommand, context: HandlerContext, requestId?: string): Response;
+export declare function handleClearLogs(command: ClearLogsCommand, context: HandlerContext, requestId?: string): Response | Promise<Response>;
 export declare function handleExtendLock(command: ExtendLockCommand, context: HandlerContext, requestId?: string): Promise<Response>;
 export declare function handleExtendLocks(command: ExtendLocksCommand, context: HandlerContext, requestId?: string): Promise<Response>;
 export declare function handleCompactMemory(_command: CompactMemoryCommand, context: HandlerContext, requestId?: string): Response;

package/dist/infrastructure/server/handlers/monitoring/operations.js

@@ -4,7 +4,14 @@ export function handlePrometheus(_command, context, requestId) {
     return response.data({ metrics: context.queueManager.getPrometheusMetrics() }, requestId);
 }
 export function handleClearLogs(command, context, requestId) {
-    context.queueManager.clearLogs(jobId(command.id), command.keepLogs);
+    const id = jobId(command.id);
+    const manager = context.queueManager;
+    if (manager.clearLogsDurable) {
+        return manager
+            .clearLogsDurable(id, command.keepLogs)
+            .then(() => response.ok(undefined, requestId));
+    }
+    manager.clearLogs(id, command.keepLogs);
     return response.ok(undefined, requestId);
 }
 export async function handleExtendLock(command, context, requestId) {