bunqueue 2.8.38 → 2.8.40

package/dist/domain/queue/waiterManager.js

@@ -17,10 +17,17 @@ export class WaiterManager {
             return;
         this.notifyQueue(queue, count);
     }
-    waitForJob(queueOrTimeout, maybeTimeout) {
+    waitForJob(queueOrTimeout, maybeTimeoutOrSignal, maybeSignal) {
         const queue = typeof queueOrTimeout === 'string' ? queueOrTimeout : DEFAULT_QUEUE;
-        const timeoutMs = typeof queueOrTimeout === 'number' ? queueOrTimeout : (maybeTimeout ?? 0);
-        if (timeoutMs <= 0)
+        const timeoutMs = typeof queueOrTimeout === 'number'
+            ? queueOrTimeout
+            : typeof maybeTimeoutOrSignal === 'number'
+                ? maybeTimeoutOrSignal
+                : 0;
+        const signal = typeof queueOrTimeout === 'number'
+            ? maybeTimeoutOrSignal
+            : maybeSignal;
+        if (timeoutMs <= 0 || signal?.aborted)
             return Promise.resolve();
         const state = this.queues.get(queue);
         if (state?.pending) {
@@ -34,19 +41,30 @@ export class WaiterManager {
                 resolve,
                 cancelled: false,
                 timer: undefined,
+                signal,
+                onAbort: undefined,
             };
-            waiter.timer = setTimeout(() => {
+            const settle = () => {
                 if (waiter.cancelled)
                     return;
                 waiter.cancelled = true;
+                clearTimeout(waiter.timer);
+                if (waiter.signal && waiter.onAbort) {
+                    waiter.signal.removeEventListener('abort', waiter.onAbort);
+                }
                 queueState.active--;
                 this.activeWaiters--;
                 resolve();
                 this.compact(queue, queueState);
-            }, timeoutMs);
+            };
+            waiter.timer = setTimeout(settle, timeoutMs);
+            waiter.onAbort = settle;
+            signal?.addEventListener('abort', settle, { once: true });
             queueState.entries.push(waiter);
             queueState.active++;
             this.activeWaiters++;
+            if (signal?.aborted)
+                settle();
         });
     }
     notifyQueue(queue, count) {
@@ -62,6 +80,9 @@ export class WaiterManager {
                 continue;
             waiter.cancelled = true;
             clearTimeout(waiter.timer);
+            if (waiter.signal && waiter.onAbort) {
+                waiter.signal.removeEventListener('abort', waiter.onAbort);
+            }
             state.active--;
             this.activeWaiters--;
             remaining--;

package/dist/infrastructure/cloud/wsSender.js

@@ -8,8 +8,8 @@
  * - Commands only: all data goes via HTTP, WS is for remote commands
  * - Keepalive: server sends ping every 25s, bunqueue responds pong
  */
-import { pack, unpack } from 'msgpackr';
 import { cloudLog } from './logger';
+import { decodeMessagePack, encodeMessagePack } from '../../shared/msgpack';
 export class WsSender {
     config;
     instanceId;
@@ -124,7 +124,7 @@ export class WsSender {
     }
     /** Encode and send as zstd(msgpack) binary frame */
     async sendBinary(ws, data) {
-        ws.send(await Bun.zstdCompress(pack(data)));
+        ws.send(await Bun.zstdCompress(encodeMessagePack(data)));
     }
     /** Decode incoming message — supports zstd+msgpack, plain msgpack, and JSON (text) */
     decodeMessage(data) {
@@ -146,9 +146,9 @@ export class WsSender {
             buf[1] === 0xb5 &&
             buf[2] === 0x2f &&
             buf[3] === 0xfd) {
-            return unpack(Buffer.from(await Bun.zstdDecompress(buf)));
+            return decodeMessagePack(Buffer.from(await Bun.zstdDecompress(buf)));
         }
-        return unpack(buf);
+        return decodeMessagePack(buf);
     }
     /** Clean up socket handlers and close */
     cleanup() {

package/dist/infrastructure/persistence/schema.d.ts

@@ -4,10 +4,10 @@
 /** SQLite PRAGMA settings for optimal performance */
 export declare const PRAGMA_SETTINGS = "\nPRAGMA journal_mode = WAL;\nPRAGMA synchronous = NORMAL;\nPRAGMA cache_size = -64000;\nPRAGMA temp_store = MEMORY;\nPRAGMA mmap_size = 268435456;\nPRAGMA page_size = 4096;\nPRAGMA busy_timeout = 5000;\n";
 /** Main schema creation */
-export declare const SCHEMA = "\n-- Jobs table (using UUIDv7 for job IDs)\n-- Uses BLOB for data fields (MessagePack serialization for ~2-3x faster than JSON)\nCREATE TABLE IF NOT EXISTS jobs (\n    id TEXT PRIMARY KEY,\n    queue TEXT NOT NULL,\n    data BLOB NOT NULL,\n    priority INTEGER NOT NULL DEFAULT 0,\n    created_at INTEGER NOT NULL,\n    run_at INTEGER NOT NULL,\n    started_at INTEGER,\n    completed_at INTEGER,\n    attempts INTEGER NOT NULL DEFAULT 0,\n    max_attempts INTEGER NOT NULL DEFAULT 3,\n    backoff INTEGER NOT NULL DEFAULT 1000,\n    ttl INTEGER,\n    timeout INTEGER,\n    unique_key TEXT,\n    custom_id TEXT,\n    depends_on BLOB,\n    parent_id TEXT,\n    children_ids BLOB,\n    tags BLOB,\n    state TEXT NOT NULL DEFAULT 'waiting',\n    lifo INTEGER NOT NULL DEFAULT 0,\n    group_id TEXT,\n    progress INTEGER DEFAULT 0,\n    progress_msg TEXT,\n    remove_on_complete INTEGER DEFAULT 0,\n    remove_on_fail INTEGER DEFAULT 0,\n    stall_timeout INTEGER,\n    last_heartbeat INTEGER,\n    stall_count INTEGER NOT NULL DEFAULT 0,\n    timeline BLOB,\n    stacktrace BLOB\n);\n\n-- Indexes for common queries\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_state\n    ON jobs(queue, state);\n-- Stable createdAt/id pagination for unfiltered and logical-state queue views\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_created\n    ON jobs(queue, created_at, id);\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_state_created\n    ON jobs(queue, state, created_at, id);\nCREATE INDEX IF NOT EXISTS idx_jobs_run_at\n    ON jobs(run_at) WHERE state IN ('waiting', 'delayed');\nCREATE INDEX IF NOT EXISTS idx_jobs_unique\n    ON jobs(queue, unique_key) WHERE unique_key IS NOT NULL;\nCREATE INDEX IF NOT EXISTS idx_jobs_custom_id\n    ON jobs(custom_id) WHERE custom_id IS NOT NULL;\nCREATE INDEX IF NOT EXISTS idx_jobs_parent\n    ON jobs(parent_id) WHERE parent_id IS NOT NULL;\n\n-- Job results storage (BLOB for MessagePack)\nCREATE TABLE IF NOT EXISTS job_results (\n    job_id TEXT PRIMARY KEY,\n    result BLOB,\n    completed_at INTEGER NOT NULL\n);\n\n-- Dead letter queue (BLOB for MessagePack - stores full DlqEntry)\nCREATE TABLE IF NOT EXISTS dlq (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    job_id TEXT NOT NULL,\n    queue TEXT NOT NULL,\n    entry BLOB NOT NULL,\n    entered_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_dlq_queue ON dlq(queue);\nCREATE INDEX IF NOT EXISTS idx_dlq_job_id ON dlq(job_id);\nCREATE INDEX IF NOT EXISTS idx_dlq_entered_at ON dlq(entered_at);\n\n-- Performance indexes for high-throughput operations\n-- Stall detection: runs every 5s, needs fast lookup of active jobs by started_at\nCREATE INDEX IF NOT EXISTS idx_jobs_state_started\n    ON jobs(state, started_at) WHERE state = 'active';\n\n-- Group operations: fast lookup by group_id\nCREATE INDEX IF NOT EXISTS idx_jobs_group_id\n    ON jobs(group_id) WHERE group_id IS NOT NULL;\n\n-- Pending jobs: compound index for priority-ordered retrieval\nCREATE INDEX IF NOT EXISTS idx_jobs_pending_priority\n    ON jobs(queue, state, priority DESC, run_at ASC) WHERE state IN ('waiting', 'delayed');\n\n-- Completed jobs: index for recovery ordering (issue #84)\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_order\n    ON jobs(completed_at DESC) WHERE state = 'completed';\n\n-- Cron jobs (BLOB for MessagePack)\nCREATE TABLE IF NOT EXISTS cron_jobs (\n    name TEXT PRIMARY KEY,\n    queue TEXT NOT NULL,\n    data BLOB NOT NULL,\n    schedule TEXT,\n    repeat_every INTEGER,\n    priority INTEGER NOT NULL DEFAULT 0,\n    next_run INTEGER NOT NULL,\n    executions INTEGER NOT NULL DEFAULT 0,\n    max_limit INTEGER,\n    timezone TEXT,\n    unique_key TEXT,\n    dedup BLOB,\n    skip_missed_on_restart INTEGER NOT NULL DEFAULT 0,\n    skip_if_no_worker INTEGER NOT NULL DEFAULT 0,\n    prevent_overlap INTEGER NOT NULL DEFAULT 1,\n    job_options BLOB\n);\n\n-- Queue state persistence (optional)\nCREATE TABLE IF NOT EXISTS queue_state (\n    name TEXT PRIMARY KEY,\n    paused INTEGER NOT NULL DEFAULT 0,\n    rate_limit INTEGER,\n    concurrency_limit INTEGER,\n    rate_limit_duration INTEGER,\n    rate_limit_expires_at INTEGER,\n    stall_enabled INTEGER,\n    stall_interval INTEGER,\n    max_stalls INTEGER,\n    stall_grace_period INTEGER\n);\n";
+export declare const SCHEMA = "\n-- Jobs table (using UUIDv7 for job IDs)\n-- Uses BLOB for data fields (MessagePack serialization for ~2-3x faster than JSON)\nCREATE TABLE IF NOT EXISTS jobs (\n    id TEXT PRIMARY KEY,\n    queue TEXT NOT NULL,\n    data BLOB NOT NULL,\n    priority INTEGER NOT NULL DEFAULT 0,\n    created_at INTEGER NOT NULL,\n    run_at INTEGER NOT NULL,\n    started_at INTEGER,\n    completed_at INTEGER,\n    attempts INTEGER NOT NULL DEFAULT 0,\n    max_attempts INTEGER NOT NULL DEFAULT 3,\n    backoff INTEGER NOT NULL DEFAULT 1000,\n    ttl INTEGER,\n    timeout INTEGER,\n    unique_key TEXT,\n    custom_id TEXT,\n    depends_on BLOB,\n    parent_id TEXT,\n    children_ids BLOB,\n    tags BLOB,\n    state TEXT NOT NULL DEFAULT 'waiting',\n    lifo INTEGER NOT NULL DEFAULT 0,\n    group_id TEXT,\n    progress INTEGER DEFAULT 0,\n    progress_msg TEXT,\n    remove_on_complete INTEGER DEFAULT 0,\n    remove_on_fail INTEGER DEFAULT 0,\n    stall_timeout INTEGER,\n    last_heartbeat INTEGER,\n    stall_count INTEGER NOT NULL DEFAULT 0,\n    timeline BLOB,\n    stacktrace BLOB\n);\n\n-- Indexes for common queries\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_state\n    ON jobs(queue, state);\n-- Stable createdAt/id pagination for unfiltered and logical-state queue views\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_created\n    ON jobs(queue, created_at, id);\nCREATE INDEX IF NOT EXISTS idx_jobs_queue_state_created\n    ON jobs(queue, state, created_at, id);\nCREATE INDEX IF NOT EXISTS idx_jobs_run_at\n    ON jobs(run_at) WHERE state IN ('waiting', 'delayed');\nCREATE INDEX IF NOT EXISTS idx_jobs_unique\n    ON jobs(queue, unique_key) WHERE unique_key IS NOT NULL;\nCREATE INDEX IF NOT EXISTS idx_jobs_custom_id\n    ON jobs(custom_id) WHERE custom_id IS NOT NULL;\nCREATE INDEX IF NOT EXISTS idx_jobs_parent\n    ON jobs(parent_id) WHERE parent_id IS NOT NULL;\n\n-- Job results storage (BLOB for MessagePack)\nCREATE TABLE IF NOT EXISTS job_results (\n    job_id TEXT PRIMARY KEY,\n    result BLOB,\n    completed_at INTEGER NOT NULL\n);\n\n-- Dead letter queue (BLOB for MessagePack - stores full DlqEntry)\nCREATE TABLE IF NOT EXISTS dlq (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    job_id TEXT NOT NULL,\n    queue TEXT NOT NULL,\n    entry BLOB NOT NULL,\n    entered_at INTEGER NOT NULL\n);\n\nCREATE INDEX IF NOT EXISTS idx_dlq_queue ON dlq(queue);\nCREATE INDEX IF NOT EXISTS idx_dlq_job_id ON dlq(job_id);\nCREATE INDEX IF NOT EXISTS idx_dlq_entered_at ON dlq(entered_at);\n\n-- Performance indexes for high-throughput operations\n-- Stall detection: runs every 5s, needs fast lookup of active jobs by started_at\nCREATE INDEX IF NOT EXISTS idx_jobs_state_started\n    ON jobs(state, started_at) WHERE state = 'active';\n\n-- Group operations: fast lookup by group_id\nCREATE INDEX IF NOT EXISTS idx_jobs_group_id\n    ON jobs(group_id) WHERE group_id IS NOT NULL;\n\n-- Pending jobs: compound index for priority-ordered retrieval\nCREATE INDEX IF NOT EXISTS idx_jobs_pending_priority\n    ON jobs(queue, state, priority DESC, run_at ASC) WHERE state IN ('waiting', 'delayed');\n\n-- Completed jobs: index for recovery ordering (issue #84)\nCREATE INDEX IF NOT EXISTS idx_jobs_completed_order\n    ON jobs(completed_at DESC) WHERE state = 'completed';\n\n-- Cron jobs (BLOB for MessagePack)\nCREATE TABLE IF NOT EXISTS cron_jobs (\n    name TEXT PRIMARY KEY,\n    queue TEXT NOT NULL,\n    data BLOB NOT NULL,\n    schedule TEXT,\n    repeat_every INTEGER,\n    priority INTEGER NOT NULL DEFAULT 0,\n    next_run INTEGER NOT NULL,\n    executions INTEGER NOT NULL DEFAULT 0,\n    max_limit INTEGER,\n    timezone TEXT,\n    unique_key TEXT,\n    dedup BLOB,\n    skip_missed_on_restart INTEGER NOT NULL DEFAULT 0,\n    skip_if_no_worker INTEGER NOT NULL DEFAULT 0,\n    prevent_overlap INTEGER NOT NULL DEFAULT 1,\n    job_options BLOB\n);\n\n-- Queue state persistence (optional)\nCREATE TABLE IF NOT EXISTS queue_state (\n    name TEXT PRIMARY KEY,\n    paused INTEGER NOT NULL DEFAULT 0,\n    rate_limit INTEGER,\n    concurrency_limit INTEGER,\n    rate_limit_duration INTEGER,\n    rate_limit_expires_at INTEGER,\n    stall_enabled INTEGER,\n    stall_interval INTEGER,\n    max_stalls INTEGER,\n    stall_grace_period INTEGER,\n    dlq_config BLOB\n);\n";
 /** Migration version table */
 export declare const MIGRATION_TABLE = "\nCREATE TABLE IF NOT EXISTS migrations (\n    version INTEGER PRIMARY KEY,\n    applied_at INTEGER NOT NULL\n);\n";
 /** Current schema version */
-export declare const SCHEMA_VERSION = 21;
+export declare const SCHEMA_VERSION = 22;
 /** All migrations in order */
 export declare const MIGRATIONS: Record<number, string>;

package/dist/infrastructure/persistence/schema.js

@@ -134,7 +134,8 @@ CREATE TABLE IF NOT EXISTS queue_state (
     stall_enabled INTEGER,
     stall_interval INTEGER,
     max_stalls INTEGER,
-    stall_grace_period INTEGER
+    stall_grace_period INTEGER,
+    dlq_config BLOB
 );
 `;
 /** Migration version table */
@@ -145,7 +146,7 @@ CREATE TABLE IF NOT EXISTS migrations (
 );
 `;
 /** Current schema version */
-export const SCHEMA_VERSION = 21;
+export const SCHEMA_VERSION = 22;
 /** All migrations in order */
 export const MIGRATIONS = {
     1: SCHEMA,
@@ -235,5 +236,9 @@ ALTER TABLE queue_state ADD COLUMN max_stalls INTEGER;
 `,
     21: `
 ALTER TABLE queue_state ADD COLUMN stall_grace_period INTEGER;
+`,
+    // Migration 22: Persist the complete per-queue DLQ policy atomically.
+    22: `
+ALTER TABLE queue_state ADD COLUMN dlq_config BLOB;
 `,
 };

package/dist/infrastructure/persistence/sqlite.d.ts

@@ -6,7 +6,7 @@
 import type { Job, JobId, JobTimelineEntry } from '../../domain/types/job';
 import type { StallConfig } from '../../domain/types/stall';
 import type { CronJob } from '../../domain/types/cron';
-import { type DlqEntry } from '../../domain/types/dlq';
+import { type DlqConfig, type DlqEntry } from '../../domain/types/dlq';
 /** Critical-loss callback: invoked when WriteBuffer drops jobs after exhausting retries. */
 export type SqliteCriticalLossCallback = (jobs: Job[], lastError: Error, attempts: number) => void;
 /** Record of a critical job loss event (jobs dropped after max retries). */
@@ -116,6 +116,8 @@ export declare class SqliteStorage {
     updateJobData(jobId: JobId, data: unknown): void;
     /** Persist priority ordering, including its LIFO tie-break, across recovery. */
     updateJobPriority(jobId: JobId, priority: number, lifo: boolean): void;
+    /** Persist progress and its heartbeat as one active-job mutation. */
+    updateJobProgress(jobId: JobId, progress: number, message: string | null, lastHeartbeat: number): void;
     /**
      * Persist a delay change (moveToDelayed / changeDelay) so the new `run_at`
      * survives a restart. Without this the delay lives only in the in-memory heap:
@@ -220,6 +222,7 @@ export declare class SqliteStorage {
         rateLimitDuration?: number | null;
         rateLimitExpiresAt?: number | null;
         stallConfig?: StallConfig | null;
+        dlqConfig?: DlqConfig | null;
     }): void;
     /** Load all persisted queue control-state rows (used by recover() on boot). */
     loadQueueState(): Array<{
@@ -230,6 +233,7 @@ export declare class SqliteStorage {
         rateLimitDuration: number | null;
         rateLimitExpiresAt: number | null;
         stallConfig: StallConfig | null;
+        dlqConfig: DlqConfig | null;
     }>;
     /** Drop a queue's persisted control-state (e.g. on obliterate). */
     deleteQueueState(name: string): void;

package/dist/infrastructure/persistence/sqlite.js

@@ -4,7 +4,7 @@
  * Uses MessagePack for ~2-3x faster serialization than JSON
  */
 import { Database } from 'bun:sqlite';
-import { createDlqEntry } from '../../domain/types/dlq';
+import { createDlqEntry, } from '../../domain/types/dlq';
 import { PRAGMA_SETTINGS, SCHEMA, MIGRATION_TABLE, SCHEMA_VERSION, MIGRATIONS } from './schema';
 import { prepareStatements, } from './statements';
 import { pack, persistedStallCount, reconstructDlqEntry, rowToJob, unpack, } from './sqliteSerializer';
@@ -403,6 +403,13 @@ export class SqliteStorage {
                 .run(priority, lifo ? 1 : 0, jobId);
         });
     }
+    /** Persist progress and its heartbeat as one active-job mutation. */
+    updateJobProgress(jobId, progress, message, lastHeartbeat) {
+        this.flushIfBuffered(jobId);
+        this.safeWrite(() => {
+            this.statements.get('updateJobProgress').run(progress, message, lastHeartbeat, jobId);
+        });
+    }
     /**
      * Persist a delay change (moveToDelayed / changeDelay) so the new `run_at`
      * survives a restart. Without this the delay lives only in the in-memory heap:
@@ -697,7 +704,7 @@ export class SqliteStorage {
                 ? null
                 : state.stallConfig.enabled
                     ? 1
-                    : 0, state.stallConfig?.stallInterval ?? null, state.stallConfig?.maxStalls ?? null, state.stallConfig?.gracePeriod ?? null);
+                    : 0, state.stallConfig?.stallInterval ?? null, state.stallConfig?.maxStalls ?? null, state.stallConfig?.gracePeriod ?? null, state.dlqConfig ? pack(state.dlqConfig) : null);
         });
     }
     /** Load all persisted queue control-state rows (used by recover() on boot). */
@@ -721,6 +728,7 @@ export class SqliteStorage {
                     maxStalls: row.max_stalls,
                     gracePeriod: row.stall_grace_period,
                 },
+            dlqConfig: unpack(row.dlq_config, null, `loadQueueDlqConfig:${row.name}`),
         }));
     }
     /** Drop a queue's persisted control-state (e.g. on obliterate). */

package/dist/infrastructure/persistence/sqliteSerializer.js

@@ -3,9 +3,9 @@
  * MessagePack encoding/decoding and row conversion
  * Uses msgpackr for 2-3x faster serialization
  */
-import { pack as msgpackEncode, unpack as msgpackDecode } from 'msgpackr';
 import { jobId } from '../../domain/types/job';
 import { storageLog } from '../../shared/logger';
+import { decodeMessagePack as msgpackDecode, encodeMessagePack as msgpackEncode, } from '../../shared/msgpack';
 /** Encode data to MessagePack buffer */
 export function pack(data) {
     return msgpackEncode(data);

package/dist/infrastructure/persistence/statements.d.ts

@@ -4,7 +4,7 @@
  */
 import type { Database } from 'bun:sqlite';
 /** Statement names */
-export type StatementName = 'insertJob' | 'updateJobState' | 'completeJob' | 'deleteJob' | 'deleteJobResult' | 'getJob' | 'insertResult' | 'getResult' | 'insertDlq' | 'loadDlq' | 'deleteDlqEntry' | 'deleteDlqEntryForQueue' | 'clearDlqQueue' | 'insertCron' | 'updateCron' | 'upsertQueueState' | 'loadQueueState' | 'deleteQueueState';
+export type StatementName = 'insertJob' | 'updateJobState' | 'completeJob' | 'updateJobProgress' | 'deleteJob' | 'deleteJobResult' | 'getJob' | 'insertResult' | 'getResult' | 'insertDlq' | 'loadDlq' | 'deleteDlqEntry' | 'deleteDlqEntryForQueue' | 'clearDlqQueue' | 'insertCron' | 'updateCron' | 'upsertQueueState' | 'loadQueueState' | 'deleteQueueState';
 /** SQL statements */
 export declare const SQL_STATEMENTS: Record<StatementName, string>;
 /** Prepare all statements */
@@ -74,4 +74,5 @@ export interface DbQueueState {
     stall_interval: number | null;
     max_stalls: number | null;
     stall_grace_period: number | null;
+    dlq_config: Uint8Array | null;
 }

package/dist/infrastructure/persistence/statements.js

@@ -42,6 +42,7 @@ export const SQL_STATEMENTS = {
   `,
     updateJobState: 'UPDATE jobs SET state = ?, started_at = ?, timeline = ? WHERE id = ?',
     completeJob: 'UPDATE jobs SET state = ?, completed_at = ?, progress = 100, timeline = ? WHERE id = ?',
+    updateJobProgress: 'UPDATE jobs SET progress = ?, progress_msg = ?, last_heartbeat = ? WHERE id = ?',
     deleteJob: 'DELETE FROM jobs WHERE id = ?',
     deleteJobResult: 'DELETE FROM job_results WHERE job_id = ?',
     getJob: 'SELECT * FROM jobs WHERE id = ?',
@@ -59,8 +60,8 @@ export const SQL_STATEMENTS = {
   `,
     updateCron: 'UPDATE cron_jobs SET executions = ?, next_run = ? WHERE name = ?',
     // Queue control-state persistence (#100): paused / rate-limit / concurrency.
-    upsertQueueState: 'INSERT OR REPLACE INTO queue_state (name, paused, rate_limit, concurrency_limit, rate_limit_duration, rate_limit_expires_at, stall_enabled, stall_interval, max_stalls, stall_grace_period) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
-    loadQueueState: 'SELECT name, paused, rate_limit, concurrency_limit, rate_limit_duration, rate_limit_expires_at, stall_enabled, stall_interval, max_stalls, stall_grace_period FROM queue_state',
+    upsertQueueState: 'INSERT OR REPLACE INTO queue_state (name, paused, rate_limit, concurrency_limit, rate_limit_duration, rate_limit_expires_at, stall_enabled, stall_interval, max_stalls, stall_grace_period, dlq_config) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
+    loadQueueState: 'SELECT name, paused, rate_limit, concurrency_limit, rate_limit_duration, rate_limit_expires_at, stall_enabled, stall_interval, max_stalls, stall_grace_period, dlq_config FROM queue_state',
     deleteQueueState: 'DELETE FROM queue_state WHERE name = ?',
 };
 /** Prepare all statements */

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

@@ -106,7 +106,7 @@ export async function handlePull(cmd, ctx, reqId) {
         return resp.error(timeoutError, reqId);
     // If owner is provided, use lock-based pull
     if (cmd.owner) {
-        const { job, token } = await ctx.queueManager.pullWithLock(cmd.queue, cmd.owner, cmd.timeout, cmd.lockTtl);
+        const { job, token } = await ctx.queueManager.pullWithLock(cmd.queue, cmd.owner, cmd.timeout, cmd.lockTtl, ctx.signal);
         // Register job with client for connection-based release
         if (job && ctx.clientId) {
             ctx.queueManager.registerClientJob(ctx.clientId, job.id);
@@ -114,7 +114,7 @@ export async function handlePull(cmd, ctx, reqId) {
         return resp.pulledJob(job, token, reqId);
     }
     // Standard pull (no lock, but still track for client release unless detached)
-    const job = await ctx.queueManager.pull(cmd.queue, cmd.timeout);
+    const job = await ctx.queueManager.pull(cmd.queue, cmd.timeout, ctx.signal);
     if (job && ctx.clientId && !cmd.detach) {
         ctx.queueManager.registerClientJob(ctx.clientId, job.id);
     }
@@ -135,7 +135,7 @@ export async function handlePullBatch(cmd, ctx, reqId) {
         return resp.error(timeoutError, reqId);
     // If owner is provided, use lock-based pull
     if (cmd.owner) {
-        const { jobs, tokens } = await ctx.queueManager.pullBatchWithLock(cmd.queue, cmd.count, cmd.owner, cmd.timeout ?? 0, cmd.lockTtl);
+        const { jobs, tokens } = await ctx.queueManager.pullBatchWithLock(cmd.queue, cmd.count, cmd.owner, cmd.timeout ?? 0, cmd.lockTtl, ctx.signal);
         // Register all jobs with client for connection-based release
         if (ctx.clientId) {
             for (const job of jobs) {
@@ -146,7 +146,7 @@ export async function handlePullBatch(cmd, ctx, reqId) {
     }
     // Standard pull (no locks, but still track for client release) — the
     // non-owner branch honors cmd.timeout exactly like the owner branch and PULL.
-    const jobs = await ctx.queueManager.pullBatch(cmd.queue, cmd.count, cmd.timeout ?? 0);
+    const jobs = await ctx.queueManager.pullBatch(cmd.queue, cmd.count, cmd.timeout ?? 0, ctx.signal);
     if (ctx.clientId) {
         for (const job of jobs) {
             ctx.queueManager.registerClientJob(ctx.clientId, job.id);

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

@@ -39,6 +39,7 @@ export interface TcpServerConfig {
 /** Per-connection data */
 interface ConnectionData {
     state: ConnectionState;
+    abortController: AbortController;
     frameParser: FrameParser;
     ctx: HandlerContext;
     /** Semaphore for limiting concurrent command processing (pipelining) */

package/dist/infrastructure/server/tcp.js

@@ -8,10 +8,10 @@ import { FrameParser, FrameSizeError, createConnectionState, } from './protocol'
 import { uuid } from '../../shared/hash';
 import { tcpLog } from '../../shared/logger';
 import { getRateLimiter } from './rateLimiter';
-import { pack, unpack } from 'msgpackr';
 import { Semaphore, withSemaphore } from '../../shared/semaphore';
 import { SocketWriteQueue } from './socketWriteQueue';
 import { loadTlsOptions } from './tls';
+import { decodeMessagePack, encodeMessagePack } from '../../shared/msgpack';
 /** Max concurrent commands per connection for pipelining */
 const MAX_CONCURRENT_PER_CONNECTION = 50;
 /**
@@ -58,11 +58,11 @@ async function releaseClientJobsWithRetry(queueManager, clientId, maxRetries = 3
 }
 /** Serialize response to framed msgpack */
 function serializeResponse(response) {
-    return FrameParser.frame(pack(response));
+    return FrameParser.frame(encodeMessagePack(response));
 }
 /** Error response as framed msgpack */
 function errorResponse(message, reqId) {
-    return FrameParser.frame(pack({ ok: false, error: message, reqId }));
+    return FrameParser.frame(encodeMessagePack({ ok: false, error: message, reqId }));
 }
 /**
  * Create and start TCP server
@@ -118,14 +118,17 @@ export function createTcpServer(queueManager, config) {
             return;
         const clientId = uuid();
         const state = createConnectionState(clientId);
+        const abortController = new AbortController();
         const ctx = {
             queueManager,
             authTokens,
             authenticated: authTokens.size === 0, // Auto-auth if no tokens
             clientId, // For job ownership tracking
+            signal: abortController.signal,
         };
         socket.data = {
             state,
+            abortController,
             frameParser: new FrameParser(),
             ctx,
             semaphore: new Semaphore(MAX_CONCURRENT_PER_CONNECTION),
@@ -144,12 +147,6 @@ export function createTcpServer(queueManager, config) {
             initConnection(socket);
             const { frameParser, ctx, state, semaphore, writeQueue } = socket.data;
             const rateLimiter = getRateLimiter();
-            // Check rate limit
-            if (!rateLimiter.isAllowed(state.clientId)) {
-                ctx.queueManager.emitDashboardEvent('ratelimit:hit', { clientId: state.clientId });
-                writeQueue.write(socket, errorResponse('Rate limit exceeded'));
-                return;
-            }
             let frames;
             try {
                 // `data` is a Bun Buffer (a Uint8Array). addData copies it into its own
@@ -191,14 +188,27 @@ export function createTcpServer(queueManager, config) {
             const processFrame = async (frame) => {
                 let cmd;
                 try {
-                    cmd = unpack(frame);
+                    cmd = decodeMessagePack(frame);
                 }
                 catch {
+                    // Invalid complete frames still consume protocol quota. They cannot
+                    // carry a trustworthy reqId because msgpack decoding failed.
+                }
+                const reqId = typeof cmd?.reqId === 'string' ? cmd.reqId : undefined;
+                if (!rateLimiter.isAllowed(state.clientId)) {
+                    ctx.queueManager.emitDashboardEvent('ratelimit:hit', { clientId: state.clientId });
+                    writeQueue.write(socket, errorResponse('Rate limit exceeded', reqId));
+                    dropForWriteOverflow();
+                    return;
+                }
+                if (!cmd) {
                     writeQueue.write(socket, errorResponse('Invalid command format'));
+                    dropForWriteOverflow();
                     return;
                 }
                 if (!cmd?.cmd) {
-                    writeQueue.write(socket, errorResponse('Invalid command'));
+                    writeQueue.write(socket, errorResponse('Invalid command', reqId));
+                    dropForWriteOverflow();
                     return;
                 }
                 // Process with concurrency limit
@@ -224,6 +234,7 @@ export function createTcpServer(queueManager, config) {
             // (e.g. TLS handshake aborted) — nothing to release. #108
             if (!socket.data)
                 return;
+            socket.data.abortController.abort();
             const clientId = socket.data.state.clientId;
             // Cancel the slowloris stall timer and drop any buffered-but-unwritten
             // bytes; the socket is gone.
@@ -288,7 +299,7 @@ export function createTcpServer(queueManager, config) {
         },
         /** Broadcast to all connections */
         broadcast(message) {
-            const frame = FrameParser.frame(pack(message));
+            const frame = FrameParser.frame(encodeMessagePack(message));
             for (const socket of connections.values()) {
                 // Each connection writes through its own backpressure-aware queue so a
                 // slow reader buffers (in order) instead of dropping frame tail bytes.

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

@@ -9,4 +9,6 @@ export interface HandlerContext {
     authenticated: boolean;
     /** Client ID for job ownership tracking */
     clientId?: string;
+    /** Aborted when the transport disconnects, cancelling connection-scoped waits. */
+    signal?: AbortSignal;
 }

package/dist/shared/msgpack.d.ts

@@ -0,0 +1,3 @@
+export declare function encodeMessagePack(value: unknown): Uint8Array;
+/** Decode maps through safe own properties, preserving keys such as `__proto__`. */
+export declare function decodeMessagePack<T = unknown>(buffer: Uint8Array): T;

package/dist/shared/msgpack.js

@@ -0,0 +1,70 @@
+import { pack, unpack, Unpackr } from 'msgpackr';
+const unpackr = new Unpackr({ mapsAsObjects: false, useRecords: false });
+const PROTO_KEY_BYTES = new TextEncoder().encode('__proto__');
+function containsProtoKey(buffer) {
+    for (let index = 0; index <= buffer.length - PROTO_KEY_BYTES.length; index++) {
+        if (buffer[index] !== PROTO_KEY_BYTES[0])
+            continue;
+        let matches = true;
+        for (let offset = 1; offset < PROTO_KEY_BYTES.length; offset++) {
+            if (buffer[index + offset] !== PROTO_KEY_BYTES[offset]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return true;
+    }
+    return false;
+}
+function defineSafe(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+}
+function materialize(value, seen) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    const cached = seen.get(value);
+    if (cached !== undefined)
+        return cached;
+    if (Array.isArray(value)) {
+        const result = [];
+        seen.set(value, result);
+        for (const item of value)
+            result.push(materialize(item, seen));
+        return result;
+    }
+    if (value instanceof Map) {
+        const result = {};
+        seen.set(value, result);
+        for (const [key, item] of value) {
+            defineSafe(result, typeof key === 'symbol' ? key : String(key), materialize(item, seen));
+        }
+        return result;
+    }
+    if (value instanceof Date ||
+        value instanceof RegExp ||
+        value instanceof ArrayBuffer ||
+        ArrayBuffer.isView(value)) {
+        return value;
+    }
+    const result = {};
+    seen.set(value, result);
+    for (const key of Reflect.ownKeys(value)) {
+        defineSafe(result, key, materialize(Reflect.get(value, key), seen));
+    }
+    return result;
+}
+export function encodeMessagePack(value) {
+    return pack(value);
+}
+/** Decode maps through safe own properties, preserving keys such as `__proto__`. */
+export function decodeMessagePack(buffer) {
+    if (!containsProtoKey(buffer))
+        return unpack(buffer);
+    return materialize(unpackr.unpack(buffer), new WeakMap());
+}

package/package.json

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