bunqueue 2.8.38 → 2.8.40

package/dist/application/backgroundTasks.js

@@ -208,6 +208,9 @@ export function recover(ctx) {
         if (qs.stallConfig) {
             ctx.shards[shardIndex(qs.name)].setStallConfig(qs.name, qs.stallConfig);
         }
+        if (qs.dlqConfig) {
+            ctx.shards[shardIndex(qs.name)].setDlqConfig(qs.name, qs.dlqConfig);
+        }
     }
     const now = Date.now();
     // === PHASE 1: Recover active jobs (were processing when server stopped) ===
@@ -324,6 +327,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 };
@@ -75,10 +78,13 @@ export async function updateJobProgress(jobId, progress, ctx, message) {
         const job = ctx.processingShards[procIdx].get(jobId);
         if (!job)
             return false;
-        job.progress = Math.max(0, Math.min(100, progress));
-        if (message !== undefined)
-            job.progressMessage = message;
-        job.lastHeartbeat = Date.now();
+        const clampedProgress = Math.max(0, Math.min(100, progress));
+        const effectiveMessage = message === undefined ? job.progressMessage : message;
+        const heartbeat = Date.now();
+        ctx.storage?.updateJobProgress(jobId, clampedProgress, effectiveMessage, heartbeat);
+        job.progress = clampedProgress;
+        job.progressMessage = effectiveMessage;
+        job.lastHeartbeat = heartbeat;
         // Broadcast progress event to internal subscribers
         ctx.eventsManager.broadcast({
             eventType: 'progress',

package/dist/application/operations/jobStateTransitions.js

@@ -37,6 +37,7 @@ export async function moveActiveToWait(jobId, ctx) {
         ctx.jobIndex.set(jobId, { type: 'queue', shardIdx: idx, queueName: job.queue });
         shard.notify(job.queue);
     });
+    ctx.storage?.updateRunAt(jobId, job.runAt);
     ctx.eventsManager.broadcast({
         eventType: 'waiting',
         jobId,

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

@@ -29,8 +29,8 @@ export interface PullContext {
 /**
  * Pull next job from queue
  */
-export declare function pullJob(queue: string, timeoutMs: number, ctx: PullContext): Promise<Job | null>;
+export declare function pullJob(queue: string, timeoutMs: number, ctx: PullContext, signal?: AbortSignal): Promise<Job | null>;
 /**
  * Pull multiple jobs from queue
  */
-export declare function pullJobBatch(queue: string, count: number, timeoutMs: number, ctx: PullContext): Promise<Job[]>;
+export declare function pullJobBatch(queue: string, count: number, timeoutMs: number, ctx: PullContext, signal?: AbortSignal): Promise<Job[]>;

package/dist/application/operations/pull.js

@@ -122,10 +122,11 @@ function tryDequeueNextJob(shard, queue, now, ctx) {
     }
 }
 /** Wait until either a notification arrives, the next delay matures, or the pull deadline. */
-async function waitForNextCandidate(shard, queue, deadline, now, nextRunAt) {
+async function waitForNextCandidate(options) {
+    const { shard, queue, deadline, now, nextRunAt, signal } = options;
     const remaining = deadline - now;
     const untilNextRun = nextRunAt === null ? remaining : Math.max(1, nextRunAt - now);
-    await shard.waitForJob(queue, Math.min(remaining, untilNextRun));
+    await shard.waitForJob(queue, Math.min(remaining, untilNextRun), signal);
 }
 /**
  * Finish the handoff of a dequeued job: persist active state and broadcast.
@@ -217,14 +218,20 @@ async function requeueJob(job, queue, idx, ctx) {
 /**
  * Pull next job from queue
  */
-export async function pullJob(queue, timeoutMs, ctx) {
+export async function pullJob(queue, timeoutMs, ctx, signal) {
     const startNs = Bun.nanoseconds();
     const deadline = timeoutMs > 0 ? Date.now() + timeoutMs : 0;
     const idx = shardIndex(queue);
     while (true) {
-        const attempt = await tryPullFromShard(queue, idx, ctx);
+        if (signal?.aborted)
+            return null;
+        const attempt = await tryPullFromShard(queue, idx, ctx, signal);
         const job = attempt.job;
         if (job) {
+            if (signal?.aborted) {
+                await requeueJob(job, queue, idx, ctx);
+                return null;
+            }
             let delivered = false;
             try {
                 delivered = finalizeProcessing(job, queue, ctx);
@@ -246,14 +253,23 @@ export async function pullJob(queue, timeoutMs, ctx) {
         if (deadline === 0 || now >= deadline) {
             return null;
         }
-        await waitForNextCandidate(ctx.shards[idx], queue, deadline, now, attempt.nextRunAt);
+        await waitForNextCandidate({
+            shard: ctx.shards[idx],
+            queue,
+            deadline,
+            now,
+            nextRunAt: attempt.nextRunAt,
+            signal,
+        });
     }
 }
 /**
  * Try to pull a job from a specific shard
  */
-async function tryPullFromShard(queue, idx, ctx) {
+async function tryPullFromShard(queue, idx, ctx, signal) {
     return await withWriteLock(ctx.shardLocks[idx], () => {
+        if (signal?.aborted)
+            return { job: null, nextRunAt: null };
         const shard = ctx.shards[idx];
         const state = shard.getState(queue);
         if (state.paused) {
@@ -269,14 +285,22 @@ async function tryPullFromShard(queue, idx, ctx) {
 /**
  * Pull multiple jobs from queue
  */
-export async function pullJobBatch(queue, count, timeoutMs, ctx) {
+export async function pullJobBatch(queue, count, timeoutMs, ctx, signal) {
     const startNs = Bun.nanoseconds();
     const deadline = timeoutMs > 0 ? Date.now() + timeoutMs : 0;
     const idx = shardIndex(queue);
     while (true) {
-        const attempt = await tryPullBatchFromShard(queue, idx, count, ctx);
+        if (signal?.aborted)
+            return [];
+        const attempt = await tryPullBatchFromShard(queue, idx, count, ctx, signal);
         const jobs = attempt.jobs;
         if (jobs.length > 0) {
+            if (signal?.aborted) {
+                for (const job of jobs) {
+                    await requeueJob(job, queue, idx, ctx);
+                }
+                return [];
+            }
             let delivered;
             try {
                 delivered = finalizeProcessingBatch(jobs, queue, ctx);
@@ -305,14 +329,23 @@ export async function pullJobBatch(queue, count, timeoutMs, ctx) {
         if (deadline === 0 || now >= deadline) {
             return [];
         }
-        await waitForNextCandidate(ctx.shards[idx], queue, deadline, now, attempt.nextRunAt);
+        await waitForNextCandidate({
+            shard: ctx.shards[idx],
+            queue,
+            deadline,
+            now,
+            nextRunAt: attempt.nextRunAt,
+            signal,
+        });
     }
 }
 /**
  * Try to pull multiple jobs from a shard
  */
-async function tryPullBatchFromShard(queue, idx, count, ctx) {
+async function tryPullBatchFromShard(queue, idx, count, ctx, signal) {
     return await withWriteLock(ctx.shardLocks[idx], () => {
+        if (signal?.aborted)
+            return { jobs: [], nextRunAt: null };
         const shard = ctx.shards[idx];
         const state = shard.getState(queue);
         const jobs = [];

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);