bunqueue 2.8.34 → 2.8.36

package/dist/infrastructure/scheduler/cronScheduler.js

@@ -283,6 +283,35 @@ export class CronScheduler {
                 else {
                     newNextRun = executionTime;
                 }
+                // Skip decision comes BEFORE the executions increment: a skipped fire
+                // pushes no job, so it must not consume the maxLimit budget (a cron
+                // with maxLimit=N must deliver N jobs, not N-minus-skips — worst case
+                // skipIfNoWorker used to burn the whole budget with zero deliveries).
+                // The schedule still advances so the heap doesn't hot-loop on it.
+                const skipReason = this.getSkipReason(cron, now);
+                if (skipReason) {
+                    if (this.persistCron) {
+                        try {
+                            this.persistCron(cron.name, cron.executions, newNextRun);
+                        }
+                        catch (persistErr) {
+                            // Benign here: nothing was pushed, in-memory advance is enough;
+                            // the next successful persist catches the row up.
+                            cronLog.error('Failed to persist cron nextRun on skip', {
+                                name: cron.name,
+                                error: String(persistErr),
+                            });
+                        }
+                    }
+                    cron.nextRun = newNextRun;
+                    this.dashboardEmit?.('cron:skipped', {
+                        name: cron.name,
+                        queue: cron.queue,
+                        reason: skipReason,
+                    });
+                    toReinsert.push(entry);
+                    continue;
+                }
                 // PERSIST STATE FIRST (before pushing job to prevent duplicates)
                 if (this.persistCron) {
                     try {
@@ -339,27 +368,24 @@ export class CronScheduler {
         this.scheduleNext();
     }
     /** Fire a cron job with overlap and worker detection */
-    async fireCronJob(cron, now) {
+    /**
+     * Reasons a due cron must not push right now. Evaluated BEFORE the
+     * executions increment in tick(), so skips never consume maxLimit budget.
+     */
+    getSkipReason(cron, now) {
         // skipIfNoWorker: skip if no workers registered for this queue
         if (cron.skipIfNoWorker && this.hasWorkers && !this.hasWorkers(cron.queue)) {
-            this.dashboardEmit?.('cron:skipped', {
-                name: cron.name,
-                queue: cron.queue,
-                reason: 'no-worker',
-            });
-            return;
+            return 'no-worker';
         }
         // Overlap detection: skip if last fire was within repeatEvery window
         const lastFire = this.lastFiredAt.get(cron.name);
         const interval = cron.repeatEvery ?? 60000;
         if (lastFire && now - lastFire < interval * 0.8) {
-            this.dashboardEmit?.('cron:skipped', {
-                name: cron.name,
-                queue: cron.queue,
-                reason: 'overlap',
-            });
-            return;
+            return 'overlap';
         }
+        return null;
+    }
+    async fireCronJob(cron, now) {
         // preventOverlap: auto-set uniqueKey to block pushes while previous job is active
         const effectiveUniqueKey = cron.uniqueKey ?? (cron.preventOverlap ? `cron:${cron.name}` : undefined);
         const opts = cron.jobOptions;

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

@@ -172,8 +172,17 @@ export function handleRateLimit(cmd, ctx, reqId) {
     const limit = toFiniteNumber(cmd.limit);
     if (limit === undefined)
         return resp.error('limit must be a finite number', reqId);
-    ctx.queueManager.setRateLimit(cmd.queue, limit);
-    ctx.queueManager.emitDashboardEvent('ratelimit:set', { queue: cmd.queue, max: limit });
+    // Optional window/TTL: invalid values degrade to the defaults (1s window,
+    // permanent limit) inside the limiter rather than failing the command.
+    const duration = toFiniteNumber(cmd.duration);
+    const ttl = toFiniteNumber(cmd.ttl);
+    ctx.queueManager.setRateLimit(cmd.queue, limit, duration, ttl);
+    ctx.queueManager.emitDashboardEvent('ratelimit:set', {
+        queue: cmd.queue,
+        max: limit,
+        ...(duration !== undefined && { duration }),
+        ...(ttl !== undefined && { ttl }),
+    });
     return resp.ok(undefined, reqId);
 }
 /** Handle RateLimitClear command */

package/dist/infrastructure/server/httpRouteQueueConfig.js

@@ -76,6 +76,8 @@ export async function routeQueueConfigRoutes(req, path, method, ctx, cors) {
             cmd: 'RateLimit',
             queue,
             limit: body['limit'],
+            duration: body['duration'],
+            ttl: body['ttl'],
         }, ctx);
         return jsonResponse(r, 200, cors);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunqueue",
-  "version": "2.8.34",
+  "version": "2.8.36",
   "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,7 +57,9 @@
     "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:model": "BUNQUEUE_EMBEDDED=1 bun test test/model-based/queue-model.test.ts",
     "test:sandbox": "bun run scripts/test-sandbox.ts",
+    "test:sandbox:sdk": "bun run scripts/test-sdk-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",
@@ -82,6 +84,7 @@
     "@types/bun": "^1.3.9",
     "bullmq": "^5.79.3",
     "elysia": "^1.4.25",
+    "fast-check": "^4.9.0",
     "ioredis": "^5.11.1",
     "typescript": "^5.9.3",
     "zod": "^4.3.6"