bunqueue 2.8.38 → 2.8.39

package/dist/application/backgroundTasks.js

@@ -324,6 +324,12 @@ export function recover(ctx) {
                 shard.incrementQueued(job.id, isDelayed, job.createdAt, job.queue, job.runAt);
             }
             ctx.jobIndex.set(job.id, { type: 'queue', shardIdx: idx, queueName: job.queue });
+            ctx.dependencyResults.registerConsumer(job.id, job.dependsOn);
+            for (const dependencyId of job.dependsOn) {
+                if (ctx.jobResults.has(dependencyId)) {
+                    ctx.dependencyResults.retain(dependencyId, ctx.jobResults.get(dependencyId));
+                }
+            }
             // Restore customId mapping for deduplication (fixes idempotency on restart)
             if (job.customId) {
                 ctx.customIdMap.set(job.customId, job.id);

package/dist/application/cleanupTasks.js

@@ -24,7 +24,7 @@ export async function cleanup(ctx) {
         }
     }
     await cleanOrphanedProcessingEntries(ctx, now, stallTimeout);
-    cleanStaleWaitingDependencies(ctx, now);
+    await cleanStaleWaitingDependencies(ctx, now);
     cleanUniqueKeysAndGroups(ctx);
     cleanStalledCandidates(ctx);
     await cleanOrphanedJobIndex(ctx);
@@ -58,23 +58,43 @@ async function cleanOrphanedProcessingEntries(ctx, now, stallTimeout) {
         });
     }
 }
-function cleanStaleWaitingDependencies(ctx, now) {
+async function cleanStaleWaitingDependencies(ctx, now) {
     const depTimeout = 60 * 60 * 1000; // 1 hour
     for (let i = 0; i < SHARD_COUNT; i++) {
         const shard = ctx.shards[i];
-        const stale = [];
+        const staleIds = [];
         for (const [_id, job] of shard.waitingDeps) {
             if (now - job.createdAt > depTimeout) {
-                stale.push(job);
+                staleIds.push(job.id);
             }
         }
-        for (const job of stale) {
-            shard.waitingDeps.delete(job.id);
-            shard.unregisterDependencies(job.id, job.dependsOn);
-            ctx.jobIndex.delete(job.id);
-        }
-        if (stale.length > 0) {
-            ctx.dashboardEmit?.('cleanup:stale-deps-removed', { count: stale.length });
+        if (staleIds.length === 0)
+            continue;
+        const removed = await withWriteLock(ctx.shardLocks[i], () => {
+            let count = 0;
+            for (const id of staleIds) {
+                const job = shard.waitingDeps.get(id);
+                if (!job || now - job.createdAt <= depTimeout)
+                    continue;
+                // Persistence first: deleteJob also removes a pending buffered insert.
+                // If SQLite throws, the in-memory lifecycle remains live and coherent.
+                ctx.storage?.deleteJob(job.id);
+                shard.waitingDeps.delete(job.id);
+                shard.unregisterDependencies(job.id, job.dependsOn);
+                if (job.uniqueKey && shard.getUniqueKeyEntry(job.queue, job.uniqueKey)?.jobId === job.id) {
+                    shard.releaseUniqueKey(job.queue, job.uniqueKey);
+                }
+                if (job.customId && ctx.customIdMap.get(job.customId) === job.id) {
+                    ctx.customIdMap.delete(job.customId);
+                }
+                ctx.dependencyResults?.releaseConsumer(job.id);
+                ctx.jobIndex.delete(job.id);
+                count++;
+            }
+            return count;
+        });
+        if (removed > 0) {
+            ctx.dashboardEmit?.('cleanup:stale-deps-removed', { count: removed });
         }
     }
 }

package/dist/application/contextFactory.d.ts

@@ -12,6 +12,7 @@ import type { WebhookManager } from './webhookManager';
 import type { WorkerManager } from './workerManager';
 import type { EventsManager } from './eventsManager';
 import type { MonitoringState } from './monitoringChecks';
+import type { DependencyResultTracker } from './dependencyResultTracker';
 import type { LockContext, BackgroundContext, StatsContext } from './types';
 import type { PushContext } from './operations/push';
 import type { PullContext } from './operations/pull';
@@ -36,6 +37,7 @@ export interface ContextDependencies {
     depCompletions?: BoundedSet<JobId>;
     timedOutJobs?: BoundedSet<JobId>;
     jobResults: LRUMap<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
     customIdMap: LRUMap<string, JobId>;
     jobLogs: LRUMap<JobId, JobLogEntry[]>;
     jobLocks: Map<JobId, JobLock>;
@@ -111,6 +113,7 @@ export declare class ContextFactory {
         completedJobs: BoundedSet<JobId>;
         completedJobsData: BoundedMap<JobId, Job>;
         jobResults: LRUMap<JobId, unknown>;
+        dependencyResults: DependencyResultTracker;
         jobLogs: LRUMap<JobId, JobLogEntry[]>;
         storage: SqliteStorage | null;
     };

package/dist/application/contextFactory.js

@@ -37,6 +37,7 @@ export class ContextFactory {
             depCompletions: this.deps.depCompletions,
             timedOutJobs: this.deps.timedOutJobs,
             jobResults: this.deps.jobResults,
+            dependencyResults: this.deps.dependencyResults,
             customIdMap: this.deps.customIdMap,
             jobLogs: this.deps.jobLogs,
             jobLocks: this.deps.jobLocks,
@@ -86,6 +87,7 @@ export class ContextFactory {
             depCompletions: this.deps.depCompletions,
             timedOutJobs: this.deps.timedOutJobs,
             jobResults: this.deps.jobResults,
+            dependencyResults: this.deps.dependencyResults,
             customIdMap: this.deps.customIdMap,
             jobIndex: this.deps.jobIndex,
             totalPushed: this.deps.metrics.totalPushed,
@@ -117,6 +119,7 @@ export class ContextFactory {
             completedJobsData: this.deps.completedJobsData,
             depCompletions: this.deps.depCompletions,
             jobResults: this.deps.jobResults,
+            dependencyResults: this.deps.dependencyResults,
             jobIndex: this.deps.jobIndex,
             customIdMap: this.deps.customIdMap,
             totalCompleted: this.deps.metrics.totalCompleted,
@@ -143,6 +146,7 @@ export class ContextFactory {
             jobIndex: this.deps.jobIndex,
             jobLocks: this.deps.jobLocks,
             clientJobs: this.deps.clientJobs,
+            dependencyResults: this.deps.dependencyResults,
             webhookManager: this.deps.webhookManager,
             eventsManager: this.deps.eventsManager,
             repeatChain: this.deps.repeatChain,
@@ -159,6 +163,7 @@ export class ContextFactory {
             completedJobs: this.deps.completedJobs,
             completedJobsData: this.deps.completedJobsData,
             jobResults: this.deps.jobResults,
+            dependencyResults: this.deps.dependencyResults,
             customIdMap: this.deps.customIdMap,
         };
     }
@@ -196,6 +201,7 @@ export class ContextFactory {
             completedJobs: this.deps.completedJobs,
             completedJobsData: this.deps.completedJobsData,
             jobResults: this.deps.jobResults,
+            dependencyResults: this.deps.dependencyResults,
             jobLogs: this.deps.jobLogs,
             storage: this.deps.storage,
         };

package/dist/application/dependencyResultTracker.d.ts

@@ -0,0 +1,17 @@
+import type { JobId } from '../domain/types/job';
+/**
+ * Retains results while at least one live dependency consumer may still read
+ * them. Ordinary completed-job results remain governed by the configured LRU.
+ */
+export declare class DependencyResultTracker {
+    private readonly consumersByDependency;
+    private readonly dependenciesByConsumer;
+    private readonly protectedResults;
+    registerConsumer(consumerId: JobId, dependencyIds: readonly JobId[]): void;
+    retain(dependencyId: JobId, result: unknown): void;
+    has(dependencyId: JobId): boolean;
+    get(dependencyId: JobId): unknown;
+    releaseConsumer(consumerId: JobId): void;
+    releaseDependency(consumerId: JobId, dependencyId: JobId): void;
+    clear(): void;
+}

package/dist/application/dependencyResultTracker.js

@@ -0,0 +1,71 @@
+/**
+ * Retains results while at least one live dependency consumer may still read
+ * them. Ordinary completed-job results remain governed by the configured LRU.
+ */
+export class DependencyResultTracker {
+    consumersByDependency = new Map();
+    dependenciesByConsumer = new Map();
+    protectedResults = new Map();
+    registerConsumer(consumerId, dependencyIds) {
+        if (dependencyIds.length === 0)
+            return;
+        let dependencies = this.dependenciesByConsumer.get(consumerId);
+        if (!dependencies) {
+            dependencies = new Set();
+            this.dependenciesByConsumer.set(consumerId, dependencies);
+        }
+        for (const dependencyId of dependencyIds) {
+            dependencies.add(dependencyId);
+            let consumers = this.consumersByDependency.get(dependencyId);
+            if (!consumers) {
+                consumers = new Set();
+                this.consumersByDependency.set(dependencyId, consumers);
+            }
+            consumers.add(consumerId);
+        }
+    }
+    retain(dependencyId, result) {
+        if (this.consumersByDependency.has(dependencyId)) {
+            this.protectedResults.set(dependencyId, result);
+        }
+    }
+    has(dependencyId) {
+        return this.protectedResults.has(dependencyId);
+    }
+    get(dependencyId) {
+        return this.protectedResults.get(dependencyId);
+    }
+    releaseConsumer(consumerId) {
+        const dependencies = this.dependenciesByConsumer.get(consumerId);
+        if (!dependencies)
+            return;
+        for (const dependencyId of dependencies) {
+            const consumers = this.consumersByDependency.get(dependencyId);
+            if (!consumers)
+                continue;
+            consumers.delete(consumerId);
+            if (consumers.size === 0) {
+                this.consumersByDependency.delete(dependencyId);
+                this.protectedResults.delete(dependencyId);
+            }
+        }
+        this.dependenciesByConsumer.delete(consumerId);
+    }
+    releaseDependency(consumerId, dependencyId) {
+        const dependencies = this.dependenciesByConsumer.get(consumerId);
+        dependencies?.delete(dependencyId);
+        if (dependencies?.size === 0)
+            this.dependenciesByConsumer.delete(consumerId);
+        const consumers = this.consumersByDependency.get(dependencyId);
+        consumers?.delete(consumerId);
+        if (consumers?.size === 0) {
+            this.consumersByDependency.delete(dependencyId);
+            this.protectedResults.delete(dependencyId);
+        }
+    }
+    clear() {
+        this.consumersByDependency.clear();
+        this.dependenciesByConsumer.clear();
+        this.protectedResults.clear();
+    }
+}

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

@@ -8,6 +8,7 @@ import type { Shard } from '../../domain/queue/shard';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { RWLock } from '../../shared/lock';
 import type { SetLike, MapLike } from '../../shared/lru';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
 /** Ack operation context */
 export interface AckContext {
     storage: SqliteStorage | null;
@@ -20,6 +21,7 @@ export interface AckContext {
     /** Bare completion ids for removeOnComplete jobs so dependents can unblock */
     depCompletions?: SetLike<JobId>;
     jobResults: MapLike<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
     jobIndex: Map<JobId, JobLocation>;
     customIdMap?: MapLike<string, JobId>;
     totalCompleted: {

package/dist/application/operations/ack.js

@@ -60,6 +60,9 @@ export async function ackJob(jobId, result, ctx) {
         // without making the job appear in state/stats queries.
         ctx.depCompletions?.add(jobId);
     }
+    if (result !== undefined)
+        ctx.dependencyResults.retain(jobId, result);
+    ctx.dependencyResults.releaseConsumer(jobId);
     ctx.totalCompleted.value++;
     if (ctx.perQueueMetrics) {
         const pq = ctx.perQueueMetrics.get(job.queue);
@@ -205,6 +208,9 @@ export async function failJob(jobId, error, ctx, unrecoverable = false, stack) {
             prev: 'failed',
         });
     }
+    else {
+        ctx.dependencyResults.releaseConsumer(jobId);
+    }
     // BullMQ v5: failParentOnFailure — propagate terminal failure to parent
     if (!wasRetried && job.failParentOnFailure && job.parentId && ctx.onChildTerminalFailure) {
         ctx.onChildTerminalFailure(job, error);

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

@@ -7,7 +7,7 @@ import type { Shard } from '../../domain/queue/shard';
 import type { RWLock } from '../../shared/lock';
 import type { SetLike, MapLike } from '../../shared/lru';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
-/** Extracted job with optional result */
+import type { DependencyResultTracker } from '../dependencyResultTracker';
 export interface ExtractedJob<T = unknown> {
     id: JobId;
     job: Job;
@@ -58,6 +58,7 @@ export interface FinalizeContext {
     /** Bare completion ids for removeOnComplete jobs so dependents can unblock */
     depCompletions?: SetLike<JobId>;
     jobResults: MapLike<JobId, unknown>;
+    dependencyResults?: DependencyResultTracker;
     jobIndex: Map<JobId, JobLocation>;
     customIdMap?: MapLike<string, JobId>;
     totalCompleted: {

package/dist/application/operations/ackHelpers.js

@@ -171,6 +171,12 @@ export function finalizeBatchAck(extractedJobs, ctx, includeResults) {
             ctx.depCompletions?.add(jobId);
         }
     }
+    for (let i = 0; i < jobCount; i++) {
+        const { id, result } = extractedJobs[i];
+        if (includeResults && result !== undefined)
+            ctx.dependencyResults?.retain(id, result);
+        ctx.dependencyResults?.releaseConsumer(id);
+    }
     // Broadcast events
     if (needsBroadcast) {
         for (let i = 0; i < jobCount; i++) {

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

@@ -9,6 +9,7 @@ import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { WebhookManager } from '../webhookManager';
 import type { EventsManager } from '../eventsManager';
 import { type RWLock } from '../../shared/lock';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
 export { discardJob, moveJobToDelayed } from './jobMoveOperations';
 /** Context for job management operations */
 export interface JobManagementContext {
@@ -23,6 +24,7 @@ export interface JobManagementContext {
     webhookManager: WebhookManager;
     eventsManager: EventsManager;
     repeatChain?: Map<JobId, JobId>;
+    dependencyResults: DependencyResultTracker;
 }
 /** Cancel a job (remove from queue) */
 export declare function cancelJob(jobId: JobId, ctx: JobManagementContext): Promise<boolean>;

package/dist/application/operations/jobManagement.js

@@ -22,6 +22,7 @@ export async function cancelJob(jobId, ctx) {
                     shard.releaseUniqueKey(location.queueName, job.uniqueKey);
                 ctx.jobIndex.delete(jobId);
                 ctx.storage?.deleteJob(jobId);
+                ctx.dependencyResults.releaseConsumer(jobId);
                 return { success: true, queueName: location.queueName };
             }
             // Not in the run queue — it may be parked in waitingChildren (moved via
@@ -32,6 +33,7 @@ export async function cancelJob(jobId, ctx) {
                 shard.waitingChildren.delete(jobId);
                 ctx.jobIndex.delete(jobId);
                 ctx.storage?.deleteJob(jobId);
+                ctx.dependencyResults.releaseConsumer(jobId);
                 return { success: true, queueName: location.queueName };
             }
             // Or parked in waitingDeps (flow-chain dependent inserted by push.ts while
@@ -47,6 +49,7 @@ export async function cancelJob(jobId, ctx) {
                     shard.releaseUniqueKey(location.queueName, waiting.uniqueKey);
                 ctx.jobIndex.delete(jobId);
                 ctx.storage?.deleteJob(jobId);
+                ctx.dependencyResults.releaseConsumer(jobId);
                 return { success: true, queueName: location.queueName };
             }
             return { success: false, queueName: location.queueName };

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

@@ -8,6 +8,7 @@ import type { Shard } from '../../domain/queue/shard';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { RWLock } from '../../shared/lock';
 import type { SetLike, MapLike } from '../../shared/lru';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
 /** Push operation context */
 export interface PushContext {
     storage: SqliteStorage | null;
@@ -20,6 +21,7 @@ export interface PushContext {
     /** Timeout markers — cleared on custom-id reuse so a recycled id starts clean */
     timedOutJobs?: SetLike<JobId>;
     jobResults: MapLike<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
     customIdMap: MapLike<string, JobId>;
     jobIndex: Map<JobId, JobLocation>;
     totalPushed: {

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

@@ -2,9 +2,13 @@ import type { Shard } from '../../domain/queue/shard';
 import type { Job, JobId } from '../../domain/types/job';
 import type { JobLocation } from '../../domain/types/queue';
 import type { SetLike } from '../../shared/lru';
+import type { MapLike } from '../../shared/lru';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
 export interface PushInsertContext {
     completedJobs: SetLike<JobId>;
     depCompletions?: SetLike<JobId>;
+    jobResults: MapLike<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
     jobIndex: Map<JobId, JobLocation>;
     dashboardEmit?: (event: string, data: Record<string, unknown>) => void;
 }

package/dist/application/operations/pushInsert.js

@@ -22,4 +22,10 @@ export function insertJobToShard(job, queue, shard, shardIdx, ctx) {
         job.timeline.push({ state, timestamp: now });
     }
     ctx.jobIndex.set(job.id, { type: 'queue', shardIdx, queueName: queue });
+    ctx.dependencyResults.registerConsumer(job.id, job.dependsOn);
+    for (const dependencyId of job.dependsOn) {
+        if (ctx.jobResults.has(dependencyId)) {
+            ctx.dependencyResults.retain(dependencyId, ctx.jobResults.get(dependencyId));
+        }
+    }
 }

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

@@ -9,6 +9,7 @@ import type { Shard } from '../../domain/queue/shard';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import { type RWLock } from '../../shared/lock';
 import type { SetLike, MapLike } from '../../shared/lru';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
 /** Context for query operations */
 export interface QueryContext {
     storage: SqliteStorage | null;
@@ -20,6 +21,7 @@ export interface QueryContext {
     completedJobs: SetLike<JobId>;
     completedJobsData: MapLike<JobId, Job>;
     jobResults: MapLike<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
     customIdMap: MapLike<string, JobId>;
 }
 /** Get job by ID */

package/dist/application/operations/queryOperations.js

@@ -78,7 +78,11 @@ export async function getJob(jobId, ctx) {
 }
 /** Get job result */
 export function getJobResult(jobId, ctx) {
-    return ctx.jobResults.get(jobId) ?? ctx.storage?.getResult(jobId);
+    if (ctx.jobResults.has(jobId))
+        return ctx.jobResults.get(jobId);
+    if (ctx.dependencyResults.has(jobId))
+        return ctx.dependencyResults.get(jobId);
+    return ctx.storage?.getResult(jobId);
 }
 /** Get job by custom ID */
 export function getJobByCustomId(customId, ctx) {

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

@@ -6,6 +6,7 @@ import type { Job, JobId } from '../../domain/types/job';
 import type { Shard } from '../../domain/queue/shard';
 import type { SqliteStorage } from '../../infrastructure/persistence/sqlite';
 import type { MapLike, SetLike } from '../../shared/lru';
+import type { DependencyResultTracker } from '../dependencyResultTracker';
 /** Context for queue control operations */
 export interface QueueControlContext {
     shards: Shard[];
@@ -19,6 +20,7 @@ export interface QueueControlContext {
     completedJobsData?: MapLike<JobId, Job>;
     jobResults?: MapLike<JobId, unknown>;
     jobLogs?: MapLike<JobId, unknown>;
+    dependencyResults: DependencyResultTracker;
     storage: SqliteStorage | null;
 }
 /** Pause a queue */

package/dist/application/operations/queueControl.js

@@ -28,6 +28,7 @@ export function drainQueue(queue, ctx) {
     // (not-yet-flushed) add cannot land on disk after the drain.
     for (const jobId of jobIds) {
         ctx.jobIndex.delete(jobId);
+        ctx.dependencyResults.releaseConsumer(jobId);
         safeDeleteJob(ctx, jobId);
     }
     return count;
@@ -84,6 +85,7 @@ function cleanWaitingLike(queue, graceMs, ctx, maxJobs) {
             shard.decrementQueued(jobId);
             shard.removeFromTemporalIndex(jobId);
             ctx.jobIndex.delete(jobId);
+            ctx.dependencyResults.releaseConsumer(jobId);
             safeDeleteJob(ctx, jobId);
             removed.push(jobId);
         }
@@ -112,6 +114,7 @@ function cleanCompleted(queue, graceMs, ctx, maxJobs) {
         ctx.jobResults?.delete(jid);
         ctx.jobLogs?.delete(jid);
         ctx.jobIndex.delete(jid);
+        ctx.dependencyResults.releaseConsumer(jid);
         safeDeleteJob(ctx, jid);
     }
     return toRemove;
@@ -133,6 +136,7 @@ function cleanFailed(queue, graceMs, ctx, maxJobs) {
     for (const jid of toRemove) {
         shard.removeFromDlq(queue, jid);
         ctx.jobIndex.delete(jid);
+        ctx.dependencyResults.releaseConsumer(jid);
         ctx.jobResults?.delete(jid);
         ctx.jobLogs?.delete(jid);
         safeDeleteDlqEntry(ctx, jid);

package/dist/application/queueManager.d.ts

@@ -31,6 +31,7 @@ export declare class QueueManager {
     private readonly depCompletions;
     private readonly timedOutJobs;
     private readonly jobResults;
+    private readonly dependencyResults;
     private readonly customIdMap;
     private readonly jobLogs;
     private readonly pendingDepChecks;

package/dist/application/queueManager.js

@@ -32,6 +32,7 @@ import * as statsMgr from './statsManager';
 import { ContextFactory } from './contextFactory';
 import { processPendingDependencies } from './dependencyProcessor';
 import { handleTaskError, handleTaskSuccess } from './taskErrorTracking';
+import { DependencyResultTracker } from './dependencyResultTracker';
 /**
  * QueueManager - Central coordinator
  */
@@ -58,6 +59,7 @@ export class QueueManager {
     // current token and bypasses the stale-token recovery path entirely.
     timedOutJobs;
     jobResults;
+    dependencyResults = new DependencyResultTracker();
     customIdMap;
     jobLogs;
     // Deferred dependency resolution queue
@@ -178,6 +180,7 @@ export class QueueManager {
             depCompletions: this.depCompletions,
             timedOutJobs: this.timedOutJobs,
             jobResults: this.jobResults,
+            dependencyResults: this.dependencyResults,
             customIdMap: this.customIdMap,
             jobLogs: this.jobLogs,
             jobLocks: this.jobLocks,
@@ -541,6 +544,9 @@ export class QueueManager {
             ctx.jobIndex.delete(jId);
             ctx.storage?.deleteJob(jId);
         }
+        if (result !== undefined)
+            ctx.dependencyResults.retain(jId, result);
+        ctx.dependencyResults.releaseConsumer(jId);
         ctx.totalCompleted.value++;
         ctx.broadcast({
             eventType: 'completed',
@@ -769,6 +775,7 @@ export class QueueManager {
             this.jobResults.delete(jid);
             this.jobLogs.delete(jid);
             this.jobLocks.delete(jid);
+            this.dependencyResults.releaseConsumer(jid);
             this.failedChildrenValues.delete(jid);
             this.ignoredChildrenFailures.delete(jid);
             this.pendingDepChecks.delete(jid);
@@ -1259,6 +1266,7 @@ export class QueueManager {
         // Parent reached a terminal (DLQ) state — release its flow-failure tracking.
         this.failedChildrenValues.delete(parentId);
         this.ignoredChildrenFailures.delete(parentId);
+        this.dependencyResults.releaseConsumer(parentId);
         // Broadcast failed event for parent
         this.eventsManager.broadcast({
             eventType: 'failed',
@@ -1396,6 +1404,7 @@ export class QueueManager {
             if (depIndex !== -1) {
                 parentJob.dependsOn.splice(depIndex, 1);
                 shard.unregisterDependencies(parentId, [childJob.id]);
+                this.dependencyResults.releaseDependency(parentId, childJob.id);
             }
             // If no more pending deps, the parent is ready to be promoted
             readyToPromote =
@@ -1449,6 +1458,7 @@ export class QueueManager {
             if (depIndex !== -1) {
                 parentJob.dependsOn.splice(depIndex, 1);
                 shard.unregisterDependencies(parentId, [childJobId]);
+                this.dependencyResults.releaseDependency(parentId, childJobId);
             }
             const allDone = parentJob.dependsOn.length === 0 ||
                 parentJob.dependsOn.every((dep) => this.completedJobs.has(dep));
@@ -1615,6 +1625,7 @@ export class QueueManager {
         this.depCompletions.clear();
         this.timedOutJobs.clear();
         this.jobResults.clear();
+        this.dependencyResults.clear();
         this.jobLogs.clear();
         this.customIdMap.clear();
         this.pendingDepChecks.clear();

package/dist/application/types.d.ts

@@ -12,6 +12,7 @@ import type { EventsManager } from './eventsManager';
 import type { WebhookManager } from './webhookManager';
 import type { WorkerManager } from './workerManager';
 import type { MonitoringState } from './monitoringChecks';
+import type { DependencyResultTracker } from './dependencyResultTracker';
 /** Queue Manager configuration */
 export interface QueueManagerConfig {
     dataPath?: string;
@@ -52,6 +53,7 @@ export interface QueueManagerState {
     readonly jobIndex: Map<JobId, JobLocation>;
     readonly completedJobs: BoundedSet<JobId>;
     readonly jobResults: LRUMap<JobId, unknown>;
+    readonly dependencyResults: DependencyResultTracker;
     readonly customIdMap: LRUMap<string, JobId>;
     readonly jobLogs: LRUMap<JobId, JobLogEntry[]>;
     readonly jobLocks: Map<JobId, JobLock>;

package/dist/infrastructure/server/tcp.js

@@ -144,12 +144,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
@@ -194,11 +188,24 @@ export function createTcpServer(queueManager, config) {
                     cmd = unpack(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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunqueue",
-  "version": "2.8.38",
+  "version": "2.8.39",
   "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",