bunqueue 2.8.53 → 2.8.54

package/dist/application/backgroundTasks.js

@@ -326,7 +326,11 @@ export function recover(ctx) {
             const needsWaitingDeps = hasDependencies &&
                 !wasAlreadyPromoted &&
                 !job.dependsOn.every((depId) => ctx.completedJobs.has(depId) || completedInDb.has(depId));
-            if (needsWaitingDeps) {
+            const manuallyWaitingChildren = recoveredState === 'waiting-children' && !hasDependencies;
+            if (manuallyWaitingChildren) {
+                shard.waitingChildren.set(job.id, job);
+            }
+            else if (needsWaitingDeps) {
                 // Job is waiting for dependencies - don't add to main queue
                 shard.waitingDeps.set(job.id, job);
                 shard.registerDependencies(job.id, job.dependsOn);

package/dist/application/cleanupTasks.js

@@ -85,7 +85,7 @@ async function cleanStaleWaitingDependencies(ctx, now) {
                 shard.unregisterDependencies(job.id, job.dependsOn);
                 released.push(...job.dependsOn);
                 if (job.uniqueKey && shard.getUniqueKeyEntry(job.queue, job.uniqueKey)?.jobId === job.id) {
-                    shard.releaseUniqueKey(job.queue, job.uniqueKey);
+                    shard.releaseUniqueKeyIfOwned(job.queue, job.uniqueKey, job.id);
                 }
                 if (job.customId && ctx.customIdMap.get(job.customId) === job.id) {
                     ctx.customIdMap.delete(job.customId);

package/dist/application/clientTracking.js

@@ -179,7 +179,7 @@ function releaseJobToQueue(opts) {
     // Release lock if exists
     ctx.jobLocks.delete(jobId);
     // Release all job resources (concurrency, uniqueKey, groupId)
-    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
     // Discard cron jobs with preventOverlap instead of re-queuing (#73).
     // The cron scheduler will re-create them at the next scheduled tick.
     // Re-queuing them causes the "starts right away on reconnect" bug.

package/dist/application/contextFactory.js

@@ -191,6 +191,7 @@ export class ContextFactory {
             jobLogs: this.deps.jobLogs,
             storage: this.deps.storage,
             completedJobs: this.deps.completedJobs,
+            completedJobsData: this.deps.completedJobsData,
             jobResults: this.deps.jobResults,
         };
     }

package/dist/application/dlqManager.d.ts

@@ -47,9 +47,15 @@ export interface RetryCompletedContext extends DlqContext {
         has(id: JobId): boolean;
         delete(id: JobId): boolean;
     } & Iterable<JobId>;
+    completedJobsData: {
+        get(id: JobId): Job | undefined;
+    };
     jobResults: {
         delete(id: JobId): boolean;
     };
 }
 /** Retry completed jobs */
-export declare function retryCompletedJobs(queue: string, ctx: RetryCompletedContext, jobId?: JobId): number;
+export declare function retryCompletedJobs(queue: string, ctx: RetryCompletedContext, jobId?: JobId, options?: {
+    limit?: number;
+    timestamp?: number;
+}): number;

package/dist/application/dlqManager.js

@@ -260,20 +260,31 @@ export function getDlqConfig(queue, ctx) {
     return ctx.shards[idx].getDlqConfig(queue);
 }
 /** Retry completed jobs */
-export function retryCompletedJobs(queue, ctx, jobId) {
+export function retryCompletedJobs(queue, ctx, jobId, options = {}) {
     if (jobId) {
         if (!ctx.completedJobs.has(jobId))
             return 0;
-        const job = ctx.storage?.getJob(jobId);
+        const job = ctx.completedJobsData.get(jobId) ?? ctx.storage?.getJob(jobId);
         if (job?.queue !== queue)
             return 0;
         return requeueCompletedJob(job, ctx);
     }
+    const limit = options.limit === undefined
+        ? Number.POSITIVE_INFINITY
+        : Number.isFinite(options.limit) && options.limit > 0
+            ? Math.floor(options.limit)
+            : 0;
+    if (limit === 0)
+        return 0;
+    const timestamp = options.timestamp ?? Number.POSITIVE_INFINITY;
     let count = 0;
-    for (const id of ctx.completedJobs) {
-        const job = ctx.storage?.getJob(id);
-        if (job?.queue === queue)
+    for (const id of [...ctx.completedJobs]) {
+        if (count >= limit)
+            break;
+        const job = ctx.completedJobsData.get(id) ?? ctx.storage?.getJob(id);
+        if (job?.queue === queue && job.completedAt !== null && job.completedAt <= timestamp) {
             count += requeueCompletedJob(job, ctx);
+        }
     }
     return count;
 }

package/dist/application/lockManager.js

@@ -81,7 +81,7 @@ function processExpiredLockInner(jobId, lock, job, shardIdx, procIdx, ctx, now)
     // the job finishes. Re-queuing would cause "starts right away on reconnect".
     // The cron scheduler will re-create the job at the next scheduled tick.
     if (job.uniqueKey?.startsWith('cron:')) {
-        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
         ctx.jobIndex.delete(jobId);
         ctx.storage?.deleteJob(jobId);
         ctx.jobLocks.delete(jobId);
@@ -124,7 +124,7 @@ function handleRecoveryBoundExceeded(opts) {
     // Release the concurrency slot (+group+uniqueKey) acquired at pull before
     // moving to DLQ — otherwise the slot leaks (mirrors
     // stallDetection.moveStalliedJobToDlq).
-    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
     const entry = shard.addToDlq(job, attemptsExhausted ? "max_attempts_exceeded" /* FailureReason.MaxAttemptsExceeded */ : "stalled" /* FailureReason.Stalled */, attemptsExhausted
         ? `Lock expired at max attempts (${job.maxAttempts})`
         : `Lock expired after ${lock.renewalCount} renewals`);
@@ -153,7 +153,7 @@ function requeueExpiredJob(opts) {
     // Release the concurrency slot (+group+uniqueKey) acquired at pull before
     // re-pushing — otherwise the slot leaks and the queue wedges (mirrors
     // stallDetection.retryStalliedJob).
-    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
     queue.push(job);
     const isDelayed = job.runAt > now;
     shard.incrementQueued(jobId, isDelayed, job.createdAt, job.queue, job.runAt);

package/dist/application/operations/ack.js

@@ -28,7 +28,7 @@ export async function ackJob(jobId, result, ctx) {
     const idx = shardIndex(job.queue);
     await withWriteLock(ctx.shardLocks[idx], () => {
         const shard = ctx.shards[idx];
-        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
         // Releasing either queue concurrency or an active FIFO group can make a
         // parked job eligible. Wake only waiters for this queue.
         shard.notify(job.queue);
@@ -176,7 +176,7 @@ export async function failJob(jobId, error, ctx, unrecoverable = false, stack) {
     const flowFailure = willRetry ? null : flowFailureRecord(job, error);
     await withWriteLock(ctx.shardLocks[idx], () => {
         const shard = ctx.shards[idx];
-        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
         if (willRetry) {
             const now = Date.now();
             job.runAt = now + calculateBackoff(job);

package/dist/application/operations/ackHelpers.js

@@ -97,7 +97,7 @@ export async function releaseResources(byQueueShard, ctx) {
         await withWriteLock(ctx.shardLocks[idx], () => {
             const shard = ctx.shards[idx];
             for (const job of jobs) {
-                shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+                shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
             }
         });
     }));

package/dist/application/operations/jobManagement.js

@@ -19,8 +19,9 @@ export async function cancelJob(jobId, ctx) {
             if (job) {
                 // Update running counters for O(1) stats
                 shard.decrementQueued(jobId);
-                if (job.uniqueKey)
-                    shard.releaseUniqueKey(location.queueName, job.uniqueKey);
+                if (job.uniqueKey) {
+                    shard.releaseUniqueKeyIfOwned(location.queueName, job.uniqueKey, job.id);
+                }
                 ctx.jobIndex.delete(jobId);
                 ctx.storage?.deleteJob(jobId);
                 ctx.dependencyResults.releaseConsumer(jobId);
@@ -46,8 +47,9 @@ export async function cancelJob(jobId, ctx) {
             if (waiting) {
                 shard.waitingDeps.delete(jobId);
                 shard.unregisterDependencies(jobId, waiting.dependsOn);
-                if (waiting.uniqueKey)
-                    shard.releaseUniqueKey(location.queueName, waiting.uniqueKey);
+                if (waiting.uniqueKey) {
+                    shard.releaseUniqueKeyIfOwned(location.queueName, waiting.uniqueKey, waiting.id);
+                }
                 ctx.jobIndex.delete(jobId);
                 ctx.storage?.deleteJob(jobId);
                 ctx.dependencyResults.releaseConsumer(jobId);

package/dist/application/operations/jobMoveOperations.js

@@ -27,7 +27,7 @@ export async function moveJobToDelayed(jobId, delay, ctx) {
     const queueName = job.queue;
     await withWriteLock(ctx.shardLocks[idx], () => {
         const shard = ctx.shards[idx];
-        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
         shard.getQueue(job.queue).push(job);
         const isDelayed = job.runAt > now;
         shard.incrementQueued(jobId, isDelayed, job.createdAt, job.queue, job.runAt);
@@ -78,11 +78,11 @@ export async function discardJob(jobId, ctx) {
     const entry = await withWriteLock(ctx.shardLocks[idx], () => {
         const shard = ctx.shards[idx];
         if (fromProcessing) {
-            shard.releaseJobResources(validJob.queue, validJob.uniqueKey, validJob.groupId);
+            shard.releaseJobResources(validJob.queue, validJob.uniqueKey, validJob.groupId, validJob.id);
             shard.notify(validJob.queue);
         }
         else if (validJob.uniqueKey) {
-            shard.releaseUniqueKey(validJob.queue, validJob.uniqueKey);
+            shard.releaseUniqueKeyIfOwned(validJob.queue, validJob.uniqueKey, validJob.id);
         }
         const dlqEntry = shard.addToDlq(validJob);
         ctx.jobIndex.set(jobId, { type: 'dlq', queueName: validJob.queue });

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

@@ -5,7 +5,7 @@
  * - changeWaitingDelay: Waiting -> Delayed
  * - moveToWaitingChildren: Active -> WaitingChildren
  */
-import type { JobId } from '../../domain/types/job';
+import { type JobId } from '../../domain/types/job';
 import type { JobManagementContext } from './jobManagement';
 /** Move active job back to waiting */
 export declare function moveActiveToWait(jobId: JobId, ctx: JobManagementContext): Promise<boolean>;

package/dist/application/operations/jobStateTransitions.js

@@ -5,6 +5,7 @@
  * - changeWaitingDelay: Waiting -> Delayed
  * - moveToWaitingChildren: Active -> WaitingChildren
  */
+import { MAX_TIMELINE_ENTRIES } from '../../domain/types/job';
 import { shardIndex, processingShardIndex } from '../../shared/hash';
 import { withWriteLock } from '../../shared/lock';
 import { releaseClaimedJobOwnership } from './jobClaim';
@@ -31,7 +32,7 @@ export async function moveActiveToWait(jobId, ctx) {
     await withWriteLock(ctx.shardLocks[idx], () => {
         const shard = ctx.shards[idx];
         // Release concurrency/uniqueKey/group slots before re-queueing
-        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
         shard.getQueue(job.queue).push(job);
         shard.incrementQueued(jobId, false, job.createdAt, job.queue, job.runAt);
         ctx.jobIndex.set(jobId, { type: 'queue', shardIdx: idx, queueName: job.queue });
@@ -82,13 +83,26 @@ export async function moveToWaitingChildren(jobId, ctx) {
     });
     if (!job)
         return false;
+    const now = Date.now();
+    job.startedAt = null;
+    if (job.timeline.length < MAX_TIMELINE_ENTRIES) {
+        job.timeline.push({ state: 'waiting-children', timestamp: now });
+    }
     const idx = shardIndex(job.queue);
     await withWriteLock(ctx.shardLocks[idx], () => {
         const shard = ctx.shards[idx];
         // Release concurrency/uniqueKey/group slots before moving to waitingChildren
-        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
         shard.waitingChildren.set(jobId, job);
         ctx.jobIndex.set(jobId, { type: 'queue', shardIdx: idx, queueName: job.queue });
     });
+    ctx.storage?.markWaitingChildren(jobId, job.timeline);
+    ctx.eventsManager.broadcast({
+        eventType: "waiting-children" /* EventType.WaitingChildren */,
+        jobId,
+        queue: job.queue,
+        timestamp: now,
+        prev: 'active',
+    });
     return true;
 }

package/dist/application/queueManager.d.ts

@@ -202,8 +202,12 @@ export declare class QueueManager {
     getDlqCount(queue: string): number;
     getDlqStats(queue: string): DlqStats;
     retryDlq(queue: string, jobId?: JobId, limit?: number): number;
+    retryDlqByFilter(queue: string, filter: DlqFilter): number;
     purgeDlq(queue: string): number;
-    retryCompleted(queue: string, jobId?: JobId): number;
+    retryCompleted(queue: string, jobId?: JobId, options?: {
+        limit?: number;
+        timestamp?: number;
+    }): number;
     setRateLimit(queue: string, limit: number, durationMs?: number, ttlMs?: number): void;
     clearRateLimit(queue: string): void;
     setConcurrency(queue: string, limit: number): void;
@@ -214,11 +218,27 @@ export declare class QueueManager {
      * Reads the post-mutation state from the owning shard and UPSERTs the row.
      */
     private persistQueueState;
-    /** Get rate limit and concurrency limit for a queue */
+    /** Get configured scalar limits (retained for internal/cloud compatibility). */
     getQueueLimits(queue: string): {
         rateLimit: number | null;
         concurrencyLimit: number | null;
     };
+    /** Get the full live limit status exposed by public Queue getters. */
+    getQueueLimitStatus(queue: string, maxJobs?: number): {
+        rateLimit: {
+            max: number;
+            duration: number;
+        } | null;
+        rateLimitTtl: number;
+        concurrencyLimit: number | null;
+        maxed: boolean;
+    };
+    /** Resolve the current owner of a queue-scoped deduplication key. */
+    getDeduplicationJobId(queue: string, key: string): string | null;
+    /** Release the current owner of a queue-scoped deduplication key. */
+    removeDeduplicationKey(queue: string, key: string): Promise<number>;
+    /** Release only the deduplication key still owned by a specific job. */
+    removeJobDeduplicationKey(id: string): Promise<boolean>;
     /** Get all job results (for cloud telemetry) */
     getAllJobResults(): Map<JobId, unknown>;
     /** Get all job logs (for cloud telemetry) */

package/dist/application/queueManager.js

@@ -2,7 +2,7 @@
  * Queue Manager
  * Core orchestrator for all queue operations
  */
-import { DEFAULT_LOCK_TTL } from '../domain/types/job';
+import { DEFAULT_LOCK_TTL, jobId } from '../domain/types/job';
 import { DEFAULT_STALL_CONFIG } from '../domain/types/stall';
 import { DEFAULT_DLQ_CONFIG } from '../domain/types/dlq';
 import { Shard } from '../domain/queue/shard';
@@ -550,7 +550,7 @@ export class QueueManager {
             job = pq.remove(jId);
             if (job) {
                 shard.decrementQueued(jId);
-                shard.releaseJobResources(queueName, job.uniqueKey, job.groupId);
+                shard.releaseJobResources(queueName, job.uniqueKey, job.groupId, job.id);
             }
         });
         if (!job) {
@@ -974,11 +974,14 @@ export class QueueManager {
     retryDlq(queue, jobId, limit) {
         return dlqOps.retryDlqJobs(queue, this.contextFactory.getDlqContext(), jobId, limit);
     }
+    retryDlqByFilter(queue, filter) {
+        return dlqOps.retryDlqByFilter(queue, this.contextFactory.getDlqContext(), filter);
+    }
     purgeDlq(queue) {
         return dlqOps.purgeDlqJobs(queue, this.contextFactory.getDlqContext());
     }
-    retryCompleted(queue, jobId) {
-        return dlqOps.retryCompletedJobs(queue, this.contextFactory.getRetryCompletedContext(), jobId);
+    retryCompleted(queue, jobId, options) {
+        return dlqOps.retryCompletedJobs(queue, this.contextFactory.getRetryCompletedContext(), jobId, options);
     }
     // ============ Rate Limiting ============
     setRateLimit(queue, limit, durationMs, ttlMs) {
@@ -1039,14 +1042,53 @@ export class QueueManager {
             dlqConfig,
         });
     }
-    /** Get rate limit and concurrency limit for a queue */
+    /** Get configured scalar limits (retained for internal/cloud compatibility). */
     getQueueLimits(queue) {
         const shard = this.shards[shardIndex(queue)];
-        // Lazy TTL expiry so reads never report a limit that no longer throttles.
         shard.expireRateLimitIfNeeded(queue);
         const state = shard.getState(queue);
         return { rateLimit: state.rateLimit, concurrencyLimit: state.concurrencyLimit };
     }
+    /** Get the full live limit status exposed by public Queue getters. */
+    getQueueLimitStatus(queue, maxJobs) {
+        const shard = this.shards[shardIndex(queue)];
+        return {
+            rateLimit: shard.getRateLimit(queue),
+            rateLimitTtl: shard.getRateLimitTtl(queue, maxJobs),
+            concurrencyLimit: shard.getConcurrency(queue),
+            maxed: shard.isConcurrencyMaxed(queue),
+        };
+    }
+    /** Resolve the current owner of a queue-scoped deduplication key. */
+    getDeduplicationJobId(queue, key) {
+        return this.shards[shardIndex(queue)].getUniqueKeyEntry(queue, key)?.jobId ?? null;
+    }
+    /** Release the current owner of a queue-scoped deduplication key. */
+    async removeDeduplicationKey(queue, key) {
+        const idx = shardIndex(queue);
+        return withWriteLock(this.shardLocks[idx], () => {
+            const shard = this.shards[idx];
+            const owner = shard.getUniqueKeyEntry(queue, key)?.jobId;
+            if (!owner || !shard.releaseUniqueKeyIfOwned(queue, key, owner))
+                return 0;
+            this.storage?.clearJobUniqueKey(owner);
+            return 1;
+        });
+    }
+    /** Release only the deduplication key still owned by a specific job. */
+    async removeJobDeduplicationKey(id) {
+        const jid = jobId(id);
+        const job = await this.getJob(jid);
+        if (!job?.uniqueKey)
+            return false;
+        const idx = shardIndex(job.queue);
+        return withWriteLock(this.shardLocks[idx], () => {
+            const removed = this.shards[idx].releaseUniqueKeyIfOwned(job.queue, job.uniqueKey, jid);
+            if (removed)
+                this.storage?.clearJobUniqueKey(jid);
+            return removed;
+        });
+    }
     /** Get all job results (for cloud telemetry) */
     getAllJobResults() {
         const map = new Map();

package/dist/application/stallDetection.js

@@ -108,7 +108,7 @@ async function handleStalledJob(job, action, ctx) {
 /** Move stalled job to DLQ */
 function moveStalliedJobToDlq(job, ctx, shard, procIdx, attemptsExhausted) {
     ctx.processingShards[procIdx].delete(job.id);
-    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
     // Discard cron jobs with preventOverlap instead of sending to DLQ (#73).
     if (job.uniqueKey?.startsWith('cron:')) {
         ctx.jobIndex.delete(job.id);
@@ -132,7 +132,7 @@ function retryStalliedJob(job, ctx, shard, procIdx, idx) {
     // The cron scheduler will re-create them at the next scheduled tick.
     if (job.uniqueKey?.startsWith('cron:')) {
         ctx.processingShards[procIdx].delete(job.id);
-        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+        shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
         ctx.jobIndex.delete(job.id);
         ctx.storage?.deleteJob(job.id);
         return;
@@ -153,7 +153,7 @@ function retryStalliedJob(job, ctx, shard, procIdx, idx) {
         job.timeline.push({ state: 'waiting', timestamp: stallNow, attempt: job.attempts + 1 });
     }
     ctx.processingShards[procIdx].delete(job.id);
-    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId);
+    shard.releaseJobResources(job.queue, job.uniqueKey, job.groupId, job.id);
     shard.getQueue(job.queue).push(job);
     const isDelayed = job.runAt > Date.now();
     shard.incrementQueued(job.id, isDelayed, job.createdAt, job.queue, job.runAt);

package/dist/client/flowJobDependencies.js

@@ -5,12 +5,14 @@ async function fetchChildIds(id, embedded, tcp) {
     if (embedded) {
         const job = await getSharedManager().getJob(jobId(id));
         if (!job)
-            throw new Error(`Flow job ${id} not found`);
+            return [];
         return job.childrenIds.map(String);
     }
     if (!tcp)
         return [];
     const response = await tcp.send({ cmd: 'GetJob', id });
+    if (response.ok !== true && response.error === 'Job not found')
+        return [];
     assertFlowTcpOk(response, 'GetJob');
     const parent = response.job;
     return (parent?.childrenIds ?? []).map(String);

package/dist/client/flowJobMoveMethods.js

@@ -2,6 +2,7 @@ import { jobId } from '../domain/types/job';
 import { getSharedManager } from './manager';
 import { buildFailCommand, failEmbeddedArgs } from './queue/failWire';
 import { assertFlowTcpOk } from './flowJobTypes';
+import { removeJobDeduplicationKey } from './jobDeduplication';
 /** Lifecycle and failure-inspection methods exposed by a FlowProducer Job. */
 export function buildFlowJobMoveMethods(runtime) {
     const { id, embedded, tcp } = runtime;
@@ -42,7 +43,11 @@ export function buildFlowJobMoveMethods(runtime) {
         moveToWaitingChildren: async () => {
             if (embedded)
                 return getSharedManager().moveToWaitingChildren(jobId(id));
-            throw new Error('moveToWaitingChildren is not supported in TCP mode — no server command available');
+            if (!tcp)
+                return false;
+            const response = await tcp.send({ cmd: 'MoveToWaitingChildren', id });
+            assertFlowTcpOk(response, 'MoveToWaitingChildren');
+            return true;
         },
         waitUntilFinished: async (_queueEvents, ttl) => {
             const timeout = ttl ?? 30_000;
@@ -100,7 +105,7 @@ export function buildFlowJobMoveMethods(runtime) {
             assertFlowTcpOk(response, 'RemoveChildDependency');
             return response.removed ?? false;
         },
-        removeDeduplicationKey: () => Promise.reject(new Error('removeDeduplicationKey is not implemented — no server primitive available')),
+        removeDeduplicationKey: () => removeJobDeduplicationKey(id, embedded, tcp),
         removeUnprocessedChildren: async () => {
             if (embedded)
                 return void (await getSharedManager().removeUnprocessedChildren(jobId(id)));

package/dist/client/jobConversion.d.ts

@@ -4,11 +4,11 @@
  */
 import type { DlqEntry as InternalDlqEntry } from '../domain/types/dlq';
 import type { Job, DlqEntry } from './types';
-import type { CreatePublicJobOptions, ToPublicJobOptions } from './jobConversionTypes';
-export type { CreatePublicJobOptions, ToPublicJobOptions } from './jobConversionTypes';
+import type { CreatePublicJobOptions, PublicJobMethodContext, ToPublicJobOptions } from './jobConversionTypes';
+export type { CreatePublicJobOptions, PublicJobMethodContext, ToPublicJobOptions, } from './jobConversionTypes';
 /** Convert internal job to public job (with methods) */
 export declare function createPublicJob<T>(opts: CreatePublicJobOptions): Job<T>;
 /** Simple public job without methods (for Queue.getJob) */
 export declare function toPublicJob<T>(opts: ToPublicJobOptions): Job<T>;
 /** Convert internal DLQ entry to public DLQ entry */
-export declare function toDlqEntry<T>(entry: InternalDlqEntry): DlqEntry<T>;
+export declare function toDlqEntry<T>(entry: InternalDlqEntry, methods: PublicJobMethodContext): DlqEntry<T>;

package/dist/client/jobConversion.js

@@ -64,7 +64,7 @@ export function createPublicJob(opts) {
 }
 /** Simple public job without methods (for Queue.getJob) */
 export function toPublicJob(opts) {
-    const { job, name, getState, remove, retry, getChildrenValues, updateData, promote, changeDelay, changePriority, extendLock, clearLogs, getDependencies, getDependenciesCount, moveToCompleted, moveToFailed, moveToWait, moveToDelayed, moveToWaitingChildren, waitUntilFinished, discard, getFailedChildrenValues, getIgnoredChildrenFailures, removeChildDependency, removeDeduplicationKey, removeUnprocessedChildren, stacktrace, } = opts;
+    const { job, name, updateProgress, log, getState, remove, retry, getChildrenValues, updateData, promote, changeDelay, changePriority, extendLock, clearLogs, getDependencies, getDependenciesCount, moveToCompleted, moveToFailed, moveToWait, moveToDelayed, moveToWaitingChildren, waitUntilFinished, discard, getFailedChildrenValues, getIgnoredChildrenFailures, removeChildDependency, removeDeduplicationKey, removeUnprocessedChildren, stacktrace, } = opts;
     const id = String(job.id);
     const jobOpts = buildJobOpts(job);
     const props = buildJobProperties(job, name, stacktrace, undefined, undefined);
@@ -74,9 +74,9 @@ export function toPublicJob(opts) {
         ...props,
         ...stateChecks,
         ...serialization,
-        // Core methods (no-op for simple jobs)
-        updateProgress: async () => { },
-        log: async () => { },
+        // Core methods
+        updateProgress: (progress, message) => updateProgress ? updateProgress(id, progress, message) : Promise.resolve(),
+        log: (message) => (log ? log(id, message) : Promise.resolve()),
         getState: () => (getState ? getState(id) : Promise.resolve('unknown')),
         remove: () => (remove ? remove(id) : Promise.resolve()),
         retry: () => (retry ? retry(id) : Promise.resolve()),
@@ -121,10 +121,14 @@ export function toPublicJob(opts) {
     };
 }
 /** Convert internal DLQ entry to public DLQ entry */
-export function toDlqEntry(entry) {
+export function toDlqEntry(entry, methods) {
     const jobData = entry.job.data;
     return {
-        job: toPublicJob({ job: entry.job, name: jobData?.name ?? 'default' }),
+        job: createPublicJob({
+            job: entry.job,
+            name: jobData?.name ?? 'default',
+            ...methods,
+        }),
         enteredAt: entry.enteredAt,
         reason: entry.reason,
         error: entry.error,

package/dist/client/jobConversionHelpers.d.ts

@@ -7,6 +7,6 @@ import type { Job, JobStateType, JobOptions, GetDependenciesOpts, JobDependencie
 /** Build common job properties from internal job */
 export declare function buildJobProperties<T>(job: InternalJob, name: string, stacktrace?: string[] | null, token?: string, processedBy?: string): Pick<Job<T>, 'id' | 'name' | 'data' | 'queueName' | 'attemptsMade' | 'timestamp' | 'progress' | 'parent' | 'delay' | 'processedOn' | 'finishedOn' | 'stacktrace' | 'stalledCounter' | 'priority' | 'parentKey' | 'opts' | 'token' | 'processedBy' | 'deduplicationId' | 'repeatJobKey' | 'attemptsStarted'>;
 /** Build state check methods */
-export declare function buildStateCheckMethods(id: string, getState?: (id: string) => Promise<JobStateType>, getDependenciesCount?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>): Pick<Job, 'isWaiting' | 'isActive' | 'isDelayed' | 'isCompleted' | 'isFailed' | 'isWaitingChildren'>;
+export declare function buildStateCheckMethods(id: string, getState?: (id: string) => Promise<JobStateType>, _getDependenciesCount?: (id: string, opts?: GetDependenciesOpts) => Promise<JobDependenciesCount>): Pick<Job, 'isWaiting' | 'isActive' | 'isDelayed' | 'isCompleted' | 'isFailed' | 'isWaitingChildren'>;
 /** Build serialization methods */
 export declare function buildSerializationMethods<T>(job: InternalJob, id: string, name: string, jobOpts: JobOptions, stacktrace?: string[] | null): Pick<Job<T>, 'toJSON' | 'asJSON'>;

package/dist/client/jobConversionHelpers.js

@@ -38,7 +38,7 @@ export function buildJobProperties(job, name, stacktrace, token, processedBy) {
     };
 }
 /** Build state check methods */
-export function buildStateCheckMethods(id, getState, getDependenciesCount) {
+export function buildStateCheckMethods(id, getState, _getDependenciesCount) {
     return {
         isWaiting: async () => {
             const state = await (getState ? getState(id) : Promise.resolve('unknown'));
@@ -61,11 +61,8 @@ export function buildStateCheckMethods(id, getState, getDependenciesCount) {
             return state === 'failed';
         },
         isWaitingChildren: async () => {
-            if (getDependenciesCount) {
-                const counts = await getDependenciesCount(id);
-                return counts.unprocessed > 0;
-            }
-            return false;
+            const state = await (getState ? getState(id) : Promise.resolve('unknown'));
+            return state === 'waiting-children';
         },
     };
 }

package/dist/client/jobConversionTypes.d.ts

@@ -43,10 +43,14 @@ export interface CreatePublicJobOptions {
     processedBy?: string;
     stacktrace?: string[] | null;
 }
+/** Complete operation set required when exposing a live job from another view. */
+export type PublicJobMethodContext = Required<Omit<CreatePublicJobOptions, 'job' | 'name' | 'token' | 'processedBy' | 'stacktrace'>>;
 /** Options for creating a simple public job */
 export interface ToPublicJobOptions {
     job: InternalJob;
     name: string;
+    updateProgress?: (id: string, progress: number, message?: string) => Promise<void>;
+    log?: (id: string, message: string) => Promise<void>;
     getState?: (id: string) => Promise<JobStateType>;
     remove?: (id: string) => Promise<void>;
     retry?: (id: string) => Promise<void>;

package/dist/client/jobDeduplication.d.ts

@@ -0,0 +1,6 @@
+interface CommandTransport {
+    send(command: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+/** Remove only the deduplication key currently owned by the given job. */
+export declare function removeJobDeduplicationKey(id: string, embedded: boolean, transport: CommandTransport | null | undefined): Promise<boolean>;
+export {};

package/dist/client/jobDeduplication.js

@@ -0,0 +1,14 @@
+import { jobId } from '../domain/types/job';
+import { getSharedManager } from './manager';
+/** Remove only the deduplication key currently owned by the given job. */
+export async function removeJobDeduplicationKey(id, embedded, transport) {
+    if (embedded)
+        return getSharedManager().removeJobDeduplicationKey(jobId(id));
+    if (!transport)
+        return false;
+    const response = await transport.send({ cmd: 'RemoveJobDeduplicationKey', id });
+    if (!response.ok) {
+        throw new Error(response.error ?? 'Failed to remove deduplication key');
+    }
+    return response.data.removed;
+}