bunqueue 2.8.0 → 2.8.2

package/README.md

@@ -49,6 +49,24 @@ That's it. Queue + Worker in one object. No Redis, no config, no setup.
 
 ---
 
+## 🪶 Featherweight install
+
+`bun add bunqueue` pulls **7 packages and 5.4 MB** — and that includes the binary
+queue server, the CLI, and the MCP server. Most queue libraries pull a Redis
+client and its dependency tree before you've queued a single job.
+
+| | Before (2.7.x) | Now | |
+| --- | --- | --- | --- |
+| **`node_modules`** | 93 MB | **5.4 MB** | **−94%** |
+| **packages** | 117 | **7** | **−110** |
+| **cold install** | ~6 s | **~1.2 s** | **~5× faster** |
+
+Just **2 runtime dependencies** (`croner` + `msgpackr`). SQLite, S3, HTTP and
+WebSocket are all Bun built-ins. The MCP SDK is an optional peer dependency —
+queue users never download it. ([details →](https://bunqueue.dev/changelog/))
+
+---
+
 ## Simple Mode
 
 Simple Mode gives you a Queue and a Worker in a single object. Add jobs, process them, add middleware, schedule crons — all from one place.
@@ -537,26 +555,32 @@ await engine.start('order-pipeline', { orderId: 'ORD-1', amount: 99.99 });
 
 **vs Competitors:**
 
-| | **bunqueue** | **Temporal** | **Inngest** | **AWS Step Functions** |
+| | **bunqueue** | **Temporal** | **Inngest** | **Trigger.dev** |
 |---|---|---|---|---|
-| **Infrastructure** | None (embedded) | PostgreSQL + 7 services | Cloud-only | AWS-native |
+| **Infrastructure** | None (embedded) | PostgreSQL + 7 services | Cloud-only | Redis + PostgreSQL |
 | **Saga compensation** | Built-in | Manual | Manual | Manual |
-| **Human-in-the-loop** | `.waitFor()` | Signals API | `step.waitForEvent()` | Callback tasks |
-| **Self-hosted** | Zero-config | Complex | No | No |
-| **Pricing** | Free (MIT) | Free / Cloud $$ | Per-execution | Per-transition |
+| **Human-in-the-loop** | `.waitFor()` | Signals API | `step.waitForEvent()` | Waitpoint tokens |
+| **Self-hosted** | Zero-config | Complex | No | Complex |
+| **Pricing** | Free (MIT) | Free / Cloud $$ | Per-execution | Free tier, then $50/mo+ |
 
 ```typescript
 // Branching
 const flow = new Workflow('tiered')
-  .step('classify', async (ctx) => ({ tier: ctx.input.amount > 1000 ? 'vip' : 'basic' }))
-  .branch((ctx) => ctx.steps['classify'].tier)
+  .step('classify', async (ctx) => {
+    const { amount } = ctx.input as { amount: number };
+    return { tier: amount > 1000 ? 'vip' : 'basic' };
+  })
+  .branch((ctx) => (ctx.steps['classify'] as { tier: string }).tier)
   .path('vip', (w) => w.step('vip-handler', async () => ({ discount: 20 })))
   .path('basic', (w) => w.step('basic-handler', async () => ({ discount: 0 })))
   .step('done', async () => ({ processed: true }));
 
 // Human-in-the-loop
 const approvalFlow = new Workflow('expense')
-  .step('submit', async (ctx) => ({ amount: ctx.input.amount }))
+  .step('submit', async (ctx) => {
+    const { amount } = ctx.input as { amount: number };
+    return { amount };
+  })
   .waitFor('manager-approval')
   .step('reimburse', async (ctx) => {
     const decision = ctx.signals['manager-approval'] as { approved: boolean };
@@ -596,6 +620,7 @@ https://github.com/user-attachments/assets/e8a8d38e-b4a6-4dc8-8360-876c0f24d116
 - **MCP server included** — 73 tools, 5 resources, 3 prompts. AI agents get full control out of the box
 - **BullMQ-compatible API** — Same `Queue`, `Worker`, `QueueEvents`
 - **Zero dependencies** — No Redis, no MongoDB
+- **Tiny footprint** — 5.4 MB installed, 7 packages (just 2 runtime deps: `croner` + `msgpackr`)
 - **SQLite persistence** — Survives restarts, WAL mode for concurrent access
 - **Up to 286K ops/sec** — [Verified benchmarks](https://bunqueue.dev/guide/benchmarks/)
 
@@ -620,17 +645,25 @@ bunqueue is the **first job queue with native MCP support**. AI agents get a ful
 - **HTTP handlers** — register a URL, bunqueue auto-processes jobs via HTTP calls
 
 ```bash
-# One command to connect Claude Code
+# bunqueue-mcp is a binary bundled inside the bunqueue package (not a standalone npm package),
+# so install bunqueue first, then connect Claude Code:
+bun add bunqueue
+# Since v2.8.0 the MCP SDK is an optional peer dependency. Queue-only users skip it entirely:
+# a clean install drops from 93 MB / 117 packages to 5.4 MB / 7 packages (−94%, up to ~5× faster on a cold install).
+# bunx --package=bunqueue does NOT auto-install optional peers, so install the SDK once to run the MCP server:
+bun add @modelcontextprotocol/sdk
 claude mcp add bunqueue -- bunx bunqueue-mcp
 ```
 
 ```json
-// Claude Desktop / Cursor / Windsurf — add to MCP config
+// Claude Desktop / Cursor / Windsurf — --package=bunqueue lets bunx resolve the bundled
+// bunqueue-mcp binary without a separate install (the @modelcontextprotocol/sdk optional
+// peer dependency must still be installed once: bun add @modelcontextprotocol/sdk):
 {
   "mcpServers": {
     "bunqueue": {
       "command": "bunx",
-      "args": ["bunqueue-mcp"]
+      "args": ["--package=bunqueue", "bunqueue-mcp"]
     }
   }
 }

package/dist/application/backgroundTasks.d.ts

@@ -28,4 +28,3 @@ export declare function startBackgroundTasks(ctx: BackgroundContext, cronSchedul
 export declare function stopBackgroundTasks(handles: BackgroundTaskHandles): void;
 export declare function recover(ctx: BackgroundContext): void;
 export { processPendingDependencies };
-//# sourceMappingURL=backgroundTasks.d.ts.map

package/dist/application/backgroundTasks.js

@@ -4,6 +4,7 @@
  */
 import { queueLog } from '../shared/logger';
 import { shardIndex } from '../shared/hash';
+import { createDlqEntry } from '../domain/types/dlq';
 import { calculateBackoff } from '../domain/types/job';
 import * as dlqOps from './dlqManager';
 import { checkExpiredLocks } from './lockManager';
@@ -12,6 +13,7 @@ import { checkStalledJobs } from './stallDetection';
 import { processPendingDependencies } from './dependencyProcessor';
 import { handleTaskError, handleTaskSuccess, getTaskErrorStats } from './taskErrorTracking';
 import { runMonitoringChecks } from './monitoringChecks';
+import { isCorruptDependsOn } from '../infrastructure/persistence/sqliteSerializer';
 export { getTaskErrorStats };
 /**
  * Start all background tasks
@@ -151,12 +153,40 @@ function performDlqMaintenance(ctx) {
 // ============ Recovery ============
 /** Batch size for paginated recovery */
 const RECOVERY_BATCH_SIZE = 10000;
+/**
+ * Route a job whose `depends_on` blob was corrupt on disk straight to the DLQ.
+ *
+ * Its real dependency metadata is unrecoverable, so it must never be enqueued
+ * as "ready" (out-of-order execution) nor parked in waitingDeps behind a
+ * dependency that can never complete (an unbounded leak).
+ *
+ * We persist the DLQ entry to disk and drop the jobs row here, but do NOT add
+ * it to the in-memory DLQ — the later `loadDlq()` pass (which runs after both
+ * recovery phases) restores every persisted entry into memory exactly once.
+ * Adding it here too would double-count it. The job row is deleted so that pass
+ * sees only the DLQ table.
+ */
+function quarantineCorruptDependsOn(ctx, job) {
+    if (!ctx.storage)
+        return;
+    const entry = createDlqEntry(job, "unknown" /* FailureReason.Unknown */, 'corrupt-dependency-metadata');
+    ctx.storage.saveDlqEntry(entry);
+    ctx.storage.deleteJob(job.id);
+    ctx.registerQueueName(job.queue);
+    queueLog.error('Recovered job with corrupt depends_on metadata -> routed to DLQ', {
+        jobId: String(job.id),
+        queue: job.queue,
+    });
+}
 // eslint-disable-next-line complexity
 export function recover(ctx) {
     if (!ctx.storage)
         return;
     // Load completed job IDs from SQLite for dependency checking
     const completedInDb = ctx.storage.loadCompletedJobIds();
+    // Load DLQ job IDs so Phase 1 can skip stale active rows for DLQ'd jobs
+    // (legacy DBs predate the DLQ-row cleanup fix in failJob).
+    const dlqJobIds = ctx.storage.loadDlqJobIds();
     const now = Date.now();
     // === PHASE 1: Recover active jobs (were processing when server stopped) ===
     // These jobs are considered "stalled" and need to be retried or moved to DLQ
@@ -177,6 +207,21 @@ export function recover(ctx) {
                 ctx.registerQueueName(job.queue);
                 continue;
             }
+            // Skip jobs already present in DLQ (stale 'active' row from before the
+            // failJob fix). Drop the orphan row so Phase 2 and subsequent queries
+            // don't double-count it.
+            if (dlqJobIds.has(job.id)) {
+                ctx.storage.deleteJob(job.id);
+                ctx.registerQueueName(job.queue);
+                continue;
+            }
+            // A corrupt depends_on blob makes the job's real dependencies
+            // unrecoverable: route it to the DLQ instead of retrying it (which could
+            // execute it out-of-order once stalls are exhausted).
+            if (isCorruptDependsOn(job)) {
+                quarantineCorruptDependsOn(ctx, job);
+                continue;
+            }
             // Increment stall count (job was interrupted)
             job.stallCount = (job.stallCount || 0) + 1;
             job.attempts++;
@@ -216,6 +261,13 @@ export function recover(ctx) {
         for (const job of jobs) {
             const idx = shardIndex(job.queue);
             const shard = ctx.shards[idx];
+            // A corrupt depends_on blob means the real dependencies are unrecoverable.
+            // Route the job to the DLQ rather than enqueuing it as ready (out-of-order
+            // execution) or parking it in waitingDeps forever (unbounded leak).
+            if (isCorruptDependsOn(job)) {
+                quarantineCorruptDependsOn(ctx, job);
+                continue;
+            }
             // Check if job has unmet dependencies
             // Check both in-memory completedJobs AND SQLite job_results table
             const hasDependencies = job.dependsOn && job.dependsOn.length > 0;
@@ -257,10 +309,40 @@ export function recover(ctx) {
         const shard = ctx.shards[idx];
         for (const entry of entries) {
             shard.restoreDlqEntry(queue, entry);
+            // Populate jobIndex so getJob/getJobState resolve DLQ'd jobs post-restart.
+            ctx.jobIndex.set(entry.job.id, { type: 'dlq', queueName: queue });
         }
         ctx.registerQueueName(queue);
     }
+    // === PHASE 3: Recover completed jobs ===
+    // Required for clean('completed'), stats.completed, and in-memory lookups
+    // on jobs that completed before a server restart (issue #84).
+    // Capped at maxCompletedJobs (matches BoundedSet cap) so we don't exceed
+    // the in-memory budget when SQLite contains more rows than the cap.
+    // Note: we deliberately do NOT populate customIdMap here — Phase 2 owns
+    // dedup for pending jobs, and push.ts handles customId collision against
+    // completed jobs via the storage fallback. Touching customIdMap here would
+    // LRU-evict pending-job mappings when many completed jobs have customIds.
+    const completedCap = ctx.config.maxCompletedJobs;
+    let completedLoaded = 0;
+    let completedOffset = 0;
+    while (completedLoaded < completedCap) {
+        const remaining = completedCap - completedLoaded;
+        const batchSize = Math.min(RECOVERY_BATCH_SIZE, remaining);
+        const completedBatch = ctx.storage.loadCompletedJobs(batchSize, completedOffset);
+        if (completedBatch.length === 0)
+            break;
+        for (const job of completedBatch) {
+            ctx.jobIndex.set(job.id, { type: 'completed', queueName: job.queue });
+            ctx.completedJobs.add(job.id);
+            ctx.completedJobsData.set(job.id, job);
+            ctx.registerQueueName(job.queue);
+        }
+        completedLoaded += completedBatch.length;
+        completedOffset += completedBatch.length;
+        if (completedBatch.length < batchSize)
+            break;
+    }
 }
 // Re-export for backward compatibility
 export { processPendingDependencies };
-//# sourceMappingURL=backgroundTasks.js.map

package/dist/application/cleanupTasks.d.ts

@@ -8,4 +8,3 @@ import type { BackgroundContext } from './types';
  * Cleans orphaned entries, stale data, and manages memory
  */
 export declare function cleanup(ctx: BackgroundContext): Promise<void>;
-//# sourceMappingURL=cleanupTasks.d.ts.map

package/dist/application/cleanupTasks.js

@@ -228,4 +228,3 @@ function cleanEmptyQueues(ctx) {
         shard.cleanOrphanedTemporalEntries();
     }
 }
-//# sourceMappingURL=cleanupTasks.js.map

package/dist/application/clientTracking.d.ts

@@ -19,4 +19,26 @@ export declare function unregisterClientJob(clientId: string | undefined, jobId:
  * Uses proper locking to prevent race conditions.
  */
 export declare function releaseClientJobs(clientId: string, ctx: LockContext): Promise<number>;
-//# sourceMappingURL=clientTracking.d.ts.map
+/**
+ * Force-release client tracking without acquiring queue locks.
+ * Used as a last-resort fallback when releaseClientJobs has exhausted its
+ * retry budget (e.g. persistent lock contention on TCP disconnect). For each
+ * orphaned job:
+ *   - clears `jobLocks` so a stale lock token can't survive the disconnect
+ *     until its TTL expires;
+ *   - expires both `lastHeartbeat` (so stall detection's heartbeat check
+ *     fires) and `startedAt` (so the gracePeriod check passes immediately).
+ *
+ * Recovery latency: stall detection uses two-phase confirmation
+ * (stalledCandidates collected on one tick, acted on the next), so a job is
+ * recovered within ~2 stall-check ticks (≈10s with defaults). This is faster
+ * than the full stallTimeout (30s default) but NOT instant.
+ *
+ * This path runs lock-free: callers must accept that another path (stall
+ * detector, lock expiration) may concurrently mutate or remove the same job
+ * from processingShards. Worst case: our mutation lands on an object that is
+ * no longer in the Map, wasting the write. Never corrupts state.
+ *
+ * Returns the number of jobs whose state was reset.
+ */
+export declare function forceReleaseClientJobs(clientId: string, ctx: LockContext): number;

package/dist/application/clientTracking.js

@@ -73,36 +73,91 @@ export async function releaseClientJobs(clientId, ctx) {
     }
     let released = 0;
     const now = Date.now();
-    // Phase 3: Process each processing shard with proper locking
-    // Lock order: shardLocks BEFORE processingLocks (per lock hierarchy in CLAUDE.md)
-    for (const [procIdx, items] of byProcShard) {
-        // Group items by queue shard to minimize lock acquisitions
-        const byQueueShard = new Map();
-        for (const item of items) {
-            let list = byQueueShard.get(item.queueShardIdx);
-            if (!list) {
-                list = [];
-                byQueueShard.set(item.queueShardIdx, list);
+    try {
+        // Phase 3: Process each processing shard with proper locking
+        // Lock order: shardLocks BEFORE processingLocks (per lock hierarchy in CLAUDE.md)
+        for (const [procIdx, items] of byProcShard) {
+            // Group items by queue shard to minimize lock acquisitions
+            const byQueueShard = new Map();
+            for (const item of items) {
+                let list = byQueueShard.get(item.queueShardIdx);
+                if (!list) {
+                    list = [];
+                    byQueueShard.set(item.queueShardIdx, list);
+                }
+                list.push(item);
             }
-            list.push(item);
-        }
-        // Acquire shard locks first, then processing lock
-        for (const [queueShardIdx, shardItems] of byQueueShard) {
-            await withWriteLock(ctx.shardLocks[queueShardIdx], async () => {
-                await withWriteLock(ctx.processingLocks[procIdx], () => {
-                    for (const { jobId } of shardItems) {
-                        const job = ctx.processingShards[procIdx].get(jobId);
-                        if (!job)
-                            continue;
-                        released += releaseJobToQueue({ jobId, job, procIdx, queueShardIdx, ctx, now });
-                    }
+            // Acquire shard locks first, then processing lock
+            for (const [queueShardIdx, shardItems] of byQueueShard) {
+                await withWriteLock(ctx.shardLocks[queueShardIdx], async () => {
+                    await withWriteLock(ctx.processingLocks[procIdx], () => {
+                        for (const { jobId } of shardItems) {
+                            const job = ctx.processingShards[procIdx].get(jobId);
+                            if (!job)
+                                continue;
+                            released += releaseJobToQueue({ jobId, job, procIdx, queueShardIdx, ctx, now });
+                        }
+                    });
                 });
-            });
+            }
         }
+        return released;
+    }
+    finally {
+        // Always clear client tracking, even if locking failed mid-flight.
+        // Prevents a leak in ctx.clientJobs that would otherwise accumulate
+        // across every TCP disconnect that hit a lock timeout. Jobs left in
+        // 'active' state will be recovered by the stall detector on its next tick.
+        ctx.clientJobs.delete(clientId);
+    }
+}
+/**
+ * Force-release client tracking without acquiring queue locks.
+ * Used as a last-resort fallback when releaseClientJobs has exhausted its
+ * retry budget (e.g. persistent lock contention on TCP disconnect). For each
+ * orphaned job:
+ *   - clears `jobLocks` so a stale lock token can't survive the disconnect
+ *     until its TTL expires;
+ *   - expires both `lastHeartbeat` (so stall detection's heartbeat check
+ *     fires) and `startedAt` (so the gracePeriod check passes immediately).
+ *
+ * Recovery latency: stall detection uses two-phase confirmation
+ * (stalledCandidates collected on one tick, acted on the next), so a job is
+ * recovered within ~2 stall-check ticks (≈10s with defaults). This is faster
+ * than the full stallTimeout (30s default) but NOT instant.
+ *
+ * This path runs lock-free: callers must accept that another path (stall
+ * detector, lock expiration) may concurrently mutate or remove the same job
+ * from processingShards. Worst case: our mutation lands on an object that is
+ * no longer in the Map, wasting the write. Never corrupts state.
+ *
+ * Returns the number of jobs whose state was reset.
+ */
+export function forceReleaseClientJobs(clientId, ctx) {
+    const jobs = ctx.clientJobs.get(clientId);
+    if (!jobs || jobs.size === 0) {
+        ctx.clientJobs.delete(clientId);
+        return 0;
+    }
+    let touched = 0;
+    for (const jobId of jobs) {
+        // Always drop any lock token for this job, even if the location is no
+        // longer 'processing' — prevents stale tokens from surviving.
+        ctx.jobLocks.delete(jobId);
+        const loc = ctx.jobIndex.get(jobId);
+        if (loc?.type !== 'processing')
+            continue;
+        const job = ctx.processingShards[loc.shardIdx].get(jobId);
+        if (!job)
+            continue;
+        // Expire heartbeat AND startedAt so the stall detector's grace-period
+        // gate passes on the next eligible tick.
+        job.lastHeartbeat = 0;
+        job.startedAt = 0;
+        touched++;
     }
-    // Clear client tracking
     ctx.clientJobs.delete(clientId);
-    return released;
+    return touched;
 }
 /** Release a single job back to queue */
 function releaseJobToQueue(opts) {
@@ -132,4 +187,3 @@ function releaseJobToQueue(opts) {
     ctx.jobIndex.set(jobId, { type: 'queue', shardIdx: queueShardIdx, queueName: job.queue });
     return 1;
 }
-//# sourceMappingURL=clientTracking.js.map

package/dist/application/contextFactory.d.ts

@@ -105,6 +105,11 @@ export declare class ContextFactory {
     getQueueControlContext(): {
         shards: Shard[];
         jobIndex: Map<JobId, JobLocation>;
+        processingShards: Map<JobId, Job>[];
+        completedJobs: BoundedSet<JobId>;
+        completedJobsData: BoundedMap<JobId, Job>;
+        jobResults: LRUMap<JobId, unknown>;
+        jobLogs: LRUMap<JobId, JobLogEntry[]>;
+        storage: SqliteStorage | null;
     };
 }
-//# sourceMappingURL=contextFactory.d.ts.map

package/dist/application/contextFactory.js

@@ -53,6 +53,7 @@ export class ContextFactory {
             dashboardEmit: this.callbacks.emitDashboardEvent,
             workerManager: this.deps.workerManager,
             monitoringState: this.deps.monitoringState,
+            completedJobsData: this.deps.completedJobsData,
         };
     }
     getStatsContext() {
@@ -179,7 +180,12 @@ export class ContextFactory {
         return {
             shards: this.deps.shards,
             jobIndex: this.deps.jobIndex,
+            processingShards: this.deps.processingShards,
+            completedJobs: this.deps.completedJobs,
+            completedJobsData: this.deps.completedJobsData,
+            jobResults: this.deps.jobResults,
+            jobLogs: this.deps.jobLogs,
+            storage: this.deps.storage,
         };
     }
 }
-//# sourceMappingURL=contextFactory.js.map

package/dist/application/dependencyProcessor.d.ts

@@ -8,4 +8,3 @@ import type { BackgroundContext } from './types';
  * Resolves jobs whose dependencies have been completed
  */
 export declare function processPendingDependencies(ctx: BackgroundContext): Promise<void>;
-//# sourceMappingURL=dependencyProcessor.d.ts.map

package/dist/application/dependencyProcessor.js

@@ -75,4 +75,3 @@ function promoteJobsToQueue(jobsToPromote, shard, ctx, shardIdx) {
         }
     }
 }
-//# sourceMappingURL=dependencyProcessor.js.map

package/dist/application/dlqManager.d.ts

@@ -47,4 +47,3 @@ export interface RetryCompletedContext extends DlqContext {
 }
 /** Retry completed jobs */
 export declare function retryCompletedJobs(queue: string, ctx: RetryCompletedContext, jobId?: JobId): number;
-//# sourceMappingURL=dlqManager.d.ts.map

package/dist/application/dlqManager.js

@@ -81,6 +81,8 @@ export function retryDlqJob(queue, jobId, ctx) {
     const isDelayed = job.runAt > now;
     shard.incrementQueued(job.id, isDelayed, job.createdAt, queue, job.runAt);
     ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: queue });
+    // Re-insert jobs row (deleted when job entered DLQ) so retry survives restart
+    ctx.storage?.insertJob(job, true);
     return job;
 }
 /** Retry jobs from DLQ (backward compatible) */
@@ -110,6 +112,7 @@ export function retryDlqJobs(queue, ctx, jobId) {
         const isDelayed = job.runAt > now;
         shard.incrementQueued(job.id, isDelayed, job.createdAt, queue, job.runAt);
         ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: queue });
+        ctx.storage?.insertJob(job, true);
     }
     return count;
 }
@@ -138,6 +141,7 @@ export function retryDlqByFilter(queue, ctx, filter) {
         const isDelayed = job.runAt > now;
         shard.incrementQueued(job.id, isDelayed, job.createdAt, queue, job.runAt);
         ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: queue });
+        ctx.storage?.insertJob(job, true);
         count++;
     }
     return count;
@@ -172,6 +176,7 @@ export function processAutoRetry(queue, ctx) {
         const isDelayed = job.runAt > now;
         shard.incrementQueued(job.id, isDelayed, job.createdAt, queue, job.runAt);
         ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: queue });
+        ctx.storage?.insertJob(job, true);
         count++;
     }
     return count;
@@ -248,4 +253,3 @@ function requeueCompletedJob(job, ctx) {
     shard.notify();
     return 1;
 }
-//# sourceMappingURL=dlqManager.js.map

package/dist/application/eventsManager.d.ts

@@ -41,4 +41,3 @@ export declare class EventsManager {
     /** Map internal event type to webhook event */
     private mapEventToWebhook;
 }
-//# sourceMappingURL=eventsManager.d.ts.map

package/dist/application/eventsManager.js

@@ -168,4 +168,3 @@ export class EventsManager {
         }
     }
 }
-//# sourceMappingURL=eventsManager.js.map

package/dist/application/jobLogsManager.d.ts

@@ -18,4 +18,3 @@ export declare function addJobLog(jobId: JobId, message: string, ctx: JobLogsCon
 export declare function getJobLogs(jobId: JobId, ctx: JobLogsContext): JobLogEntry[];
 /** Clear logs for a job, optionally keeping the most recent N entries */
 export declare function clearJobLogs(jobId: JobId, ctx: JobLogsContext, keepLogs?: number): void;
-//# sourceMappingURL=jobLogsManager.d.ts.map

package/dist/application/jobLogsManager.js

@@ -35,4 +35,3 @@ export function clearJobLogs(jobId, ctx, keepLogs) {
         }
     }
 }
-//# sourceMappingURL=jobLogsManager.js.map

package/dist/application/latencyTracker.d.ts

@@ -37,4 +37,3 @@ export declare class LatencyTracker {
 }
 /** Global singleton */
 export declare const latencyTracker: LatencyTracker;
-//# sourceMappingURL=latencyTracker.d.ts.map

package/dist/application/latencyTracker.js

@@ -49,4 +49,3 @@ export class LatencyTracker {
 }
 /** Global singleton */
 export const latencyTracker = new LatencyTracker();
-//# sourceMappingURL=latencyTracker.js.map

package/dist/application/lockManager.d.ts

@@ -4,7 +4,7 @@
  */
 import type { LockContext } from './types';
 export { createLock, verifyLock, renewJobLock, renewJobLockBatch, releaseLock, getLockInfo, } from './lockOperations';
-export { registerClientJob, unregisterClientJob, releaseClientJobs } from './clientTracking';
+export { registerClientJob, unregisterClientJob, releaseClientJobs, forceReleaseClientJobs, } from './clientTracking';
 /**
  * Check and handle expired locks.
  * Jobs with expired locks are requeued for retry.
@@ -13,4 +13,3 @@ export { registerClientJob, unregisterClientJob, releaseClientJobs } from './cli
  * Lock hierarchy: shards[N] -> processingShards[N] (per CLAUDE.md)
  */
 export declare function checkExpiredLocks(ctx: LockContext): Promise<void>;
-//# sourceMappingURL=lockManager.d.ts.map

package/dist/application/lockManager.js

@@ -8,7 +8,7 @@ import { withWriteLock } from '../shared/lock';
 // Re-export lock operations
 export { createLock, verifyLock, renewJobLock, renewJobLockBatch, releaseLock, getLockInfo, } from './lockOperations';
 // Re-export client tracking
-export { registerClientJob, unregisterClientJob, releaseClientJobs } from './clientTracking';
+export { registerClientJob, unregisterClientJob, releaseClientJobs, forceReleaseClientJobs, } from './clientTracking';
 /**
  * Check and handle expired locks.
  * Jobs with expired locks are requeued for retry.
@@ -137,4 +137,3 @@ function requeueExpiredJob(opts) {
         timestamp: now,
     });
 }
-//# sourceMappingURL=lockManager.js.map

package/dist/application/lockOperations.d.ts

@@ -36,4 +36,3 @@ export declare function releaseLock(jobId: JobId, ctx: LockContext, token?: stri
  * Get lock info for a job (for debugging/monitoring).
  */
 export declare function getLockInfo(jobId: JobId, ctx: LockContext): JobLock | null;
-//# sourceMappingURL=lockOperations.d.ts.map

package/dist/application/lockOperations.js

@@ -91,4 +91,3 @@ export function releaseLock(jobId, ctx, token) {
 export function getLockInfo(jobId, ctx) {
     return ctx.jobLocks.get(jobId) ?? null;
 }
-//# sourceMappingURL=lockOperations.js.map

package/dist/application/metricsExporter.d.ts

@@ -23,4 +23,3 @@ export interface QueueStats {
 }
 /** Generate Prometheus metrics */
 export declare function generatePrometheusMetrics(stats: QueueStats, workerManager: WorkerManager, webhookManager: WebhookManager, perQueueStats?: Map<string, PerQueueStats>): string;
-//# sourceMappingURL=metricsExporter.d.ts.map

package/dist/application/metricsExporter.js

@@ -121,4 +121,3 @@ export function generatePrometheusMetrics(stats, workerManager, webhookManager,
     }
     return lines.join('\n');
 }
-//# sourceMappingURL=metricsExporter.js.map

package/dist/application/monitoringChecks.d.ts

@@ -34,4 +34,3 @@ export interface MonitoringContext {
 }
 /** Check all monitoring conditions — called from cleanup interval (10s) */
 export declare function runMonitoringChecks(ctx: MonitoringContext): void;
-//# sourceMappingURL=monitoringChecks.d.ts.map

package/dist/application/monitoringChecks.js

@@ -163,4 +163,3 @@ function checkStorageSize(ctx) {
         ctx.state.storageWarningEmitted = false;
     }
 }
-//# sourceMappingURL=monitoringChecks.js.map

package/dist/application/operations/ack.d.ts

@@ -70,4 +70,3 @@ export declare function ackJobBatchWithResults(items: Array<{
     id: JobId;
     result: unknown;
 }>, ctx: AckContext): Promise<void>;
-//# sourceMappingURL=ack.d.ts.map