bunqueue 2.8.23 → 2.8.24

package/dist/application/cleanupTasks.js

@@ -204,9 +204,11 @@ function cleanEmptyQueues(ctx) {
         const shard = ctx.shards[i];
         const emptyQueues = [];
         for (const [queueName, queue] of shard.queues) {
-            const dlqEntries = shard.dlq.get(queueName);
+            // `shard.dlq` is a getter that rebuilds a Map of EVERY queue's DLQ entries
+            // on each access — calling it once per queue in this loop was O(Q²) per
+            // shard per tick. getDlqCount(queueName) is an O(1) counter lookup.
             if (queue.size === 0 &&
-                (!dlqEntries || dlqEntries.length === 0) &&
+                shard.getDlqCount(queueName) === 0 &&
                 !hasProcessingJobsForQueue(ctx, queueName) &&
                 !hasWaitingDepsForQueue(ctx, queueName)) {
                 emptyQueues.push(queueName);

package/dist/client/tcp/connection.js

@@ -41,7 +41,10 @@ export async function createConnection(target, connectTimeout, events) {
             data(_sock, data) {
                 let frames;
                 try {
-                    frames = socketData.frameParser.addData(new Uint8Array(data));
+                    // `data` (Bun Buffer) is copied into addData's own buffer synchronously
+                    // and never retained, so the `new Uint8Array(data)` wrapper was a
+                    // redundant full copy per read on the client response path.
+                    frames = socketData.frameParser.addData(data);
                 }
                 catch (err) {
                     if (err instanceof FrameSizeError) {

package/dist/infrastructure/server/protocol.js

@@ -160,19 +160,25 @@ export class FrameParser {
      * @throws {FrameSizeError} if frame length exceeds maxFrameSize
      */
     addData(data) {
-        // Concatenate buffers
-        const newBuffer = new Uint8Array(this.buffer.length + data.length);
-        newBuffer.set(this.buffer);
-        newBuffer.set(data, this.buffer.length);
-        this.buffer = newBuffer;
+        // Concatenate any buffered partial frame with the new data into a single
+        // owned buffer (one copy). `data` is fully copied here and never retained,
+        // so the caller may safely reuse its read buffer after this returns.
+        const buffer = new Uint8Array(this.buffer.length + data.length);
+        buffer.set(this.buffer);
+        buffer.set(data, this.buffer.length);
         const frames = [];
-        while (this.buffer.length >= 4) {
+        // Read cursor. Previously the tail was resliced with `buffer.slice(4 + len)`
+        // after EVERY frame — O(tail) per frame, i.e. O(F²) when F frames arrive
+        // coalesced in a single read (deep pipelining / OS segment coalescing). The
+        // cursor advances in O(1) per frame, making the whole pass O(total bytes).
+        let offset = 0;
+        while (buffer.length - offset >= 4) {
             // Read length prefix (big-endian u32) using unsigned right shift to ensure positive value
             // Using >>> 0 at the end converts the result to an unsigned 32-bit integer
-            const length = ((this.buffer[0] << 24) |
-                (this.buffer[1] << 16) |
-                (this.buffer[2] << 8) |
-                this.buffer[3]) >>>
+            const length = ((buffer[offset] << 24) |
+                (buffer[offset + 1] << 16) |
+                (buffer[offset + 2] << 8) |
+                buffer[offset + 3]) >>>
                 0;
             // Validate frame size to prevent memory exhaustion DoS. A single frame's
             // declared length can never exceed maxFrameSize (64MB), so the partial
@@ -185,15 +191,30 @@ export class FrameParser {
                 this.buffer = new Uint8Array(0);
                 throw new FrameSizeError(length, this.maxFrameSize);
             }
-            if (this.buffer.length < 4 + length) {
+            if (buffer.length - offset < 4 + length) {
                 // Not enough data for this (legal, < maxFrameSize) frame yet. Keep the
                 // partial bytes buffered until the rest of the frame arrives across
                 // subsequent TCP segments.
                 break;
             }
-            // Extract frame
-            frames.push(this.buffer.slice(4, 4 + length));
-            this.buffer = this.buffer.slice(4 + length);
+            // Extract frame. The body is copied out (slice) so it never aliases the
+            // retained tail buffer.
+            frames.push(buffer.slice(offset + 4, offset + 4 + length));
+            offset += 4 + length;
+        }
+        // Retain only the unconsumed tail. Three cases mirror the previous behavior
+        // without the per-frame reslice:
+        //  - fully drained: a fresh empty buffer (do not pin the read's ArrayBuffer)
+        //  - nothing consumed: keep the concat buffer as-is (no extra copy)
+        //  - partial leftover after ≥1 frame: copy the small tail (no aliasing)
+        if (offset >= buffer.length) {
+            this.buffer = new Uint8Array(0);
+        }
+        else if (offset === 0) {
+            this.buffer = buffer;
+        }
+        else {
+            this.buffer = buffer.slice(offset);
         }
         return frames;
     }

package/dist/infrastructure/server/tcp.js

@@ -135,7 +135,10 @@ export function createTcpServer(queueManager, config) {
             }
             let frames;
             try {
-                frames = frameParser.addData(new Uint8Array(data));
+                // `data` is a Bun Buffer (a Uint8Array). addData copies it into its own
+                // buffer synchronously and never retains it, so the previous defensive
+                // `new Uint8Array(data)` wrapper was a redundant full copy per read.
+                frames = frameParser.addData(data);
             }
             catch (err) {
                 if (err instanceof FrameSizeError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunqueue",
-  "version": "2.8.23",
+  "version": "2.8.24",
   "description": "High-performance job queue for Bun & AI agents. SQLite persistence, cron scheduling, priorities, retries, DLQ, webhooks, native MCP server. Zero external dependencies.",
   "type": "module",
   "main": "dist/main.js",

package/dist/main 2.js

@@ -1,250 +0,0 @@
-#!/usr/bin/env bun
-/**
- * bunqueue - High-performance job queue server for Bun
- * Main entry point - routes to CLI for client commands or starts server
- */
-// Only run startup dispatch when this file is the program entry point.
-// Issue #85: re-exporting `defineConfig` means user config files import this
-// module; without this guard, the top-level dispatch would re-run the CLI/server
-// on every import and cause "Failed to listen at 0.0.0.0".
-if (import.meta.main) {
-    const clientCommands = [
-        'push',
-        'pull',
-        'ack',
-        'fail',
-        'job',
-        'queue',
-        'dlq',
-        'cron',
-        'worker',
-        'webhook',
-        'rate-limit',
-        'concurrency',
-        'stats',
-        'metrics',
-        'health',
-        'backup',
-    ];
-    const firstArg = process.argv[2];
-    const isClientCommand = firstArg && clientCommands.includes(firstArg);
-    const isStartCommand = firstArg === 'start';
-    const hasHelpOrVersion = process.argv.includes('--help') || process.argv.includes('--version');
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- process.argv[2] can be undefined at runtime
-    const hasFlags = firstArg?.startsWith('-');
-    if (isClientCommand || hasHelpOrVersion || isStartCommand || hasFlags) {
-        void import('./cli/index').then(({ main }) => main());
-    }
-    else {
-        void startServer();
-    }
-}
-import { QueueManager } from './application/queueManager';
-import { createTcpServer } from './infrastructure/server/tcp';
-import { createHttpServer } from './infrastructure/server/http';
-import { Logger, serverLog, statsLog } from './shared/logger';
-import { stopRateLimiter } from './infrastructure/server/rateLimiter';
-import { VERSION } from './shared/version';
-import { S3BackupManager } from './infrastructure/backup';
-import { CloudAgent } from './infrastructure/cloud';
-import { SHARD_COUNT } from './shared/hash';
-import { loadConfigFile, resolveServerConfig, resolveCloudConfig, resolveBackupConfig, } from './config';
-export { defineConfig } from './config';
-/** Print startup banner */
-function printBanner(config, cloudUrl) {
-    const dim = '\x1b[2m';
-    const reset = '\x1b[0m';
-    const bold = '\x1b[1m';
-    const magenta = '\x1b[35m';
-    const green = '\x1b[32m';
-    const yellow = '\x1b[33m';
-    // Format TCP endpoint display
-    const tcpDisplay = config.tcpSocketPath
-        ? `${bold}${config.tcpSocketPath}${reset} ${dim}(unix)${reset}`
-        : `${bold}${config.hostname}:${config.tcpPort}${reset}`;
-    // Format HTTP endpoint display
-    const httpDisplay = config.httpSocketPath
-        ? `${bold}${config.httpSocketPath}${reset} ${dim}(unix)${reset}`
-        : `${bold}${config.hostname}:${config.httpPort}${reset}`;
-    // Socket mode display
-    const hasUnixSockets = config.tcpSocketPath !== undefined || config.httpSocketPath !== undefined;
-    const socketDisplay = hasUnixSockets
-        ? `${green}enabled${reset} ${dim}(${config.tcpSocketPath ? 'TCP' : ''}${config.tcpSocketPath && config.httpSocketPath ? '+' : ''}${config.httpSocketPath ? 'HTTP' : ''})${reset}`
-        : `${dim}disabled${reset}`;
-    console.log(`
-${magenta}        (\\(\\        ${reset}
-${magenta}        ( -.-)      ${bold}bunqueue${reset} ${dim}v${VERSION}${reset}
-${magenta}        o_(")(")    ${reset}${dim}High-performance job queue for Bun${reset}
-
-${dim}─────────────────────────────────────────────────${reset}
-
-  ${green}●${reset} TCP    ${tcpDisplay}
-  ${green}●${reset} HTTP   ${httpDisplay}
-  ${yellow}●${reset} Socket ${socketDisplay}
-  ${yellow}●${reset} Data   ${config.dataPath ?? 'in-memory'}
-  ${yellow}●${reset} Auth   ${config.authTokens.length > 0 ? `${green}enabled${reset}` : `${dim}disabled${reset}`}
-  ${yellow}●${reset} S3 Backup ${config.s3BackupEnabled ? `${green}enabled${reset}` : `${dim}disabled${reset}`}
-  ${yellow}●${reset} Cloud  ${cloudUrl ? `${green}enabled${reset} ${dim}→ ${cloudUrl}${reset}` : `${dim}disabled${reset}`}
-  ${dim}●${reset} Shards ${bold}${SHARD_COUNT}${reset} ${dim}(${navigator.hardwareConcurrency} CPU cores)${reset}
-
-${dim}─────────────────────────────────────────────────${reset}
-
-`);
-}
-/** Start the server (direct mode) */
-async function startServer() {
-    // Load config file (bunqueue.config.ts) if present, then merge with env vars
-    const fileConfig = await loadConfigFile();
-    const config = resolveServerConfig(fileConfig);
-    // Apply logging config before anything else
-    const logFormat = fileConfig?.logging?.format ?? Bun.env.LOG_FORMAT;
-    const logLevel = fileConfig?.logging?.level ?? Bun.env.LOG_LEVEL?.toLowerCase();
-    if (logFormat === 'json')
-        Logger.enableJsonMode();
-    if (logLevel) {
-        const validLevels = ['debug', 'info', 'warn', 'error'];
-        if (validLevels.includes(logLevel))
-            Logger.setLevel(logLevel);
-    }
-    // Resolve cloud config
-    const cloudConfig = resolveCloudConfig(fileConfig, config.dataPath);
-    printBanner(config, cloudConfig?.url);
-    // Create queue manager
-    const queueManager = new QueueManager({
-        dataPath: config.dataPath,
-    });
-    // Start TCP server
-    const tcpServer = createTcpServer(queueManager, {
-        port: config.tcpPort,
-        hostname: config.hostname,
-        authTokens: config.authTokens,
-    });
-    // Start HTTP server
-    const httpServer = createHttpServer(queueManager, {
-        port: config.httpPort,
-        hostname: config.hostname,
-        authTokens: config.authTokens,
-        corsOrigins: config.corsOrigins,
-        requireAuthForMetrics: config.requireAuthForMetrics,
-    });
-    // Initialize S3 backup manager
-    let backupManager = null;
-    if (config.dataPath) {
-        const backupConfig = resolveBackupConfig(fileConfig, config.dataPath);
-        backupManager = new S3BackupManager(backupConfig);
-        backupManager.setDashboardEmit(queueManager.emitDashboardEvent.bind(queueManager));
-        backupManager.start();
-    }
-    // Initialize bunqueue Cloud agent (remote dashboard telemetry)
-    const cloudAgent = cloudConfig ? CloudAgent.createFromConfig(queueManager, cloudConfig) : null;
-    if (cloudAgent) {
-        cloudAgent.setServerHandles({
-            getConnectionCount: () => tcpServer.getConnectionCount(),
-            getWsClientCount: () => httpServer.getWsClientCount(),
-            getSseClientCount: () => httpServer.getSseClientCount(),
-            getBackupStatus: () => backupManager?.getStatus() ?? null,
-        });
-    }
-    queueManager.emitDashboardEvent('server:started', {
-        tcpPort: config.tcpPort,
-        httpPort: config.httpPort,
-        shards: SHARD_COUNT,
-    });
-    // Graceful shutdown
-    let shuttingDown = false;
-    const shutdown = async (signal) => {
-        if (shuttingDown)
-            return;
-        shuttingDown = true;
-        serverLog.info(`Received ${signal}, shutting down...`);
-        // Stop stats interval immediately
-        clearInterval(statsInterval);
-        tcpServer.stop();
-        httpServer.stop();
-        const shutdownTimeout = config.shutdownTimeoutMs;
-        const start = Date.now();
-        while (Date.now() - start < shutdownTimeout) {
-            const stats = queueManager.getStats();
-            if (stats.active === 0)
-                break;
-            serverLog.info(`Waiting for ${stats.active} active jobs...`);
-            await Bun.sleep(1000);
-        }
-        // Stop backup manager
-        if (backupManager) {
-            backupManager.stop();
-        }
-        // Stop Cloud agent (sends final shutdown snapshot)
-        if (cloudAgent) {
-            await cloudAgent.stop();
-        }
-        queueManager.emitDashboardEvent('server:shutdown', { signal });
-        queueManager.shutdown();
-        stopRateLimiter();
-        serverLog.info('Shutdown complete');
-        process.exit(0);
-    };
-    process.on('SIGINT', () => void shutdown('SIGINT'));
-    process.on('SIGTERM', () => void shutdown('SIGTERM'));
-    process.on('uncaughtException', (err) => {
-        serverLog.error('Uncaught exception - initiating shutdown', {
-            error: err.message,
-            stack: err.stack,
-        });
-        void shutdown('uncaughtException');
-    });
-    process.on('unhandledRejection', (reason) => {
-        serverLog.error('Unhandled promise rejection - initiating shutdown', {
-            reason: reason instanceof Error ? reason.message : String(reason),
-            stack: reason instanceof Error ? reason.stack : undefined,
-        });
-        void shutdown('unhandledRejection');
-    });
-    // Print stats periodically
-    const statsInterval = setInterval(() => {
-        const stats = queueManager.getStats();
-        const memStats = queueManager.getMemoryStats();
-        const workerStats = queueManager.workerManager.getStats();
-        const mem = process.memoryUsage();
-        const now = new Date();
-        const timestamp = now.toLocaleTimeString('en-GB', {
-            hour: '2-digit',
-            minute: '2-digit',
-            second: '2-digit',
-        });
-        statsLog.info('Queue statistics', {
-            time: timestamp,
-            waiting: stats.waiting,
-            active: stats.active,
-            delayed: stats.delayed,
-            completed: stats.completed,
-            dlq: stats.dlq,
-            tcp: tcpServer.getConnectionCount(),
-            ws: httpServer.getWsClientCount(),
-            sse: httpServer.getSseClientCount(),
-            workers: `${workerStats.active}/${workerStats.total}`,
-            mem: `${Math.round(mem.heapUsed / 1024 / 1024)}MB/${Math.round(mem.heapTotal / 1024 / 1024)}MB`,
-            rss: `${Math.round(mem.rss / 1024 / 1024)}MB`,
-            // Internal collection sizes (for memory debugging)
-            idx: memStats.jobIndex,
-            locks: memStats.jobLocks,
-            clients: memStats.clientJobsTotal,
-        });
-    }, config.statsIntervalMs);
-}
-// Logger env-var bootstrap only applies when this file is the entry point.
-// Imported consumers (e.g. user config files using `defineConfig`) must not
-// have their process Logger state mutated as a side effect — see Issue #85.
-if (import.meta.main) {
-    if (Bun.env.LOG_FORMAT === 'json') {
-        Logger.enableJsonMode();
-    }
-    if (Bun.env.LOG_LEVEL) {
-        const validLevels = ['debug', 'info', 'warn', 'error'];
-        const level = Bun.env.LOG_LEVEL.toLowerCase();
-        if (validLevels.includes(level)) {
-            Logger.setLevel(level);
-        }
-    }
-}
-//# sourceMappingURL=main.js.map