bunqueue 2.8.33 → 2.8.34

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

@@ -29,8 +29,6 @@ export declare function updateJobProgress(jobId: JobId, progress: number, ctx: J
 export declare function updateJobData(jobId: JobId, data: unknown, ctx: JobManagementContext): Promise<boolean>;
 /** Change job priority */
 export declare function changeJobPriority(jobId: JobId, priority: number, ctx: JobManagementContext, lifo?: boolean): Promise<boolean>;
-/** Promote delayed job to waiting */
-export declare function promoteJob(jobId: JobId, ctx: JobManagementContext): Promise<boolean>;
 /** Move active job back to delayed */
 export declare function moveJobToDelayed(jobId: JobId, delay: number, ctx: JobManagementContext): Promise<boolean>;
 /** Discard job to DLQ */

package/dist/application/operations/jobManagement.js

@@ -162,20 +162,6 @@ export async function changeJobPriority(jobId, priority, ctx, lifo) {
         return q.updatePriority(jobId, priority, lifo);
     });
 }
-/** Promote delayed job to waiting */
-export async function promoteJob(jobId, ctx) {
-    const location = ctx.jobIndex.get(jobId);
-    if (location?.type !== 'queue')
-        return false;
-    return withWriteLock(ctx.shardLocks[location.shardIdx], () => {
-        const q = ctx.shards[location.shardIdx].getQueue(location.queueName);
-        const job = q.find(jobId);
-        if (!job || job.runAt <= Date.now())
-            return false;
-        q.updateRunAt(jobId, Date.now());
-        return true;
-    });
-}
 /** Move active job back to delayed */
 export async function moveJobToDelayed(jobId, delay, ctx) {
     const location = ctx.jobIndex.get(jobId);

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

@@ -0,0 +1,7 @@
+/** Delayed-job promotion operations shared by embedded and server modes. */
+import type { JobId } from '../../domain/types/job';
+import type { JobManagementContext } from './jobManagement';
+/** Promote one delayed job and persist the transition before resolving. */
+export declare function promoteJob(jobId: JobId, ctx: JobManagementContext): Promise<boolean>;
+/** Promote the oldest delayed jobs from the live shard, never an eventual SQL listing. */
+export declare function promoteJobs(queueName: string, count: number | undefined, ctx: JobManagementContext): Promise<number>;

package/dist/application/operations/jobPromotion.js

@@ -0,0 +1,58 @@
+/** Delayed-job promotion operations shared by embedded and server modes. */
+import { shardIndex } from '../../shared/hash';
+import { withWriteLock } from '../../shared/lock';
+function compareOldestFirst(a, b) {
+    if (a.createdAt !== b.createdAt)
+        return a.createdAt - b.createdAt;
+    if (a.id === b.id)
+        return 0;
+    return a.id < b.id ? -1 : 1;
+}
+/** Promote one delayed job and persist the transition before resolving. */
+export async function promoteJob(jobId, ctx) {
+    const location = ctx.jobIndex.get(jobId);
+    if (location?.type !== 'queue')
+        return false;
+    const promotedAt = Date.now();
+    const success = await withWriteLock(ctx.shardLocks[location.shardIdx], () => {
+        const shard = ctx.shards[location.shardIdx];
+        const queue = shard.getQueue(location.queueName);
+        const job = queue.find(jobId);
+        if (!job || job.runAt <= promotedAt || !queue.updateRunAt(jobId, promotedAt))
+            return false;
+        shard.promoteDelayed(jobId);
+        shard.notify(location.queueName);
+        return true;
+    });
+    if (success)
+        ctx.storage?.updateRunAt(jobId, promotedAt);
+    return success;
+}
+/** Promote the oldest delayed jobs from the live shard, never an eventual SQL listing. */
+export async function promoteJobs(queueName, count, ctx) {
+    const idx = shardIndex(queueName);
+    const promotedAt = Date.now();
+    const promotedIds = await withWriteLock(ctx.shardLocks[idx], () => {
+        const shard = ctx.shards[idx];
+        const queue = shard.getQueue(queueName);
+        const delayed = queue
+            .values()
+            .filter((job) => job.runAt > promotedAt)
+            .sort(compareOldestFirst);
+        const limit = count === undefined ? delayed.length : Math.max(0, Math.floor(count));
+        const ids = [];
+        for (let i = 0; i < Math.min(limit, delayed.length); i++) {
+            const id = delayed[i].id;
+            if (!queue.updateRunAt(id, promotedAt))
+                continue;
+            shard.promoteDelayed(id);
+            ids.push(id);
+        }
+        if (ids.length > 0)
+            shard.notifyBatch(queueName, ids.length);
+        return ids;
+    });
+    for (const id of promotedIds)
+        ctx.storage?.updateRunAt(id, promotedAt);
+    return promotedIds.length;
+}

package/dist/application/queueManager.d.ts

@@ -237,6 +237,7 @@ export declare class QueueManager {
     updateJobData(jobId: JobId, data: unknown): Promise<boolean>;
     changePriority(jobId: JobId, priority: number, lifo?: boolean): Promise<boolean>;
     promote(jobId: JobId): Promise<boolean>;
+    promoteJobs(queue: string, count?: number): Promise<number>;
     moveToDelayed(jobId: JobId, delay: number): Promise<boolean>;
     changeDelay(jobId: JobId, delay: number): Promise<boolean>;
     moveActiveToWait(jobId: JobId): Promise<boolean>;

package/dist/application/queueManager.js

@@ -17,6 +17,7 @@ import { pullJob, pullJobBatch } from './operations/pull';
 import { ackJob, ackJobBatch, ackJobBatchWithResults, failJob } from './operations/ack';
 import * as queueControl from './operations/queueControl';
 import * as jobMgmt from './operations/jobManagement';
+import * as jobPromotion from './operations/jobPromotion';
 import * as jobTransitions from './operations/jobStateTransitions';
 import * as queryOps from './operations/queryOperations';
 import * as dlqOps from './dlqManager';
@@ -975,7 +976,10 @@ export class QueueManager {
         return jobMgmt.changeJobPriority(jobId, priority, this.contextFactory.getJobMgmtContext(), lifo);
     }
     async promote(jobId) {
-        return jobMgmt.promoteJob(jobId, this.contextFactory.getJobMgmtContext());
+        return jobPromotion.promoteJob(jobId, this.contextFactory.getJobMgmtContext());
+    }
+    async promoteJobs(queue, count) {
+        return jobPromotion.promoteJobs(queue, count, this.contextFactory.getJobMgmtContext());
     }
     async moveToDelayed(jobId, delay) {
         // moveToDelayed and changeDelay share identical routing in this engine: a job

package/dist/client/queue/operations/management.js

@@ -93,17 +93,7 @@ export async function cleanAsync(ctx, grace, limit, type) {
 /** Promote delayed jobs to waiting */
 export async function promoteJobs(ctx, opts) {
     if (ctx.embedded) {
-        // Get delayed jobs and promote them one by one
-        const manager = getSharedManager();
-        const jobs = manager.getJobs(ctx.name, { state: 'delayed' });
-        const count = opts?.count ?? jobs.length;
-        let promoted = 0;
-        for (let i = 0; i < Math.min(count, jobs.length); i++) {
-            const success = await manager.promote(jobs[i].id);
-            if (success)
-                promoted++;
-        }
-        return promoted;
+        return getSharedManager().promoteJobs(ctx.name, opts?.count);
     }
     const response = await ctx.tcp.send({
         cmd: 'PromoteJobs',

package/dist/domain/queue/shard.d.ts

@@ -116,6 +116,8 @@ export declare class Shard {
     };
     incrementQueued(jobId: JobId, isDelayed: boolean, createdAt?: number, queue?: string, runAt?: number): void;
     decrementQueued(jobId: JobId): void;
+    /** Remove a promoted job from delayed tracking without changing queue depth. */
+    promoteDelayed(jobId: JobId): void;
     incrementDlq(): void;
     decrementDlq(count?: number): void;
     refreshDelayedCount(now: number): void;

package/dist/domain/queue/shard.js

@@ -302,6 +302,11 @@ export class Shard {
     decrementQueued(jobId) {
         this.counters.decrementQueued(jobId);
     }
+    /** Remove a promoted job from delayed tracking without changing queue depth. */
+    promoteDelayed(jobId) {
+        this.temporalManager.removeDelayed(jobId);
+        this.counters.syncDelayedCount();
+    }
     incrementDlq() {
         this.counters.incrementDlq();
     }

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

@@ -281,14 +281,7 @@ export async function handleMoveToWait(cmd, ctx, reqId) {
 }
 /** Handle PromoteJobs command - promote all delayed jobs in a queue */
 export async function handlePromoteJobs(cmd, ctx, reqId) {
-    const delayed = ctx.queueManager.getJobs(cmd.queue, { state: 'delayed' });
-    const limit = cmd.count ?? delayed.length;
-    let count = 0;
-    for (let i = 0; i < Math.min(limit, delayed.length); i++) {
-        const success = await ctx.queueManager.promote(delayed[i].id);
-        if (success)
-            count++;
-    }
+    const count = await ctx.queueManager.promoteJobs(cmd.queue, cmd.count);
     return { ok: true, count, reqId };
 }
 // ============ Flow Dependency Commands ============

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunqueue",
-  "version": "2.8.33",
+  "version": "2.8.34",
   "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",
@@ -57,6 +57,7 @@
     "build": "bun build --compile --minify src/main.ts --outfile dist/bunqueue",
     "build:lib": "tsc -p tsconfig.build.json",
     "test": "BUNQUEUE_EMBEDDED=1 bun test",
+    "test:sandbox": "bun run scripts/test-sandbox.ts",
     "bench": "bun run bench/throughput.ts && bun run bench/latency.ts",
     "bench:throughput": "bun run bench/throughput.ts",
     "bench:latency": "bun run bench/latency.ts",