bunqueue 2.8.42 → 2.8.44

package/dist/infrastructure/server/bootstrap.js

@@ -14,6 +14,14 @@ 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;
+}
 /** Print startup banner */
 function printBanner(config, cloudUrl) {
     const dim = '\x1b[2m';
@@ -68,6 +76,12 @@ export function bootServer(fileConfig, config) {
         if (validLevels.includes(logLevel))
             Logger.setLevel(logLevel);
     }
+    const backupError = backupStartupError(config);
+    if (backupError) {
+        serverLog.error(backupError);
+        process.exitCode = 1;
+        return;
+    }
     // Resolve cloud config
     const cloudConfig = resolveCloudConfig(fileConfig, config.dataPath);
     // Resolve TLS config — fail fast on partial cert/key before binding anything
@@ -83,6 +97,7 @@ export function bootServer(fileConfig, config) {
     // 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;
@@ -101,6 +116,7 @@ export function bootServer(fileConfig, config) {
             authTokens: config.authTokens,
             corsOrigins: config.corsOrigins,
             requireAuthForMetrics: config.requireAuthForMetrics,
+            getTcpConnectionCount: () => tcpServer.getConnectionCount(),
             ...(tlsConfig && { tls: tlsConfig }),
         });
     }
@@ -114,10 +130,23 @@ export function bootServer(fileConfig, config) {
     let backupManager = null;
     if (config.dataPath) {
         const backupConfig = resolveBackupConfig(fileConfig, config.dataPath);
-        backupManager = new S3BackupManager(backupConfig);
+        backupManager = new S3BackupManager({
+            ...backupConfig,
+            flushBeforeBackup: () => {
+                queueManager.flushPersistence();
+            },
+        });
         backupManager.setDashboardEmit(queueManager.emitDashboardEvent.bind(queueManager));
         backupManager.start();
     }
+    queueManager.setOperationalMetricsProvider(() => ({
+        ...(backupManager && { backup: backupManager.getMetrics() }),
+        connections: {
+            tcp: tcpServer.getConnectionCount(),
+            websocket: httpServer.getWsClientCount(),
+            sse: httpServer.getSseClientCount(),
+        },
+    }));
     // Initialize bunqueue Cloud agent (remote dashboard telemetry)
     const cloudAgent = cloudConfig ? CloudAgent.createFromConfig(queueManager, cloudConfig) : null;
     if (cloudAgent) {

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

@@ -14,6 +14,8 @@ export interface HttpServerConfig {
     authTokens?: string[];
     corsOrigins?: string[];
     requireAuthForMetrics?: boolean;
+    /** Current TCP client count, supplied by the TCP server when available. */
+    getTcpConnectionCount?: () => number;
     /** Native TLS termination (https/wss). Protocol and routes are unchanged. */
     tls?: TlsServerOptions;
 }

package/dist/infrastructure/server/http.js

@@ -3,19 +3,13 @@
  * REST API and WebSocket support
  */
 import { constantTimeEqual, uuid } from '../../shared/hash';
-import { validateQueueName } from './protocol';
 import { httpLog } from '../../shared/logger';
 import { getRateLimiter } from './rateLimiter';
 import { SseHandler } from './sseHandler';
 import { WsHandler } from './wsHandler';
-import { jsonResponse, corsResponse, healthEndpoint, gcEndpoint, heapStatsEndpoint, statsEndpoint, metricsEndpoint, dashboardOverviewEndpoint, dashboardQueuesEndpoint, dashboardQueueDetailEndpoint, } from './httpEndpoints';
-import { routeJobRoutes } from './httpRouteJobs';
+import { jsonResponse, corsResponse, healthEndpoint, readinessEndpoint, gcEndpoint, heapStatsEndpoint, } from './httpEndpoints';
 import { loadTlsOptions } from './tls';
-import { routeQueueRoutes } from './httpRouteQueues';
-import { routeQueueConfigRoutes } from './httpRouteQueueConfig';
-import { routeResourceRoutes } from './httpRouteResources';
-// Pre-compiled regex patterns for URL matching
-const RE_DASHBOARD_QUEUE_DETAIL = /^\/dashboard\/queues\/([^/]+)$/;
+import { routeHttpRequest } from './httpRouter';
 /**
  * Validate auth token against valid tokens set
  */
@@ -81,13 +75,13 @@ export function createHttpServer(queueManager, config) {
         }
         // Health endpoints (no auth, no rate limit)
         if (path === '/health') {
-            return withCors(healthEndpoint(queueManager, wsHandler.size, sseHandler.size));
+            return withCors(healthEndpoint(queueManager, wsHandler.size, sseHandler.size, config.getTcpConnectionCount?.() ?? 0));
         }
         if (path === '/healthz' || path === '/live') {
             return withCors(new Response('OK', { status: 200 }));
         }
         if (path === '/ready') {
-            return jsonResponse({ ok: true, ready: true }, 200, corsOrigins);
+            return readinessEndpoint(queueManager, corsOrigins);
         }
         // Debug endpoints (require auth)
         if (path === '/gc' && req.method === 'POST') {
@@ -138,6 +132,9 @@ export function createHttpServer(queueManager, config) {
         // Prometheus metrics
         if (path === '/prometheus' && req.method === 'GET') {
             if (config.requireAuthForMetrics) {
+                if (authTokens.size === 0) {
+                    return jsonResponse({ ok: false, error: 'Metrics authentication is enabled but no tokens are configured' }, 503, corsOrigins);
+                }
                 const denied = checkAuth(req, authTokens);
                 if (denied)
                     return denied;
@@ -161,7 +158,7 @@ export function createHttpServer(queueManager, config) {
         // connections (TCP/WebSocket). Orphaned HTTP jobs are handled by stall detection.
         const ctx = { queueManager, authTokens, authenticated: true };
         try {
-            return await routeRequest(req, path, ctx, corsOrigins);
+            return await routeHttpRequest(req, path, ctx, corsOrigins);
         }
         catch (err) {
             const message = err instanceof Error ? err.message : 'Internal error';
@@ -194,7 +191,7 @@ export function createHttpServer(queueManager, config) {
             queueManager.unregisterWorkersByClientId(clientId);
             queueManager
                 .releaseClientJobs(clientId)
-                .then(() => { })
+                .then(() => undefined)
                 .catch((err) => {
                 httpLog.error('Failed to release WebSocket client jobs', {
                     clientId,
@@ -237,49 +234,3 @@ export function createHttpServer(queueManager, config) {
         },
     };
 }
-/** Route HTTP request to handler */
-async function routeRequest(req, path, ctx, corsOrigins) {
-    const method = req.method;
-    // Stats endpoint
-    if (path === '/stats' && method === 'GET') {
-        return statsEndpoint(ctx.queueManager, corsOrigins);
-    }
-    if (path === '/metrics' && method === 'GET') {
-        return metricsEndpoint(ctx.queueManager, corsOrigins);
-    }
-    // Dashboard endpoints
-    if (path === '/dashboard' && method === 'GET') {
-        return dashboardOverviewEndpoint(ctx.queueManager, corsOrigins);
-    }
-    if (path === '/dashboard/queues' && method === 'GET') {
-        const url = new URL(req.url);
-        const limit = Math.min(Math.max(parseInt(url.searchParams.get('limit') ?? '100', 10) || 100, 1), 500);
-        const offset = Math.max(parseInt(url.searchParams.get('offset') ?? '0', 10) || 0, 0);
-        return dashboardQueuesEndpoint(ctx.queueManager, limit, offset, corsOrigins);
-    }
-    const dashQueueMatch = path.match(RE_DASHBOARD_QUEUE_DETAIL);
-    if (dashQueueMatch && method === 'GET') {
-        const queue = decodeURIComponent(dashQueueMatch[1]);
-        const queueError = validateQueueName(queue);
-        if (queueError)
-            return jsonResponse({ ok: false, error: queueError }, 400, corsOrigins);
-        const url = new URL(req.url);
-        const includeJobs = url.searchParams.get('includeJobs') === 'true';
-        return dashboardQueueDetailEndpoint(ctx.queueManager, queue, includeJobs, corsOrigins);
-    }
-    // Route through sub-routers
-    let result;
-    result = await routeJobRoutes(req, path, method, ctx, corsOrigins);
-    if (result)
-        return result;
-    result = await routeQueueRoutes(req, path, method, ctx, corsOrigins);
-    if (result)
-        return result;
-    result = await routeQueueConfigRoutes(req, path, method, ctx, corsOrigins);
-    if (result)
-        return result;
-    result = await routeResourceRoutes(req, path, method, ctx, corsOrigins);
-    if (result)
-        return result;
-    return jsonResponse({ ok: false, error: 'Not found' }, 404, corsOrigins);
-}

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

@@ -0,0 +1,10 @@
+/**
+ * HTTP dashboard endpoints
+ */
+import type { QueueManager } from '../../application/queueManager';
+/** Dashboard overview endpoint - aggregates all dashboard data in a single call */
+export declare function dashboardOverviewEndpoint(queueManager: QueueManager, corsOrigins?: Set<string>): Response;
+/** Dashboard queues endpoint - paginated queues with per-queue stats */
+export declare function dashboardQueuesEndpoint(queueManager: QueueManager, limit: number, offset: number, corsOrigins?: Set<string>): Response;
+/** Dashboard single queue detail endpoint */
+export declare function dashboardQueueDetailEndpoint(queueManager: QueueManager, queue: string, includeJobs: boolean, corsOrigins?: Set<string>): Response;

package/dist/infrastructure/server/httpDashboardEndpoints.js

@@ -0,0 +1,146 @@
+/**
+ * HTTP dashboard endpoints
+ */
+import { latencyTracker } from '../../application/latencyTracker';
+import { throughputTracker } from '../../application/throughputTracker';
+import { pausedView } from '../../shared/pausedView';
+import { jsonResponse } from './httpResponse';
+/** Dashboard overview endpoint - aggregates all dashboard data in a single call */
+export function dashboardOverviewEndpoint(queueManager, corsOrigins) {
+    const stats = queueManager.getStats();
+    const rates = throughputTracker.getRates();
+    const latencies = latencyTracker.getPercentiles();
+    const avgLatencies = latencyTracker.getAverages();
+    const memStats = queueManager.getMemoryStats();
+    const workers = queueManager.workerManager.list();
+    const workerStats = queueManager.workerManager.getStats();
+    const crons = queueManager.listCrons();
+    const storage = queueManager.getStorageStatus();
+    const mem = process.memoryUsage();
+    return jsonResponse({
+        ok: true,
+        stats: {
+            waiting: stats.waiting,
+            active: stats.active,
+            delayed: stats.delayed,
+            completed: stats.completed,
+            dlq: stats.dlq,
+            totalPushed: Number(stats.totalPushed),
+            totalPulled: Number(stats.totalPulled),
+            totalCompleted: Number(stats.totalCompleted),
+            totalFailed: Number(stats.totalFailed),
+            uptime: stats.uptime,
+        },
+        throughput: rates,
+        latency: {
+            averages: avgLatencies,
+            percentiles: latencies,
+        },
+        memory: {
+            heapUsed: Math.round(mem.heapUsed / 1024 / 1024),
+            heapTotal: Math.round(mem.heapTotal / 1024 / 1024),
+            rss: Math.round(mem.rss / 1024 / 1024),
+        },
+        collections: memStats,
+        workers: {
+            total: workerStats.total,
+            active: workerStats.active,
+            list: workers
+                .slice(0, 100)
+                .map((w) => ({
+                id: w.id,
+                name: w.name,
+                queues: w.queues,
+                lastSeen: w.lastSeen,
+                activeJobs: w.activeJobs,
+                processedJobs: w.processedJobs,
+                failedJobs: w.failedJobs,
+            })),
+            truncated: workers.length > 100,
+        },
+        crons: {
+            total: crons.length,
+            list: crons
+                .slice(0, 100)
+                .map((c) => ({
+                name: c.name,
+                queue: c.queue,
+                schedule: c.schedule ?? null,
+                repeatEvery: c.repeatEvery ?? null,
+                nextRun: c.nextRun,
+                executions: c.executions,
+            })),
+            truncated: crons.length > 100,
+        },
+        storage,
+        timestamp: Date.now(),
+    }, 200, corsOrigins);
+}
+/** Dashboard queues endpoint - paginated queues with per-queue stats */
+export function dashboardQueuesEndpoint(queueManager, limit, offset, corsOrigins) {
+    const allQueues = queueManager.listQueues();
+    const total = allQueues.length;
+    const queueNames = allQueues.slice(offset, offset + limit);
+    const perQueueStats = queueManager.getPerQueueStats();
+    const queues = queueNames.map((name) => {
+        const stats = perQueueStats.get(name);
+        return {
+            name,
+            waiting: stats?.waiting ?? 0,
+            delayed: stats?.delayed ?? 0,
+            active: stats?.active ?? 0,
+            dlq: stats?.dlq ?? 0,
+            paused: queueManager.isPaused(name),
+        };
+    });
+    return jsonResponse({ ok: true, queues, total, limit, offset, timestamp: Date.now() }, 200, corsOrigins);
+}
+/** Dashboard single queue detail endpoint */
+export function dashboardQueueDetailEndpoint(queueManager, queue, includeJobs, corsOrigins) {
+    const rawCounts = queueManager.getQueueJobCounts(queue);
+    const paused = queueManager.isPaused(queue);
+    const pv = pausedView(rawCounts.waiting, rawCounts.prioritized, paused);
+    const counts = {
+        ...rawCounts,
+        waiting: pv.waiting,
+        prioritized: pv.prioritized,
+        paused: pv.paused,
+    };
+    const dlqJobs = queueManager.getDlq(queue, 10);
+    const priorityCounts = queueManager.getCountsPerPriority(queue);
+    const result = {
+        ok: true,
+        name: queue,
+        counts,
+        paused,
+        priorityCounts,
+        dlqPreview: dlqJobs.map((j) => ({
+            id: j.id,
+            data: j.data,
+            attempts: j.attempts,
+            createdAt: j.createdAt,
+        })),
+        timestamp: Date.now(),
+    };
+    if (includeJobs) {
+        const waiting = queueManager.getJobs(queue, { state: 'waiting', end: 10 });
+        const active = queueManager.getJobs(queue, { state: 'active', end: 10 });
+        const delayed = queueManager.getJobs(queue, { state: 'delayed', end: 10 });
+        const pausedJobs = paused ? queueManager.getJobs(queue, { state: 'paused', end: 10 }) : [];
+        const toSummary = (j) => ({
+            id: j.id,
+            priority: j.priority,
+            createdAt: j.createdAt,
+            runAt: j.runAt,
+            attempts: j.attempts,
+            progress: j.progress,
+        });
+        result.jobs = {
+            waiting: waiting.map(toSummary),
+            active: active.map(toSummary),
+            delayed: delayed.map(toSummary),
+            paused: pausedJobs.map(toSummary),
+        };
+    }
+    return jsonResponse(result, 200, corsOrigins);
+}

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

@@ -2,26 +2,22 @@
  * HTTP Endpoints - Health, diagnostics, and stats endpoints
  */
 import type { QueueManager } from '../../application/queueManager';
-/** JSON response helper */
-export declare function jsonResponse(data: unknown, status?: number, corsOrigins?: Set<string>): Response;
+export { dashboardOverviewEndpoint, dashboardQueueDetailEndpoint, dashboardQueuesEndpoint, } from './httpDashboardEndpoints';
+export { jsonResponse } from './httpResponse';
 /** Parse JSON body from request. Returns parsed object or 400 Response on invalid JSON.
  *  Empty/missing body returns {} for backward compatibility with optional-body routes. */
 export declare function parseJsonBody(req: Request, cors: Set<string>): Promise<Record<string, unknown> | Response>;
 /** CORS preflight response */
 export declare function corsResponse(corsOrigins: Set<string>): Response;
 /** Health check endpoint */
-export declare function healthEndpoint(queueManager: QueueManager, wsCount: number, sseCount: number): Response;
+export declare function healthEndpoint(queueManager: QueueManager, wsCount: number, sseCount: number, tcpCount?: number): Response;
+/** Readiness check - persistence failures must stop new traffic. */
+export declare function readinessEndpoint(queueManager: QueueManager, corsOrigins?: Set<string>): Response;
 /** GC endpoint - force garbage collection */
 export declare function gcEndpoint(queueManager: QueueManager): Response;
 /** Heap stats endpoint - for debugging memory leaks */
 export declare function heapStatsEndpoint(queueManager: QueueManager): Promise<Response>;
 /** Stats endpoint */
 export declare function statsEndpoint(queueManager: QueueManager, corsOrigins?: Set<string>): Response;
-/** Dashboard overview endpoint - aggregates all dashboard data in a single call */
-export declare function dashboardOverviewEndpoint(queueManager: QueueManager, corsOrigins?: Set<string>): Response;
-/** Dashboard queues endpoint - paginated queues with per-queue stats */
-export declare function dashboardQueuesEndpoint(queueManager: QueueManager, limit: number, offset: number, corsOrigins?: Set<string>): Response;
-/** Dashboard single queue detail endpoint */
-export declare function dashboardQueueDetailEndpoint(queueManager: QueueManager, queue: string, includeJobs: boolean, corsOrigins?: Set<string>): Response;
 /** Metrics endpoint */
 export declare function metricsEndpoint(queueManager: QueueManager, corsOrigins?: Set<string>): Response;

package/dist/infrastructure/server/httpEndpoints.js

@@ -3,20 +3,9 @@
  */
 import { VERSION } from '../../shared/version';
 import { throughputTracker } from '../../application/throughputTracker';
-import { latencyTracker } from '../../application/latencyTracker';
-import { pausedView } from '../../shared/pausedView';
-/** JSON response helper */
-export function jsonResponse(data, status = 200, corsOrigins) {
-    const headers = {
-        'Content-Type': 'application/json',
-    };
-    if (corsOrigins) {
-        headers['Access-Control-Allow-Origin'] = corsOrigins.has('*')
-            ? '*'
-            : Array.from(corsOrigins).join(', ');
-    }
-    return new Response(JSON.stringify(data), { status, headers });
-}
+import { jsonResponse } from './httpResponse';
+export { dashboardOverviewEndpoint, dashboardQueueDetailEndpoint, dashboardQueuesEndpoint, } from './httpDashboardEndpoints';
+export { jsonResponse } from './httpResponse';
 /** Parse JSON body from request. Returns parsed object or 400 Response on invalid JSON.
  *  Empty/missing body returns {} for backward compatibility with optional-body routes. */
 export async function parseJsonBody(req, cors) {
@@ -45,7 +34,7 @@ export function corsResponse(corsOrigins) {
     });
 }
 /** Health check endpoint */
-export function healthEndpoint(queueManager, wsCount, sseCount) {
+export function healthEndpoint(queueManager, wsCount, sseCount, tcpCount = 0) {
     const stats = queueManager.getStats();
     const uptime = process.uptime();
     const memoryUsage = process.memoryUsage();
@@ -64,7 +53,7 @@ export function healthEndpoint(queueManager, wsCount, sseCount) {
             dlq: stats.dlq,
         },
         connections: {
-            tcp: 0,
+            tcp: tcpCount,
             ws: wsCount,
             sse: sseCount,
         },
@@ -80,7 +69,17 @@ export function healthEndpoint(queueManager, wsCount, sseCount) {
                 since: storageStatus.since,
             },
         }),
-    });
+    }, isHealthy ? 200 : 503);
+}
+/** Readiness check - persistence failures must stop new traffic. */
+export function readinessEndpoint(queueManager, corsOrigins) {
+    const storage = queueManager.getStorageStatus();
+    const ready = !storage.diskFull;
+    return jsonResponse({
+        ok: ready,
+        ready,
+        ...(ready ? {} : { storage: { diskFull: true, error: storage.error, since: storage.since } }),
+    }, ready ? 200 : 503, corsOrigins);
 }
 /** GC endpoint - force garbage collection */
 export function gcEndpoint(queueManager) {
@@ -165,149 +164,6 @@ export function statsEndpoint(queueManager, corsOrigins) {
         collections: memStats,
     }, 200, corsOrigins);
 }
-/** Dashboard overview endpoint - aggregates all dashboard data in a single call */
-export function dashboardOverviewEndpoint(queueManager, corsOrigins) {
-    const stats = queueManager.getStats();
-    const rates = throughputTracker.getRates();
-    const latencies = latencyTracker.getPercentiles();
-    const avgLatencies = latencyTracker.getAverages();
-    const memStats = queueManager.getMemoryStats();
-    const workers = queueManager.workerManager.list();
-    const workerStats = queueManager.workerManager.getStats();
-    const crons = queueManager.listCrons();
-    const storage = queueManager.getStorageStatus();
-    const mem = process.memoryUsage();
-    return jsonResponse({
-        ok: true,
-        stats: {
-            waiting: stats.waiting,
-            active: stats.active,
-            delayed: stats.delayed,
-            completed: stats.completed,
-            dlq: stats.dlq,
-            totalPushed: Number(stats.totalPushed),
-            totalPulled: Number(stats.totalPulled),
-            totalCompleted: Number(stats.totalCompleted),
-            totalFailed: Number(stats.totalFailed),
-            uptime: stats.uptime,
-        },
-        throughput: rates,
-        latency: {
-            averages: avgLatencies,
-            percentiles: latencies,
-        },
-        memory: {
-            heapUsed: Math.round(mem.heapUsed / 1024 / 1024),
-            heapTotal: Math.round(mem.heapTotal / 1024 / 1024),
-            rss: Math.round(mem.rss / 1024 / 1024),
-        },
-        collections: memStats,
-        workers: {
-            total: workerStats.total,
-            active: workerStats.active,
-            list: workers
-                .slice(0, 100)
-                .map((w) => ({
-                id: w.id,
-                name: w.name,
-                queues: w.queues,
-                lastSeen: w.lastSeen,
-                activeJobs: w.activeJobs,
-                processedJobs: w.processedJobs,
-                failedJobs: w.failedJobs,
-            })),
-            truncated: workers.length > 100,
-        },
-        crons: {
-            total: crons.length,
-            list: crons
-                .slice(0, 100)
-                .map((c) => ({
-                name: c.name,
-                queue: c.queue,
-                schedule: c.schedule ?? null,
-                repeatEvery: c.repeatEvery ?? null,
-                nextRun: c.nextRun,
-                executions: c.executions,
-            })),
-            truncated: crons.length > 100,
-        },
-        storage,
-        timestamp: Date.now(),
-    }, 200, corsOrigins);
-}
-/** Dashboard queues endpoint - paginated queues with per-queue stats */
-export function dashboardQueuesEndpoint(queueManager, limit, offset, corsOrigins) {
-    const allQueues = queueManager.listQueues();
-    const total = allQueues.length;
-    const queueNames = allQueues.slice(offset, offset + limit);
-    const perQueueStats = queueManager.getPerQueueStats();
-    const queues = queueNames.map((name) => {
-        const stats = perQueueStats.get(name);
-        return {
-            name,
-            waiting: stats?.waiting ?? 0,
-            delayed: stats?.delayed ?? 0,
-            active: stats?.active ?? 0,
-            dlq: stats?.dlq ?? 0,
-            paused: queueManager.isPaused(name),
-        };
-    });
-    return jsonResponse({ ok: true, queues, total, limit, offset, timestamp: Date.now() }, 200, corsOrigins);
-}
-/** Dashboard single queue detail endpoint */
-export function dashboardQueueDetailEndpoint(queueManager, queue, includeJobs, corsOrigins) {
-    const rawCounts = queueManager.getQueueJobCounts(queue);
-    const paused = queueManager.isPaused(queue);
-    // Keep counts consistent with the per-state lists below (#92): a paused queue
-    // reports ready jobs under `paused`, not `waiting`/`prioritized`.
-    const pv = pausedView(rawCounts.waiting, rawCounts.prioritized, paused);
-    const counts = {
-        ...rawCounts,
-        waiting: pv.waiting,
-        prioritized: pv.prioritized,
-        paused: pv.paused,
-    };
-    const dlqJobs = queueManager.getDlq(queue, 10);
-    const priorityCounts = queueManager.getCountsPerPriority(queue);
-    const result = {
-        ok: true,
-        name: queue,
-        counts,
-        paused,
-        priorityCounts,
-        dlqPreview: dlqJobs.map((j) => ({
-            id: j.id,
-            data: j.data,
-            attempts: j.attempts,
-            createdAt: j.createdAt,
-        })),
-        timestamp: Date.now(),
-    };
-    if (includeJobs) {
-        // When paused, ready jobs surface under `paused` (waiting is empty) — match
-        // the counts above (#92).
-        const waiting = queueManager.getJobs(queue, { state: 'waiting', end: 10 });
-        const active = queueManager.getJobs(queue, { state: 'active', end: 10 });
-        const delayed = queueManager.getJobs(queue, { state: 'delayed', end: 10 });
-        const pausedJobs = paused ? queueManager.getJobs(queue, { state: 'paused', end: 10 }) : [];
-        const toSummary = (j) => ({
-            id: j.id,
-            priority: j.priority,
-            createdAt: j.createdAt,
-            runAt: j.runAt,
-            attempts: j.attempts,
-            progress: j.progress,
-        });
-        result.jobs = {
-            waiting: waiting.map(toSummary),
-            active: active.map(toSummary),
-            delayed: delayed.map(toSummary),
-            paused: pausedJobs.map(toSummary),
-        };
-    }
-    return jsonResponse(result, 200, corsOrigins);
-}
 /** Metrics endpoint */
 export function metricsEndpoint(queueManager, corsOrigins) {
     const stats = queueManager.getStats();

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

@@ -0,0 +1,2 @@
+/** Build a JSON response with optional CORS headers. */
+export declare function jsonResponse(data: unknown, status?: number, corsOrigins?: Set<string>): Response;

package/dist/infrastructure/server/httpResponse.js

@@ -0,0 +1,12 @@
+/** Build a JSON response with optional CORS headers. */
+export function jsonResponse(data, status = 200, corsOrigins) {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (corsOrigins) {
+        headers['Access-Control-Allow-Origin'] = corsOrigins.has('*')
+            ? '*'
+            : Array.from(corsOrigins).join(', ');
+    }
+    return new Response(JSON.stringify(data), { status, headers });
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Authenticated HTTP route dispatcher.
+ */
+import type { HandlerContext } from './types';
+/** Route an authenticated HTTP request to its handler. */
+export declare function routeHttpRequest(req: Request, path: string, ctx: HandlerContext, corsOrigins: Set<string>): Promise<Response>;

package/dist/infrastructure/server/httpRouter.js

@@ -0,0 +1,50 @@
+/**
+ * Authenticated HTTP route dispatcher.
+ */
+import { validateQueueName } from './protocol';
+import { dashboardOverviewEndpoint, dashboardQueueDetailEndpoint, dashboardQueuesEndpoint, jsonResponse, metricsEndpoint, statsEndpoint, } from './httpEndpoints';
+import { routeJobRoutes } from './httpRouteJobs';
+import { routeQueueConfigRoutes } from './httpRouteQueueConfig';
+import { routeQueueRoutes } from './httpRouteQueues';
+import { routeResourceRoutes } from './httpRouteResources';
+const RE_DASHBOARD_QUEUE_DETAIL = /^\/dashboard\/queues\/([^/]+)$/;
+/** Route an authenticated HTTP request to its handler. */
+export async function routeHttpRequest(req, path, ctx, corsOrigins) {
+    const method = req.method;
+    if (path === '/stats' && method === 'GET') {
+        return statsEndpoint(ctx.queueManager, corsOrigins);
+    }
+    if (path === '/metrics' && method === 'GET') {
+        return metricsEndpoint(ctx.queueManager, corsOrigins);
+    }
+    if (path === '/dashboard' && method === 'GET') {
+        return dashboardOverviewEndpoint(ctx.queueManager, corsOrigins);
+    }
+    if (path === '/dashboard/queues' && method === 'GET') {
+        const url = new URL(req.url);
+        const limit = Math.min(Math.max(parseInt(url.searchParams.get('limit') ?? '100', 10) || 100, 1), 500);
+        const offset = Math.max(parseInt(url.searchParams.get('offset') ?? '0', 10) || 0, 0);
+        return dashboardQueuesEndpoint(ctx.queueManager, limit, offset, corsOrigins);
+    }
+    const queueMatch = path.match(RE_DASHBOARD_QUEUE_DETAIL);
+    if (queueMatch && method === 'GET') {
+        const queue = decodeURIComponent(queueMatch[1]);
+        const queueError = validateQueueName(queue);
+        if (queueError)
+            return jsonResponse({ ok: false, error: queueError }, 400, corsOrigins);
+        const includeJobs = new URL(req.url).searchParams.get('includeJobs') === 'true';
+        return dashboardQueueDetailEndpoint(ctx.queueManager, queue, includeJobs, corsOrigins);
+    }
+    const routers = [
+        routeJobRoutes,
+        routeQueueRoutes,
+        routeQueueConfigRoutes,
+        routeResourceRoutes,
+    ];
+    for (const router of routers) {
+        const result = await router(req, path, method, ctx, corsOrigins);
+        if (result)
+            return result;
+    }
+    return jsonResponse({ ok: false, error: 'Not found' }, 404, corsOrigins);
+}