bunqueue 2.8.58 → 2.8.60

package/dist/client/workflow/waitFor.js

@@ -23,6 +23,7 @@ const TIMEOUT_ENQUEUE_RETRY_MS = 5_000;
  */
 export function scheduleTimeoutCheck(deps, execId, workflowName, nodeIdx, ms) {
     const arm = (requestedDelay) => {
+        deps.assertActive();
         const delay = Math.min(Math.max(requestedDelay, 0), MAX_TIMER_MS);
         // Replacing a live timer for the same execution — re-entering a waitFor node used
         // to leak the previous one, which then fired against a node the run had left.
@@ -30,6 +31,11 @@ export function scheduleTimeoutCheck(deps, execId, workflowName, nodeIdx, ms) {
         if (previous)
             clock().clearTimeout(previous);
         const timer = clock().setTimeout(() => {
+            if (!deps.isActive()) {
+                if (deps.timers.get(execId) === timer)
+                    deps.timers.delete(execId);
+                return;
+            }
             const jobData = { executionId: execId, workflowName, nodeIndex: nodeIdx };
             const published = () => {
                 // Keep the handle in the map while add() is pending. signal() and close() use
@@ -40,6 +46,10 @@ export function scheduleTimeoutCheck(deps, execId, workflowName, nodeIdx, ms) {
             const failed = () => {
                 if (deps.timers.get(execId) !== timer)
                     return;
+                if (!deps.isActive()) {
+                    deps.timers.delete(execId);
+                    return;
+                }
                 arm(TIMEOUT_ENQUEUE_RETRY_MS);
             };
             try {
@@ -75,6 +85,7 @@ export function clearTimers(timers) {
  * short-circuits without treating the pause as an error.
  */
 export async function runWaitFor(deps, exec, node, idx, wf) {
+    deps.assertActive();
     if (hasSignal(exec.signals, node.event)) {
         await deps.advance(exec, idx + 1, wf);
         return;
@@ -92,11 +103,14 @@ export async function runWaitFor(deps, exec, node, idx, wf) {
             // (refund, release stock) work the approver just authorised.
             const fresh = deps.store.get(exec.id);
             if (fresh && hasSignal(fresh.signals, node.event)) {
+                deps.assertActive();
                 exec.signals = fresh.signals;
                 await deps.advance(exec, idx + 1, wf);
                 return;
             }
+            deps.assertActive();
             deps.emitter?.emitSignal('signal:timeout', exec.id, exec.workflowName, node.event);
+            deps.assertActive();
             const timeoutReason = `Signal "${node.event}" timed out after ${node.timeout}ms`;
             exec.steps[waitKey] = {
                 status: 'failed',
@@ -106,30 +120,26 @@ export async function runWaitFor(deps, exec, node, idx, wf) {
             };
             exec.state = 'failed';
             exec.failureReason = timeoutReason;
-            // Unguarded on purpose, same reasoning as the failure write in `executor.ts`. Disk
-            // still says `waiting`, which `listRecoverable()` covers, so `recoverWaiting`
-            // recomputes the remaining time, re-enqueues, and the gate times out again rather
-            // than leaving a run that looks settled and was never unwound.
-            //
-            // A throw here skips the compensate CALL below but not the compensation: it
-            // propagates into `runNode`'s catch, which compensates anyway. That is the generic
-            // path the `WaitForSignalError` sentinel below exists to avoid on the normal route,
-            // so the outcome is a redundant route, not a missing rollback.
-            deps.store.update(exec);
+            // Persist failure before starting rollback. The lifecycle guard leaves the
+            // durable row waiting if force-close won, so replacement recovery re-evaluates
+            // the same elapsed deadline without starting an old executor's compensation.
+            deps.updateFn(exec);
             // Compensate here, then signal completion via the WaitForSignalError sentinel
             // so processStep short-circuits (return null) instead of re-running
             // compensation through its generic catch path.
             await deps.compensate(exec, wf);
+            deps.assertActive();
             deps.emitter?.emitWorkflow('workflow:failed', exec.id, exec.workflowName, 'failed');
             throw new WaitForSignalError(node.event);
         }
-        deps.store.update(exec);
+        deps.updateFn(exec);
         remaining = node.timeout - (clock().now() - waitingSince);
     }
     // Park transactionally. Between the in-memory check above and this point a signal
     // can land: it would be recorded with no parked run left to claim the resume,
     // hanging the execution forever. parkForSignal() re-reads the persisted signals
     // and only transitions 'running' -> 'waiting' when none has arrived.
+    deps.assertActive();
     const park = deps.store.parkForSignal(exec.id, node.event);
     if (park.signalPresent) {
         exec.signals = park.signals;
@@ -143,8 +153,10 @@ export async function runWaitFor(deps, exec, node, idx, wf) {
     }
     exec.state = 'waiting';
     if (node.timeout !== undefined) {
+        deps.assertActive();
         deps.scheduleTimeoutCheck(exec.id, exec.workflowName, idx, remaining);
     }
+    deps.assertActive();
     deps.emitter?.emitWorkflow('workflow:waiting', exec.id, exec.workflowName, 'waiting');
     throw new WaitForSignalError(node.event);
 }

package/dist/client/workflow/workflowDecisions.d.ts

@@ -4,7 +4,7 @@ import type { Execution } from './types';
  * Return an already persisted decision, or evaluate and persist it before the caller
  * performs any effects selected by that decision.
  */
-export declare function resolveDecision<T>(exec: Execution, key: string, evaluate: () => T | Promise<T>, updateFn: (exec: Execution) => void): Promise<T>;
+export declare function resolveDecision<T>(exec: Execution, key: string, evaluate: () => T | Promise<T>, updateFn: (exec: Execution) => void, assertActive: () => void): Promise<T>;
 export declare function branchDecisionKey(nodeIndex: number): string;
 export declare function forEachItemsDecisionKey(stepName: string): string;
 export declare function loopDecisionKey(kind: 'doUntil' | 'doWhile', firstStepName: string, iteration: number): string;

package/dist/client/workflow/workflowDecisions.js

@@ -4,11 +4,13 @@ const hasOwn = (value, key) => Object.hasOwn(value, key);
  * Return an already persisted decision, or evaluate and persist it before the caller
  * performs any effects selected by that decision.
  */
-export async function resolveDecision(exec, key, evaluate, updateFn) {
+export async function resolveDecision(exec, key, evaluate, updateFn, assertActive) {
+    assertActive();
     const decisions = (exec.decisions ??= {});
     if (hasOwn(decisions, key))
         return decisions[key];
     const value = await evaluate();
+    assertActive();
     decisions[key] = value;
     updateFn(exec);
     return value;

package/dist/infrastructure/persistence/sqlite.d.ts

@@ -1,5 +1,5 @@
 import { SqliteLifecycle } from './sqlite/lifecycle';
-export type { SqliteConfig, SqliteCriticalLoss, SqliteCriticalLossCallback, } from './types/sqlite';
+export type { SqliteConfig, SqliteCriticalLoss, SqliteCriticalLossCallback } from './types/sqlite';
 export type { DurableAdmissionMetadata } from './types/admission';
 /** SQLite persistence façade. Implementation is split by responsibility. */
 export declare class SqliteStorage extends SqliteLifecycle {

package/dist/infrastructure/server/handler-routes/jobs.js

@@ -5,7 +5,6 @@ import { handleGetDeduplicationJobId, handleGetQueueLimits, handleMoveToWaitingC
 import { handleCancel, handleGetProgress, handleProgress } from '../handlers/management';
 import { handleExtendLock, handleExtendLocks } from '../handlers/monitoring';
 import { handleGetChildrenValues, handleGetCountsPerPriority, handleGetJob, handleGetJobByCustomId, handleGetJobCounts, handleGetJobs, handleGetResult, handleGetState, } from '../handlers/query';
-// biome-ignore lint/suspicious/useAwait: stable router API always returns a Promise.
 export async function routeCoreCommand(command, context, requestId) {
     switch (command.cmd) {
         case 'PUSH':
@@ -28,7 +27,6 @@ export async function routeCoreCommand(command, context, requestId) {
             return null;
     }
 }
-// biome-ignore lint/suspicious/useAwait: stable router API always returns a Promise.
 export async function routeQueryCommand(command, context, requestId) {
     switch (command.cmd) {
         case 'GetJob':
@@ -59,7 +57,6 @@ export async function routeQueryCommand(command, context, requestId) {
             return null;
     }
 }
-// biome-ignore lint/suspicious/useAwait: stable router API always returns a Promise.
 export async function routeManagementCommand(command, context, requestId) {
     switch (command.cmd) {
         case 'Cancel':

package/dist/infrastructure/server/handlerRoutes.d.ts

@@ -1,3 +1,3 @@
 export { routeConfigCommand, routeCronCommand, routeDlqCommand, routeQueueControlCommand, routeRateLimitCommand, } from './handler-routes/control';
-export { routeCoreCommand, routeManagementCommand, routeQueryCommand, } from './handler-routes/jobs';
-export { routeDashboardCommand, routeMonitoringCommand, } from './handler-routes/monitoring';
+export { routeCoreCommand, routeManagementCommand, routeQueryCommand } from './handler-routes/jobs';
+export { routeDashboardCommand, routeMonitoringCommand } from './handler-routes/monitoring';

package/dist/infrastructure/server/handlerRoutes.js

@@ -1,3 +1,3 @@
 export { routeConfigCommand, routeCronCommand, routeDlqCommand, routeQueueControlCommand, routeRateLimitCommand, } from './handler-routes/control';
-export { routeCoreCommand, routeManagementCommand, routeQueryCommand, } from './handler-routes/jobs';
-export { routeDashboardCommand, routeMonitoringCommand, } from './handler-routes/monitoring';
+export { routeCoreCommand, routeManagementCommand, routeQueryCommand } from './handler-routes/jobs';
+export { routeDashboardCommand, routeMonitoringCommand } from './handler-routes/monitoring';

package/dist/infrastructure/server/httpEndpoints.js

@@ -84,6 +84,7 @@ export function readinessEndpoint(queueManager, corsOrigins) {
 /** GC endpoint - force garbage collection */
 export function gcEndpoint(queueManager) {
     const before = process.memoryUsage();
+    // oxlint-disable-next-line typescript/prefer-optional-chain -- the typeof guard avoids referencing an unavailable Bun global
     if (typeof Bun !== 'undefined' && Bun.gc) {
         Bun.gc(true);
     }
@@ -105,6 +106,7 @@ export function gcEndpoint(queueManager) {
 }
 /** Heap stats endpoint - for debugging memory leaks */
 export async function heapStatsEndpoint(queueManager) {
+    // oxlint-disable-next-line typescript/prefer-optional-chain -- the typeof guard avoids referencing an unavailable Bun global
     if (typeof Bun !== 'undefined' && Bun.gc) {
         Bun.gc(true);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunqueue",
-  "version": "2.8.58",
+  "version": "2.8.60",
   "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",
@@ -71,13 +71,13 @@
     "bench:workflow:scale": "bun run bench/workflow-engine/scale.ts",
     "bench:joblist": "bun run bench/job-list-perf.ts",
     "bench:compare": "bun run bench/comparison/run.ts",
-    "lint": "biome lint src",
-    "lint:fix": "biome lint --write src",
-    "format": "biome format --write src",
-    "format:check": "biome format src",
+    "lint": "oxlint src",
+    "lint:fix": "oxlint --fix src",
+    "format": "oxfmt --write src",
+    "format:check": "oxfmt --check src",
     "typecheck": "tsc --noEmit",
-    "check:biome": "biome check src",
-    "check": "bun run typecheck && biome check src && bun run check:docs-data",
+    "check:oxc": "bun run lint && bun run format:check",
+    "check": "bun run typecheck && bun run check:oxc && bun run check:docs-data",
     "prepublishOnly": "bun run build:lib"
   },
   "dependencies": {
@@ -87,18 +87,20 @@
   "devDependencies": {
     "@ai-sdk/anthropic": "^4.0.22",
     "@anthropic-ai/claude-agent-sdk": "^0.3.220",
-    "@biomejs/biome": "2.5.1",
     "@langchain/core": "^1.2.3",
     "@langchain/langgraph": "^1.4.8",
     "@mastra/core": "^1.53.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "@openai/agents": "^0.13.5",
-    "@types/bun": "^1.3.9",
+    "@types/bun": "^1.4.0",
     "ai": "^7.0.38",
     "bullmq": "^5.79.3",
     "elysia": "^1.4.25",
     "fast-check": "^4.9.0",
     "ioredis": "^5.11.1",
+    "oxfmt": "0.64.0",
+    "oxlint": "1.79.0",
+    "oxlint-tsgolint": "7.0.2001",
     "typedoc": "^0.28.20",
     "typescript": "^5.9.3",
     "zod": "^4.3.6"
@@ -162,6 +164,6 @@
   },
   "homepage": "https://bunqueue.dev",
   "engines": {
-    "bun": ">=1.3.9"
+    "bun": ">=1.4.0"
   }
 }