@boringnode/queue 0.4.1 → 0.5.1

package/README.md

@@ -292,6 +292,17 @@ import { sync } from '@boringnode/queue/drivers/sync_adapter'
 const adapter = sync() // Jobs execute immediately
 ```
 
+Use the `sync` adapter for tests and lightweight local development only.
+
+- `await MyJob.dispatch(payload).run()` waits for the job to fully finish.
+- Retries are executed inline, not by a background worker.
+- If you configure backoff, the adapter will `sleep` between attempts.
+- This means the caller can stay blocked for the full retry duration.
+
+Example: with `maxRetries: 3` and an exponential backoff of `1s`, `2s`, `4s`,
+the request or command that dispatched the job can stay busy for about 7 seconds
+before the job exhausts its retries and runs `failed()`.
+
 ## Job Options
 
 ```typescript
@@ -338,6 +349,14 @@ export default class ReliableJob extends Job<Payload> {
 }
 ```
 
+`maxRetries` can be defined directly on the job options, and `retry.backoff`
+controls the delay between attempts.
+
+> With the `sync` adapter, these delays happen inline in the caller via
+> `sleep`. If a job fails repeatedly, `dispatch().run()` will take as long as
+> the total backoff duration. Use a worker-backed adapter when you do not want
+> retries to slow down the request/command that dispatched the job.
+
 <details>
 <summary><strong>Available strategies</strong></summary>
 
@@ -500,6 +519,77 @@ await QueueManager.init({
 })
 ```
 
+## OpenTelemetry Instrumentation (experimental)
+
+> [!WARNING]
+> The OpenTelemetry instrumentation is experimental and its API may change in future releases.
+
+`@boringnode/queue` ships with built-in OpenTelemetry instrumentation that creates **PRODUCER** spans for job dispatch and **CONSUMER** spans for job execution, following [OTel messaging semantic conventions](https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/).
+
+### Quick Setup
+
+```typescript
+import { QueueInstrumentation } from '@boringnode/queue/otel'
+import * as boringqueue from '@boringnode/queue'
+
+const instrumentation = new QueueInstrumentation({
+  messagingSystem: 'boringqueue', // default
+  executionSpanLinkMode: 'link',  // or 'parent'
+})
+
+instrumentation.enable()
+instrumentation.manuallyRegister(boringqueue)
+```
+
+The instrumentation patches `QueueManager.init()` to automatically inject its wrappers — no config changes needed in your queue setup.
+
+### Span Attributes
+
+The instrumentation uses standard [OTel messaging semantic conventions](https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/) where they map cleanly, plus a few queue-specific custom attributes.
+
+| Attribute                       | Kind    | Description                                |
+| ------------------------------- | ------- | ------------------------------------------ |
+| `messaging.system`              | Semconv | `'boringqueue'` (configurable)             |
+| `messaging.operation.name`      | Semconv | `'publish'` or `'process'`                 |
+| `messaging.destination.name`    | Semconv | Queue name                                 |
+| `messaging.message.id`          | Semconv | Job ID for single-message spans            |
+| `messaging.batch.message_count` | Semconv | Number of jobs in a batch dispatch         |
+| `messaging.message.retry.count` | Custom  | Retry count (0-based) for a job attempt    |
+| `messaging.job.name`            | Custom  | Job class name (e.g. `SendEmailJob`)       |
+| `messaging.job.status`          | Custom  | `'completed'`, `'failed'`, or `'retrying'` |
+| `messaging.job.group_id`        | Custom  | Queue-specific group identifier            |
+| `messaging.job.priority`        | Custom  | Queue-specific job priority                |
+| `messaging.job.delay_ms`        | Custom  | Delay before the job becomes available     |
+
+### Trace Context Propagation
+
+The instrumentation automatically propagates trace context from dispatch to execution:
+
+- **Link mode** (default): Each job execution is an independent trace, linked to the dispatch span
+- **Parent mode**: Job execution is a child of the dispatch span (same trace)
+
+Child spans created inside `execute()` (DB queries, HTTP calls, etc.) are automatically parented to the job consumer span.
+
+### diagnostics_channel
+
+Raw telemetry events are available via `diagnostics_channel` for custom subscribers:
+
+```typescript
+import { tracingChannels } from '@boringnode/queue'
+
+const { executeChannel } = tracingChannels
+
+executeChannel.subscribe({
+  start() {},
+  end() {},
+  asyncStart() {},
+  asyncEnd(message) {
+    console.log(`Job ${message.job.name} ${message.status} in ${message.duration}ms`)
+  },
+  error() {},
+})
+```
+
 ## Benchmarks
 
 Performance comparison with BullMQ (5ms simulated work per job):

package/build/chunk-KI47AJ6U.js

@@ -0,0 +1,128 @@
+import {
+  E_JOB_MAX_ATTEMPTS_REACHED,
+  E_JOB_TIMEOUT,
+  parse
+} from "./chunk-QEFYHCL7.js";
+
+// src/job_runtime.ts
+var JobExecutionRuntime = class _JobExecutionRuntime {
+  #jobName;
+  #options;
+  #retryConfig;
+  #timeout;
+  /**
+   * Build a runtime from already-resolved queue/job execution config.
+   */
+  static from({
+    jobName,
+    options,
+    retryConfig,
+    defaultTimeout
+  }) {
+    return new _JobExecutionRuntime({
+      jobName,
+      options,
+      retryConfig,
+      defaultTimeout
+    });
+  }
+  get maxRetries() {
+    return this.#retryConfig.maxRetries;
+  }
+  /**
+   * Create a runtime with fully resolved retry and timeout settings.
+   */
+  constructor({ jobName, options, retryConfig, defaultTimeout }) {
+    this.#jobName = jobName;
+    this.#options = options || {};
+    this.#retryConfig = retryConfig;
+    const timeout = this.#options.timeout ?? defaultTimeout;
+    this.#timeout = timeout === void 0 ? void 0 : parse(timeout);
+  }
+  /**
+   * Execute a hydrated job instance and enforce the configured timeout.
+   */
+  async execute(instance, payload, context) {
+    if (this.#timeout === void 0) {
+      instance.$hydrate(payload, context);
+      return instance.execute();
+    }
+    const signal = AbortSignal.timeout(this.#timeout);
+    instance.$hydrate(payload, context, signal);
+    const { abortPromise, cleanupAbortListener } = this.#createTimeoutAbortRace(
+      signal,
+      instance.constructor.name
+    );
+    try {
+      await Promise.race([instance.execute(), abortPromise]);
+    } finally {
+      cleanupAbortListener();
+    }
+  }
+  /**
+   * Convert an execution error into a retry or permanent-failure outcome.
+   */
+  resolveFailure(error, attempts) {
+    if (error instanceof E_JOB_TIMEOUT && this.#options.failOnTimeout) {
+      return {
+        type: "failed",
+        reason: "timeout",
+        storageError: error,
+        hookError: error
+      };
+    }
+    if (typeof this.#retryConfig.maxRetries === "undefined" || this.#retryConfig.maxRetries <= 0) {
+      return {
+        type: "failed",
+        reason: "no-retries",
+        storageError: error,
+        hookError: error
+      };
+    }
+    if (attempts >= this.#retryConfig.maxRetries) {
+      return {
+        type: "failed",
+        reason: "max-attempts",
+        storageError: error,
+        hookError: new E_JOB_MAX_ATTEMPTS_REACHED([this.#jobName], { cause: error })
+      };
+    }
+    if (this.#retryConfig.backoff) {
+      return {
+        type: "retry",
+        retryAt: this.#retryConfig.backoff().getNextRetryAt(attempts + 1)
+      };
+    }
+    return { type: "retry" };
+  }
+  /**
+   * Create the timeout race used to abort a job execution cleanly.
+   */
+  #createTimeoutAbortRace(signal, runtimeJobName) {
+    const timeout = this.#timeout;
+    let abortHandler;
+    const abortPromise = new Promise((_, reject) => {
+      abortHandler = () => {
+        reject(new E_JOB_TIMEOUT([runtimeJobName, timeout]));
+      };
+      if (signal.aborted) {
+        abortHandler();
+        return;
+      }
+      signal.addEventListener("abort", abortHandler, { once: true });
+    });
+    return {
+      abortPromise,
+      cleanupAbortListener: () => {
+        if (abortHandler) {
+          signal.removeEventListener("abort", abortHandler);
+        }
+      }
+    };
+  }
+};
+
+export {
+  JobExecutionRuntime
+};
+//# sourceMappingURL=chunk-KI47AJ6U.js.map

package/build/chunk-KI47AJ6U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/job_runtime.ts"],"sourcesContent":["import * as errors from './exceptions.js'\nimport type { Job } from './job.js'\nimport type { Duration, JobContext, JobOptions, RetryConfig } from './types/main.js'\nimport { parse } from './utils.js'\n\nexport type JobExecutionOutcome =\n  | { type: 'completed' }\n  | { type: 'retry'; retryAt?: Date }\n  | {\n      type: 'failed'\n      reason: 'timeout' | 'no-retries' | 'max-attempts'\n      storageError: Error\n      hookError: Error\n    }\n\ntype JobExecutionRuntimeConfig = {\n  jobName: string\n  options?: JobOptions\n  retryConfig: RetryConfig\n  defaultTimeout?: Duration\n}\n\ntype JobExecutionRuntimeFactoryOptions = {\n  jobName: string\n  options?: JobOptions\n  retryConfig: RetryConfig\n  defaultTimeout?: Duration\n}\n\n/**\n * Shared execution policy for a single job runtime.\n *\n * It encapsulates timeout resolution and retry/failure decisions so the\n * worker and the sync adapter follow the same execution rules.\n */\nexport class JobExecutionRuntime {\n  readonly #jobName: string\n  readonly #options: JobOptions\n  readonly #retryConfig: RetryConfig\n  readonly #timeout?: number\n\n  /**\n   * Build a runtime from already-resolved queue/job execution config.\n   */\n  static from({\n    jobName,\n    options,\n    retryConfig,\n    defaultTimeout,\n  }: JobExecutionRuntimeFactoryOptions): JobExecutionRuntime {\n    return new JobExecutionRuntime({\n      jobName,\n      options,\n      retryConfig,\n      defaultTimeout,\n    })\n  }\n\n  get maxRetries(): number | undefined {\n    return this.#retryConfig.maxRetries\n  }\n\n  /**\n   * Create a runtime with fully resolved retry and timeout settings.\n   */\n  constructor({ jobName, options, retryConfig, defaultTimeout }: JobExecutionRuntimeConfig) {\n    this.#jobName = jobName\n    this.#options = options || {}\n    this.#retryConfig = retryConfig\n\n    const timeout = this.#options.timeout ?? defaultTimeout\n    this.#timeout = timeout === undefined ? undefined : parse(timeout)\n  }\n\n  /**\n   * Execute a hydrated job instance and enforce the configured timeout.\n   */\n  async execute(instance: Job, payload: unknown, context: JobContext): Promise<void> {\n    if (this.#timeout === undefined) {\n      instance.$hydrate(payload, context)\n      return instance.execute()\n    }\n\n    const signal = AbortSignal.timeout(this.#timeout)\n    instance.$hydrate(payload, context, signal)\n\n    const { abortPromise, cleanupAbortListener } = this.#createTimeoutAbortRace(\n      signal,\n      instance.constructor.name\n    )\n\n    try {\n      await Promise.race([instance.execute(), abortPromise])\n    } finally {\n      cleanupAbortListener()\n    }\n  }\n\n  /**\n   * Convert an execution error into a retry or permanent-failure outcome.\n   */\n  resolveFailure(error: Error, attempts: number): JobExecutionOutcome {\n    if (error instanceof errors.E_JOB_TIMEOUT && this.#options.failOnTimeout) {\n      return {\n        type: 'failed',\n        reason: 'timeout',\n        storageError: error,\n        hookError: error,\n      }\n    }\n\n    if (typeof this.#retryConfig.maxRetries === 'undefined' || this.#retryConfig.maxRetries <= 0) {\n      return {\n        type: 'failed',\n        reason: 'no-retries',\n        storageError: error,\n        hookError: error,\n      }\n    }\n\n    if (attempts >= this.#retryConfig.maxRetries) {\n      return {\n        type: 'failed',\n        reason: 'max-attempts',\n        storageError: error,\n        hookError: new errors.E_JOB_MAX_ATTEMPTS_REACHED([this.#jobName], { cause: error }),\n      }\n    }\n\n    if (this.#retryConfig.backoff) {\n      return {\n        type: 'retry',\n        retryAt: this.#retryConfig.backoff().getNextRetryAt(attempts + 1),\n      }\n    }\n\n    return { type: 'retry' }\n  }\n\n  /**\n   * Create the timeout race used to abort a job execution cleanly.\n   */\n  #createTimeoutAbortRace(signal: AbortSignal, runtimeJobName: string) {\n    const timeout = this.#timeout!\n    let abortHandler: (() => void) | undefined\n\n    const abortPromise = new Promise<never>((_, reject) => {\n      abortHandler = () => {\n        reject(new errors.E_JOB_TIMEOUT([runtimeJobName, timeout]))\n      }\n\n      if (signal.aborted) {\n        abortHandler()\n        return\n      }\n\n      signal.addEventListener('abort', abortHandler, { once: true })\n    })\n\n    return {\n      abortPromise,\n      cleanupAbortListener: () => {\n        if (abortHandler) {\n          signal.removeEventListener('abort', abortHandler)\n        }\n      },\n    }\n  }\n}\n"],"mappings":";;;;;;;AAmCO,IAAM,sBAAN,MAAM,qBAAoB;AAAA,EACtB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA,EAKT,OAAO,KAAK;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,GAA2D;AACzD,WAAO,IAAI,qBAAoB;AAAA,MAC7B;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,IAAI,aAAiC;AACnC,WAAO,KAAK,aAAa;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKA,YAAY,EAAE,SAAS,SAAS,aAAa,eAAe,GAA8B;AACxF,SAAK,WAAW;AAChB,SAAK,WAAW,WAAW,CAAC;AAC5B,SAAK,eAAe;AAEpB,UAAM,UAAU,KAAK,SAAS,WAAW;AACzC,SAAK,WAAW,YAAY,SAAY,SAAY,MAAM,OAAO;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,QAAQ,UAAe,SAAkB,SAAoC;AACjF,QAAI,KAAK,aAAa,QAAW;AAC/B,eAAS,SAAS,SAAS,OAAO;AAClC,aAAO,SAAS,QAAQ;AAAA,IAC1B;AAEA,UAAM,SAAS,YAAY,QAAQ,KAAK,QAAQ;AAChD,aAAS,SAAS,SAAS,SAAS,MAAM;AAE1C,UAAM,EAAE,cAAc,qBAAqB,IAAI,KAAK;AAAA,MAClD;AAAA,MACA,SAAS,YAAY;AAAA,IACvB;AAEA,QAAI;AACF,YAAM,QAAQ,KAAK,CAAC,SAAS,QAAQ,GAAG,YAAY,CAAC;AAAA,IACvD,UAAE;AACA,2BAAqB;AAAA,IACvB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,eAAe,OAAc,UAAuC;AAClE,QAAI,iBAAwB,iBAAiB,KAAK,SAAS,eAAe;AACxE,aAAO;AAAA,QACL,MAAM;AAAA,QACN,QAAQ;AAAA,QACR,cAAc;AAAA,QACd,WAAW;AAAA,MACb;AAAA,IACF;AAEA,QAAI,OAAO,KAAK,aAAa,eAAe,eAAe,KAAK,aAAa,cAAc,GAAG;AAC5F,aAAO;AAAA,QACL,MAAM;AAAA,QACN,QAAQ;AAAA,QACR,cAAc;AAAA,QACd,WAAW;AAAA,MACb;AAAA,IACF;AAEA,QAAI,YAAY,KAAK,aAAa,YAAY;AAC5C,aAAO;AAAA,QACL,MAAM;AAAA,QACN,QAAQ;AAAA,QACR,cAAc;AAAA,QACd,WAAW,IAAW,2BAA2B,CAAC,KAAK,QAAQ,GAAG,EAAE,OAAO,MAAM,CAAC;AAAA,MACpF;AAAA,IACF;AAEA,QAAI,KAAK,aAAa,SAAS;AAC7B,aAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS,KAAK,aAAa,QAAQ,EAAE,eAAe,WAAW,CAAC;AAAA,MAClE;AAAA,IACF;AAEA,WAAO,EAAE,MAAM,QAAQ;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA,EAKA,wBAAwB,QAAqB,gBAAwB;AACnE,UAAM,UAAU,KAAK;AACrB,QAAI;AAEJ,UAAM,eAAe,IAAI,QAAe,CAAC,GAAG,WAAW;AACrD,qBAAe,MAAM;AACnB,eAAO,IAAW,cAAc,CAAC,gBAAgB,OAAO,CAAC,CAAC;AAAA,MAC5D;AAEA,UAAI,OAAO,SAAS;AAClB,qBAAa;AACb;AAAA,MACF;AAEA,aAAO,iBAAiB,SAAS,cAAc,EAAE,MAAM,KAAK,CAAC;AAAA,IAC/D,CAAC;AAED,WAAO;AAAA,MACL;AAAA,MACA,sBAAsB,MAAM;AAC1B,YAAI,cAAc;AAChB,iBAAO,oBAAoB,SAAS,YAAY;AAAA,QAClD;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/build/chunk-PZ5AY32C.js

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-PZ5AY32C.js.map

package/build/chunk-PZ5AY32C.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/build/{chunk-ZZFSQY36.js → chunk-QEFYHCL7.js}

@@ -1,8 +1,6 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
 
 // src/exceptions.ts
 var exceptions_exports = {};
@@ -144,4 +142,4 @@ export {
   parse,
   calculateScore
 };
-//# sourceMappingURL=chunk-ZZFSQY36.js.map
+//# sourceMappingURL=chunk-QEFYHCL7.js.map

package/build/{chunk-ZZFSQY36.js.map → chunk-QEFYHCL7.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/exceptions.ts","../src/constants.ts","../src/utils.ts"],"sourcesContent":["import { createError } from '@poppinss/utils/exception'\n\nexport const E_INVALID_DURATION_EXPRESSION = createError(\n  'Invalid duration expression: \"%s\"',\n  'E_INVALID_DURATION_EXPRESSION',\n  500\n)\n\nexport const E_INVALID_BASE_DELAY = createError<[reason: string]>(\n  'Invalid base delay. Reason: %s',\n  'E_INVALID_BASE_DELAY',\n  500\n)\n\nexport const E_INVALID_MAX_DELAY = createError<[reason: string]>(\n  'Invalid max delay. Reason: %s',\n  'E_INVALID_MAX_DELAY',\n  500\n)\n\nexport const E_INVALID_MULTIPLIER = createError<[reason: string]>(\n  'Invalid multiplier. Reason: %s',\n  'E_INVALID_MULTIPLIER',\n  500\n)\n\nexport const E_CONFIGURATION_ERROR = createError<[reason: string]>(\n  'Configuration error. Reason: %s',\n  'E_CONFIGURATION_ERROR',\n  500\n)\n\nexport const E_JOB_NOT_FOUND = createError<[jobName: string]>(\n  'Requested job \"%s\" is not registered',\n  'E_JOB_NOT_FOUND'\n)\n\nexport const E_JOB_MAX_ATTEMPTS_REACHED = createError<[jobName: string]>(\n  'The job \"%s\" has reached the maximum number of retry attempts',\n  'E_JOB_MAX_ATTEMPTS_REACHED'\n)\n\nexport const E_JOB_TIMEOUT = createError<[jobName: string, timeout: number]>(\n  'The job \"%s\" has exceeded the timeout of %dms',\n  'E_JOB_TIMEOUT'\n)\n\nexport const E_QUEUE_NOT_INITIALIZED = createError(\n  'QueueManager is not initialized. Call QueueManager.init() before using it.',\n  'E_QUEUE_NOT_INITIALIZED',\n  500\n)\n\nexport const E_ADAPTER_INIT_ERROR = createError<[adapterName: string, originalMessage: string]>(\n  'Failed to initialize adapter \"%s\". Reason: %s',\n  'E_ADAPTER_INIT_ERROR',\n  500\n)\n\nexport const E_NO_JOBS_FOUND = createError<[patterns: string]>(\n  'No jobs found for the specified locations: %s. Verify your glob patterns match your job files.',\n  'E_NO_JOBS_FOUND',\n  500\n)\n\nexport const E_INVALID_CRON_EXPRESSION = createError<[expression: string, reason: string]>(\n  'Invalid cron expression \"%s\": %s',\n  'E_INVALID_CRON_EXPRESSION',\n  500\n)\n\nexport const E_INVALID_SCHEDULE_CONFIG = createError<[reason: string]>(\n  'Invalid schedule configuration: %s',\n  'E_INVALID_SCHEDULE_CONFIG',\n  500\n)\n","/**\n * Default job priority (1-10 scale, lower = higher priority)\n */\nexport const DEFAULT_PRIORITY = 5\n\n/**\n * Multiplier used in score calculation: priority * multiplier + timestamp\n *\n * This ensures higher priority jobs are processed first,\n * while preserving FIFO order within the same priority.\n * The value (1e13) leaves room for ~300 years of millisecond timestamps.\n */\nexport const PRIORITY_SCORE_MULTIPLIER = 1e13\n\n/**\n * Default delay when the worker is idle (no jobs in queue)\n */\nexport const DEFAULT_IDLE_DELAY = '2s'\n\n/**\n * Default interval between stalled job checks\n */\nexport const DEFAULT_STALLED_INTERVAL = '30s'\n\n/**\n * Default threshold after which a job is considered stalled\n */\nexport const DEFAULT_STALLED_THRESHOLD = '30s'\n\n/**\n * Default delay before retrying after an error\n */\nexport const DEFAULT_ERROR_RETRY_DELAY = '5s'\n","import { parse as parseDuration } from '@lukeed/ms'\nimport type { Duration, JobRetention } from './types/main.js'\nimport * as errors from './exceptions.js'\nimport { PRIORITY_SCORE_MULTIPLIER } from './constants.js'\n\nexport interface ResolvedRetention {\n  keep: boolean\n  maxAge: number\n  maxCount: number\n}\n\nexport function resolveRetention(retention?: JobRetention): ResolvedRetention {\n  if (retention === undefined || retention === true) {\n    return { keep: false, maxAge: 0, maxCount: 0 }\n  }\n\n  if (retention === false) {\n    return { keep: true, maxAge: 0, maxCount: 0 }\n  }\n\n  return {\n    keep: true,\n    maxAge: retention.age ? parse(retention.age) : 0,\n    maxCount: retention.count ?? 0,\n  }\n}\n\nexport function parse(duration: Duration): number {\n  if (typeof duration === 'number') {\n    return duration\n  }\n\n  const milliseconds = parseDuration(duration)\n\n  if (typeof milliseconds === 'undefined') {\n    throw new errors.E_INVALID_DURATION_EXPRESSION([duration])\n  }\n\n  return milliseconds\n}\n\n/**\n * Calculate the score for job ordering in the queue.\n * Lower scores are processed first.\n *\n * @param priority - Job priority (1-10, lower = higher priority)\n * @param timestamp - Timestamp in milliseconds\n * @returns Score for queue ordering\n */\nexport function calculateScore(priority: number, timestamp: number): number {\n  return priority * PRIORITY_SCORE_MULTIPLIER + timestamp\n}\n"],"mappings":";;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SAAS,mBAAmB;AAErB,IAAM,gCAAgC;AAAA,EAC3C;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,sBAAsB;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,wBAAwB;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,kBAAkB;AAAA,EAC7B;AAAA,EACA;AACF;AAEO,IAAM,6BAA6B;AAAA,EACxC;AAAA,EACA;AACF;AAEO,IAAM,gBAAgB;AAAA,EAC3B;AAAA,EACA;AACF;AAEO,IAAM,0BAA0B;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,kBAAkB;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,4BAA4B;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,4BAA4B;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AACF;;;ACxEO,IAAM,mBAAmB;AASzB,IAAM,4BAA4B;AAKlC,IAAM,qBAAqB;AAK3B,IAAM,2BAA2B;AAKjC,IAAM,4BAA4B;AAKlC,IAAM,4BAA4B;;;AChCzC,SAAS,SAAS,qBAAqB;AAWhC,SAAS,iBAAiB,WAA6C;AAC5E,MAAI,cAAc,UAAa,cAAc,MAAM;AACjD,WAAO,EAAE,MAAM,OAAO,QAAQ,GAAG,UAAU,EAAE;AAAA,EAC/C;AAEA,MAAI,cAAc,OAAO;AACvB,WAAO,EAAE,MAAM,MAAM,QAAQ,GAAG,UAAU,EAAE;AAAA,EAC9C;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,QAAQ,UAAU,MAAM,MAAM,UAAU,GAAG,IAAI;AAAA,IAC/C,UAAU,UAAU,SAAS;AAAA,EAC/B;AACF;AAEO,SAAS,MAAM,UAA4B;AAChD,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,cAAc,QAAQ;AAE3C,MAAI,OAAO,iBAAiB,aAAa;AACvC,UAAM,IAAW,8BAA8B,CAAC,QAAQ,CAAC;AAAA,EAC3D;AAEA,SAAO;AACT;AAUO,SAAS,eAAe,UAAkB,WAA2B;AAC1E,SAAO,WAAW,4BAA4B;AAChD;","names":[]}
+{"version":3,"sources":["../src/exceptions.ts","../src/constants.ts","../src/utils.ts"],"sourcesContent":["import { createError } from '@poppinss/utils/exception'\n\nexport const E_INVALID_DURATION_EXPRESSION = createError(\n  'Invalid duration expression: \"%s\"',\n  'E_INVALID_DURATION_EXPRESSION',\n  500\n)\n\nexport const E_INVALID_BASE_DELAY = createError<[reason: string]>(\n  'Invalid base delay. Reason: %s',\n  'E_INVALID_BASE_DELAY',\n  500\n)\n\nexport const E_INVALID_MAX_DELAY = createError<[reason: string]>(\n  'Invalid max delay. Reason: %s',\n  'E_INVALID_MAX_DELAY',\n  500\n)\n\nexport const E_INVALID_MULTIPLIER = createError<[reason: string]>(\n  'Invalid multiplier. Reason: %s',\n  'E_INVALID_MULTIPLIER',\n  500\n)\n\nexport const E_CONFIGURATION_ERROR = createError<[reason: string]>(\n  'Configuration error. Reason: %s',\n  'E_CONFIGURATION_ERROR',\n  500\n)\n\nexport const E_JOB_NOT_FOUND = createError<[jobName: string]>(\n  'Requested job \"%s\" is not registered',\n  'E_JOB_NOT_FOUND'\n)\n\nexport const E_JOB_MAX_ATTEMPTS_REACHED = createError<[jobName: string]>(\n  'The job \"%s\" has reached the maximum number of retry attempts',\n  'E_JOB_MAX_ATTEMPTS_REACHED'\n)\n\nexport const E_JOB_TIMEOUT = createError<[jobName: string, timeout: number]>(\n  'The job \"%s\" has exceeded the timeout of %dms',\n  'E_JOB_TIMEOUT'\n)\n\nexport const E_QUEUE_NOT_INITIALIZED = createError(\n  'QueueManager is not initialized. Call QueueManager.init() before using it.',\n  'E_QUEUE_NOT_INITIALIZED',\n  500\n)\n\nexport const E_ADAPTER_INIT_ERROR = createError<[adapterName: string, originalMessage: string]>(\n  'Failed to initialize adapter \"%s\". Reason: %s',\n  'E_ADAPTER_INIT_ERROR',\n  500\n)\n\nexport const E_NO_JOBS_FOUND = createError<[patterns: string]>(\n  'No jobs found for the specified locations: %s. Verify your glob patterns match your job files.',\n  'E_NO_JOBS_FOUND',\n  500\n)\n\nexport const E_INVALID_CRON_EXPRESSION = createError<[expression: string, reason: string]>(\n  'Invalid cron expression \"%s\": %s',\n  'E_INVALID_CRON_EXPRESSION',\n  500\n)\n\nexport const E_INVALID_SCHEDULE_CONFIG = createError<[reason: string]>(\n  'Invalid schedule configuration: %s',\n  'E_INVALID_SCHEDULE_CONFIG',\n  500\n)\n","/**\n * Default job priority (1-10 scale, lower = higher priority)\n */\nexport const DEFAULT_PRIORITY = 5\n\n/**\n * Multiplier used in score calculation: priority * multiplier + timestamp\n *\n * This ensures higher priority jobs are processed first,\n * while preserving FIFO order within the same priority.\n * The value (1e13) leaves room for ~300 years of millisecond timestamps.\n */\nexport const PRIORITY_SCORE_MULTIPLIER = 1e13\n\n/**\n * Default delay when the worker is idle (no jobs in queue)\n */\nexport const DEFAULT_IDLE_DELAY = '2s'\n\n/**\n * Default interval between stalled job checks\n */\nexport const DEFAULT_STALLED_INTERVAL = '30s'\n\n/**\n * Default threshold after which a job is considered stalled\n */\nexport const DEFAULT_STALLED_THRESHOLD = '30s'\n\n/**\n * Default delay before retrying after an error\n */\nexport const DEFAULT_ERROR_RETRY_DELAY = '5s'\n","import { parse as parseDuration } from '@lukeed/ms'\nimport type { Duration, JobRetention } from './types/main.js'\nimport * as errors from './exceptions.js'\nimport { PRIORITY_SCORE_MULTIPLIER } from './constants.js'\n\nexport interface ResolvedRetention {\n  keep: boolean\n  maxAge: number\n  maxCount: number\n}\n\nexport function resolveRetention(retention?: JobRetention): ResolvedRetention {\n  if (retention === undefined || retention === true) {\n    return { keep: false, maxAge: 0, maxCount: 0 }\n  }\n\n  if (retention === false) {\n    return { keep: true, maxAge: 0, maxCount: 0 }\n  }\n\n  return {\n    keep: true,\n    maxAge: retention.age ? parse(retention.age) : 0,\n    maxCount: retention.count ?? 0,\n  }\n}\n\nexport function parse(duration: Duration): number {\n  if (typeof duration === 'number') {\n    return duration\n  }\n\n  const milliseconds = parseDuration(duration)\n\n  if (typeof milliseconds === 'undefined') {\n    throw new errors.E_INVALID_DURATION_EXPRESSION([duration])\n  }\n\n  return milliseconds\n}\n\n/**\n * Calculate the score for job ordering in the queue.\n * Lower scores are processed first.\n *\n * @param priority - Job priority (1-10, lower = higher priority)\n * @param timestamp - Timestamp in milliseconds\n * @returns Score for queue ordering\n */\nexport function calculateScore(priority: number, timestamp: number): number {\n  return priority * PRIORITY_SCORE_MULTIPLIER + timestamp\n}\n"],"mappings":";;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SAAS,mBAAmB;AAErB,IAAM,gCAAgC;AAAA,EAC3C;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,sBAAsB;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,wBAAwB;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,kBAAkB;AAAA,EAC7B;AAAA,EACA;AACF;AAEO,IAAM,6BAA6B;AAAA,EACxC;AAAA,EACA;AACF;AAEO,IAAM,gBAAgB;AAAA,EAC3B;AAAA,EACA;AACF;AAEO,IAAM,0BAA0B;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,kBAAkB;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,4BAA4B;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AACF;AAEO,IAAM,4BAA4B;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AACF;;;ACxEO,IAAM,mBAAmB;AASzB,IAAM,4BAA4B;AAKlC,IAAM,qBAAqB;AAK3B,IAAM,2BAA2B;AAKjC,IAAM,4BAA4B;AAKlC,IAAM,4BAA4B;;;AChCzC,SAAS,SAAS,qBAAqB;AAWhC,SAAS,iBAAiB,WAA6C;AAC5E,MAAI,cAAc,UAAa,cAAc,MAAM;AACjD,WAAO,EAAE,MAAM,OAAO,QAAQ,GAAG,UAAU,EAAE;AAAA,EAC/C;AAEA,MAAI,cAAc,OAAO;AACvB,WAAO,EAAE,MAAM,MAAM,QAAQ,GAAG,UAAU,EAAE;AAAA,EAC9C;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,QAAQ,UAAU,MAAM,MAAM,UAAU,GAAG,IAAI;AAAA,IAC/C,UAAU,UAAU,SAAS;AAAA,EAC/B;AACF;AAEO,SAAS,MAAM,UAA4B;AAChD,MAAI,OAAO,aAAa,UAAU;AAChC,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,cAAc,QAAQ;AAE3C,MAAI,OAAO,iBAAiB,aAAa;AACvC,UAAM,IAAW,8BAA8B,CAAC,QAAQ,CAAC;AAAA,EAC3D;AAEA,SAAO;AACT;AAUO,SAAS,eAAe,UAAkB,WAA2B;AAC1E,SAAO,WAAW,4BAA4B;AAChD;","names":[]}

package/build/{chunk-6EBS7CW4.js → chunk-VHN3XZDC.js}

@@ -1,3 +1,6 @@
+import {
+  dispatchChannel
+} from "./chunk-WVLSICD4.js";
 import {
   DEFAULT_PRIORITY,
   E_ADAPTER_INIT_ERROR,
@@ -7,7 +10,7 @@ import {
   E_JOB_NOT_FOUND,
   E_QUEUE_NOT_INITIALIZED,
   parse
-} from "./chunk-ZZFSQY36.js";
+} from "./chunk-QEFYHCL7.js";
 
 // src/drivers/fake_adapter.ts
 import assert from "assert/strict";
@@ -185,17 +188,93 @@ var ConsoleLogger = class _ConsoleLogger {
 };
 var consoleLogger = new ConsoleLogger();
 
+// src/queue_config_resolver.ts
+var QueueConfigResolver = class _QueueConfigResolver {
+  #globalRetryConfig;
+  #globalJobOptions;
+  #queueConfigs;
+  #workerTimeout;
+  /**
+   * Create a resolver from the queue manager config.
+   */
+  static from(config) {
+    return new _QueueConfigResolver({
+      globalRetryConfig: config.retry,
+      globalJobOptions: config.defaultJobOptions,
+      queueConfigs: new Map(Object.entries(config.queues || {})),
+      workerTimeout: config.worker?.timeout
+    });
+  }
+  /**
+   * Create a resolver from already-materialized config fragments.
+   */
+  constructor({
+    globalRetryConfig,
+    globalJobOptions,
+    queueConfigs,
+    workerTimeout
+  }) {
+    this.#globalRetryConfig = globalRetryConfig;
+    this.#globalJobOptions = globalJobOptions;
+    this.#queueConfigs = queueConfigs ?? /* @__PURE__ */ new Map();
+    this.#workerTimeout = workerTimeout;
+  }
+  /**
+   * Resolve the retry policy for a job using priority: job > queue > global.
+   */
+  resolveRetryConfig(queue, jobOptions) {
+    const queueConfig = this.#queueConfigs.get(queue);
+    const queueRetryConfig = queueConfig?.retry || {};
+    const jobRetryConfig = this.#normalizeJobRetryConfig(jobOptions);
+    const maxRetries = jobRetryConfig?.maxRetries ?? queueRetryConfig.maxRetries ?? this.#globalRetryConfig?.maxRetries ?? 0;
+    const backoff = jobRetryConfig?.backoff || queueRetryConfig.backoff || this.#globalRetryConfig?.backoff;
+    return { maxRetries, backoff };
+  }
+  /**
+   * Resolve effective retention options using priority: job > queue > global.
+   */
+  resolveJobOptions(queue, jobOptions) {
+    const queueConfig = this.#queueConfigs.get(queue);
+    const queueJobOptions = queueConfig?.defaultJobOptions;
+    return {
+      removeOnComplete: jobOptions?.removeOnComplete ?? queueJobOptions?.removeOnComplete ?? this.#globalJobOptions?.removeOnComplete,
+      removeOnFail: jobOptions?.removeOnFail ?? queueJobOptions?.removeOnFail ?? this.#globalJobOptions?.removeOnFail
+    };
+  }
+  /**
+   * Return the configured default worker timeout.
+   */
+  getWorkerTimeout() {
+    return this.#workerTimeout;
+  }
+  /**
+   * Normalize job retry settings so top-level `maxRetries` participates in the
+   * merge like `retry.maxRetries`.
+   */
+  #normalizeJobRetryConfig(jobOptions) {
+    if (!jobOptions || jobOptions.retry === void 0 && jobOptions.maxRetries === void 0) {
+      return void 0;
+    }
+    return {
+      ...jobOptions.retry,
+      maxRetries: jobOptions.retry?.maxRetries ?? jobOptions.maxRetries
+    };
+  }
+};
+
 // src/queue_manager.ts
+var noopInternalOperationWrapper = async (fn) => fn();
+var noopExecutionWrapper = async (fn) => fn();
 var QueueManagerSingleton = class {
   #initialized = false;
   #defaultAdapter;
   #adapters = {};
   #adapterInstances = /* @__PURE__ */ new Map();
-  #globalRetryConfig;
-  #globalJobOptions;
-  #queueConfigs = /* @__PURE__ */ new Map();
   #logger = consoleLogger;
   #jobFactory;
+  #internalOperationWrapper;
+  #executionWrapper;
+  #configResolver = new QueueConfigResolver({});
   #fakeState;
   /**
    * Initialize the queue system with the given configuration.
@@ -224,18 +303,14 @@ var QueueManagerSingleton = class {
   async init(config) {
     debug_default("initializing queue manager with config: %O", config);
     this.#validateConfig(config);
-    this.#adapterInstances.clear();
+    await this.#cleanupBeforeReinitialization();
     this.#defaultAdapter = config.default;
     this.#adapters = config.adapters;
-    this.#globalRetryConfig = config.retry;
-    this.#globalJobOptions = config.defaultJobOptions;
     this.#logger = config.logger ?? consoleLogger;
     this.#jobFactory = config.jobFactory;
-    if (config.queues) {
-      for (const [queue, queueConfig] of Object.entries(config.queues)) {
-        this.#queueConfigs.set(queue, queueConfig);
-      }
-    }
+    this.#internalOperationWrapper = config.internalOperationWrapper;
+    this.#executionWrapper = config.executionWrapper;
+    this.#configResolver = QueueConfigResolver.from(config);
     if (config.locations && config.locations.length > 0) {
       const registered = await Locator.registerFromGlob(config.locations);
       if (registered === 0) {
@@ -247,6 +322,40 @@ var QueueManagerSingleton = class {
     this.#initialized = true;
     return this;
   }
+  /**
+   * Destroy any materialized adapters from the current configuration before
+   * replacing it with a new one.
+   */
+  async #cleanupBeforeReinitialization() {
+    const destroyedAdapters = /* @__PURE__ */ new Set();
+    await this.#destroyAdapters(this.#adapterInstances, destroyedAdapters);
+    if (this.#fakeState) {
+      await this.#destroyAdapter("fake", this.#fakeState.fakeAdapter, destroyedAdapters);
+      await this.#destroyAdapters(this.#fakeState.adapterInstances, destroyedAdapters);
+      this.#fakeState = void 0;
+    }
+    this.#adapterInstances.clear();
+  }
+  /**
+   * Destroy a collection of adapters while avoiding double-destroying the same
+   * instance through multiple references.
+   */
+  async #destroyAdapters(adapters, destroyedAdapters) {
+    for (const [name, adapter] of adapters) {
+      await this.#destroyAdapter(name, adapter, destroyedAdapters);
+    }
+  }
+  /**
+   * Destroy a single adapter once for the current cleanup pass.
+   */
+  async #destroyAdapter(name, adapter, destroyedAdapters) {
+    if (destroyedAdapters.has(adapter)) {
+      return;
+    }
+    destroyedAdapters.add(adapter);
+    debug_default('destroying adapter "%s" before reinitialization', name);
+    await adapter.destroy();
+  }
   /**
    * Get an adapter instance by name.
    *
@@ -324,11 +433,11 @@ var QueueManagerSingleton = class {
       defaultAdapter: this.#defaultAdapter,
       adapters: this.#adapters,
       adapterInstances: this.#adapterInstances,
-      globalRetryConfig: this.#globalRetryConfig,
-      globalJobOptions: this.#globalJobOptions,
-      queueConfigs: this.#queueConfigs,
       logger: this.#logger,
       jobFactory: this.#jobFactory,
+      internalOperationWrapper: this.#internalOperationWrapper,
+      executionWrapper: this.#executionWrapper,
+      configResolver: this.#configResolver,
       fakeAdapter
     };
     const fakeFactory = () => fakeAdapter;
@@ -356,35 +465,11 @@ var QueueManagerSingleton = class {
     this.#defaultAdapter = state.defaultAdapter;
     this.#adapters = state.adapters;
     this.#adapterInstances = state.adapterInstances;
-    this.#globalRetryConfig = state.globalRetryConfig;
-    this.#globalJobOptions = state.globalJobOptions;
-    this.#queueConfigs = state.queueConfigs;
     this.#logger = state.logger;
     this.#jobFactory = state.jobFactory;
-  }
-  /**
-   * Get the merged retry configuration for a job.
-   *
-   * Configuration is merged with priority: job > queue > global.
-   * This allows specific jobs or queues to override global defaults.
-   *
-   * @param queue - The queue name
-   * @param jobRetryConfig - Optional job-level retry config
-   * @returns The merged retry configuration
-   *
-   * @example
-   * ```typescript
-   * // Global: maxRetries=3, Queue: maxRetries=5, Job: maxRetries=1
-   * // Result: maxRetries=1 (job wins)
-   * const config = QueueManager.getMergedRetryConfig('emails', { maxRetries: 1 })
-   * ```
-   */
-  getMergedRetryConfig(queue, jobRetryConfig) {
-    const queueConfig = this.#queueConfigs.get(queue);
-    const queueRetryConfig = queueConfig?.retry || {};
-    let maxRetries = jobRetryConfig?.maxRetries ?? queueRetryConfig.maxRetries ?? this.#globalRetryConfig?.maxRetries ?? 0;
-    let backoff = jobRetryConfig?.backoff || queueRetryConfig.backoff || this.#globalRetryConfig?.backoff;
-    return { maxRetries, backoff };
+    this.#internalOperationWrapper = state.internalOperationWrapper;
+    this.#executionWrapper = state.executionWrapper;
+    this.#configResolver = state.configResolver;
   }
   /**
    * Get the configured job factory for custom instantiation.
@@ -395,15 +480,37 @@ var QueueManagerSingleton = class {
     return this.#jobFactory;
   }
   /**
-   * Get the merged job options for a job (priority: job > queue > global).
+   * Whether the queue manager has been initialized.
    */
-  getMergedJobOptions(queue, jobOptions) {
-    const queueConfig = this.#queueConfigs.get(queue);
-    const queueJobOptions = queueConfig?.defaultJobOptions;
-    return {
-      removeOnComplete: jobOptions?.removeOnComplete ?? queueJobOptions?.removeOnComplete ?? this.#globalJobOptions?.removeOnComplete,
-      removeOnFail: jobOptions?.removeOnFail ?? queueJobOptions?.removeOnFail ?? this.#globalJobOptions?.removeOnFail
-    };
+  isInitialized() {
+    return this.#initialized;
+  }
+  /**
+   * Get the configured logger used by the queue runtime.
+   */
+  getLogger() {
+    return this.#logger;
+  }
+  /**
+   * Get the configured internal operation wrapper.
+   */
+  getInternalOperationWrapper() {
+    return this.#internalOperationWrapper ?? noopInternalOperationWrapper;
+  }
+  /**
+   * Get the configured execution wrapper.
+   */
+  getExecutionWrapper() {
+    return this.#executionWrapper ?? noopExecutionWrapper;
+  }
+  /**
+   * Get the resolver responsible for effective queue/job runtime config.
+   */
+  getConfigResolver() {
+    if (!this.#initialized) {
+      throw new E_QUEUE_NOT_INITIALIZED();
+    }
+    return this.#configResolver;
   }
   #validateConfig(config) {
     if (!config.adapters || Object.keys(config.adapters).length === 0) {
@@ -449,6 +556,9 @@ var QueueManagerSingleton = class {
     }
     this.#adapterInstances.clear();
     this.#initialized = false;
+    this.#internalOperationWrapper = void 0;
+    this.#executionWrapper = void 0;
+    this.#configResolver = new QueueConfigResolver({});
     this.#fakeState = void 0;
   }
 };
@@ -588,7 +698,9 @@ var JobDispatcher = class {
     const id = randomUUID();
     debug_default("dispatching job %s with id %s using payload %s", this.#name, id, this.#payload);
     const adapter = this.#getAdapterInstance();
-    const payload = {
+    const wrapInternal = QueueManager.getInternalOperationWrapper();
+    const parsedDelay = this.#delay ? parse(this.#delay) : void 0;
+    const jobData = {
       id,
       name: this.#name,
       payload: this.#payload,
@@ -596,15 +708,15 @@ var JobDispatcher = class {
       priority: this.#priority,
       groupId: this.#groupId
     };
-    if (this.#delay) {
-      const parsedDelay = parse(this.#delay);
-      await adapter.pushLaterOn(this.#queue, payload, parsedDelay);
-    } else {
-      await adapter.pushOn(this.#queue, payload);
-    }
-    return {
-      jobId: id
-    };
+    const message = { jobs: [jobData], queue: this.#queue, delay: parsedDelay };
+    await dispatchChannel.tracePromise(async () => {
+      if (parsedDelay !== void 0) {
+        await wrapInternal(() => adapter.pushLaterOn(this.#queue, jobData, parsedDelay));
+      } else {
+        await wrapInternal(() => adapter.pushOn(this.#queue, jobData));
+      }
+    }, message);
+    return { jobId: id };
   }
   /**
    * Thenable implementation for auto-dispatch when awaited.
@@ -729,8 +841,10 @@ var JobBatchDispatcher = class {
    * ```
    */
   async run() {
+    if (this.#payloads.length === 0) return { jobIds: [] };
     debug_default("dispatching %d jobs of type %s", this.#payloads.length, this.#name);
     const adapter = this.#getAdapterInstance();
+    const wrapInternal = QueueManager.getInternalOperationWrapper();
     const jobs = this.#payloads.map((payload) => ({
       id: randomUUID2(),
       name: this.#name,
@@ -739,10 +853,11 @@ var JobBatchDispatcher = class {
       priority: this.#priority,
       groupId: this.#groupId
     }));
-    await adapter.pushManyOn(this.#queue, jobs);
-    return {
-      jobIds: jobs.map((job) => job.id)
-    };
+    const message = { jobs, queue: this.#queue };
+    await dispatchChannel.tracePromise(async () => {
+      await wrapInternal(() => adapter.pushManyOn(this.#queue, jobs));
+    }, message);
+    return { jobIds: jobs.map((job) => job.id) };
   }
   /**
    * Thenable implementation for auto-dispatch when awaited.
@@ -1562,4 +1677,4 @@ export {
   ScheduleBuilder,
   Job
 };
-//# sourceMappingURL=chunk-6EBS7CW4.js.map
+//# sourceMappingURL=chunk-VHN3XZDC.js.map