@open-mercato/queue 0.6.7-develop.6862.1.c11a64ce0a → 0.6.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/queue",
-  "version": "0.6.7-develop.6862.1.c11a64ce0a",
+  "version": "0.6.7",
   "license": "MIT",
   "description": "Multi-strategy job queue with local and BullMQ support",
   "type": "module",
@@ -34,35 +34,29 @@
     }
   },
   "peerDependencies": {
-    "bullmq": "^5.0.0 || ^6.0.0",
-    "bullmq-otel": "^1.3.0"
+    "bullmq": "^5.0.0"
   },
   "peerDependenciesMeta": {
     "bullmq": {
       "optional": true
-    },
-    "bullmq-otel": {
-      "optional": true
     }
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.0.1",
     "jest": "^30.4.2",
-    "ts-jest": "^29.4.12",
+    "ts-jest": "^29.4.11",
     "typescript": "7.0.2"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@open-mercato/shared": "0.6.7-develop.6862.1.c11a64ce0a",
-    "@open-mercato/telemetry": "0.6.7-develop.6862.1.c11a64ce0a"
+    "@open-mercato/shared": "0.6.7"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/open-mercato/open-mercato",
     "directory": "packages/queue"
-  },
-  "stableVersion": "0.6.6"
+  }
 }

package/src/__tests__/async.strategy.test.ts

@@ -18,7 +18,6 @@ const workerOn = jest.fn()
 
 jest.mock('@open-mercato/shared/lib/redis/connection', () => ({
   getRedisUrlOrThrow: jest.fn(),
-  parseRedisUrl: jest.requireActual('@open-mercato/shared/lib/redis/connection').parseRedisUrl,
 }))
 
 jest.mock('bullmq', () => {
@@ -61,7 +60,7 @@ describe('Queue - async strategy', () => {
     getRedisUrlOrThrowMock.mockReturnValue('rediss://default:secret@example.com:6380/1')
   })
 
-  it('passes parsed Redis connection fields to BullMQ for env-based async config', async () => {
+  it('passes the full Redis URL to BullMQ when using env-based async config', async () => {
     const queue = createQueue<{ value: number }>('test-queue', 'async', {
       concurrency: 3,
     })
@@ -70,35 +69,19 @@ describe('Queue - async strategy', () => {
     await queue.process(async () => {})
 
     expect(queueCtor).toHaveBeenCalledWith('test-queue', {
-      connection: {
-        host: 'example.com',
-        port: 6380,
-        username: 'default',
-        password: 'secret',
-        db: 1,
-        tls: {},
-        family: undefined,
-      },
+      connection: { url: 'rediss://default:secret@example.com:6380/1' },
     })
     expect(workerCtor).toHaveBeenCalledWith(
       'test-queue',
       expect.any(Function),
       {
-        connection: {
-          host: 'example.com',
-          port: 6380,
-          username: 'default',
-          password: 'secret',
-          db: 1,
-          tls: {},
-          family: undefined,
-        },
+        connection: { url: 'rediss://default:secret@example.com:6380/1' },
         concurrency: 3,
       },
     )
   })
 
-  it('preserves URL connection semantics when converting to BullMQ fields', async () => {
+  it('preserves an explicit Redis URL without converting it to host/port fields', async () => {
     const queue = createQueue<{ value: number }>('test-queue', 'async', {
       connection: {
         url: 'rediss://user:secret@example.com:6380/4?family=6',
@@ -108,15 +91,7 @@ describe('Queue - async strategy', () => {
     await queue.enqueue({ value: 42 })
 
     expect(queueCtor).toHaveBeenCalledWith('test-queue', {
-      connection: {
-        host: 'example.com',
-        port: 6380,
-        username: 'user',
-        password: 'secret',
-        db: 4,
-        tls: {},
-        family: 6,
-      },
+      connection: { url: 'rediss://user:secret@example.com:6380/4?family=6' },
     })
   })
 
@@ -139,38 +114,6 @@ describe('Queue - async strategy', () => {
     await queue.close()
   })
 
-  it('threads queue retry, lock-duration and stalled-job options to BullMQ', async () => {
-    const queue = createQueue<{ value: number }>('test-queue', 'async', {
-      attempts: 5,
-      lockDuration: 120_000,
-      maxStalledCount: 10,
-    })
-
-    await queue.enqueue({ value: 42 })
-    await queue.process(async () => {})
-
-    expect(queueAdd).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.objectContaining({ payload: { value: 42 } }),
-      expect.objectContaining({ attempts: 5 }),
-    )
-    expect(workerCtor).toHaveBeenCalledWith(
-      'test-queue',
-      expect.any(Function),
-      expect.objectContaining({ lockDuration: 120_000, maxStalledCount: 10 }),
-    )
-  })
-
-  it('leaves BullMQ on its own lock and stall defaults when the options are unset', async () => {
-    const queue = createQueue<{ value: number }>('test-queue', 'async', {})
-
-    await queue.process(async () => {})
-
-    const workerOptions = workerCtor.mock.calls[0]?.[2] as Record<string, unknown>
-    expect(workerOptions).not.toHaveProperty('lockDuration')
-    expect(workerOptions).not.toHaveProperty('maxStalledCount')
-  })
-
   it('removeQueuedJobsByScope removes only queued jobs matching tenant scope', async () => {
     const removeMatching = jest.fn(async () => {})
     const removeAutoIndex = jest.fn(async () => {})

package/src/__tests__/factory.test.ts

@@ -1,9 +1,8 @@
 import { resolveQueueStrategy, createModuleQueue } from '../factory'
-import { getRedisUrlOrThrow, parseRedisUrl } from '@open-mercato/shared/lib/redis/connection'
+import { getRedisUrlOrThrow } from '@open-mercato/shared/lib/redis/connection'
 
 jest.mock('@open-mercato/shared/lib/redis/connection', () => ({
   getRedisUrlOrThrow: jest.fn(),
-  parseRedisUrl: jest.fn(),
 }))
 
 jest.mock('bullmq', () => {
@@ -59,12 +58,10 @@ describe('resolveQueueStrategy', () => {
 describe('createModuleQueue', () => {
   const originalEnv = process.env.QUEUE_STRATEGY
   const getRedisUrlOrThrowMock = getRedisUrlOrThrow as jest.MockedFunction<typeof getRedisUrlOrThrow>
-  const parseRedisUrlMock = parseRedisUrl as jest.MockedFunction<typeof parseRedisUrl>
 
   beforeEach(() => {
     jest.clearAllMocks()
     getRedisUrlOrThrowMock.mockReturnValue('redis://localhost:6379')
-    parseRedisUrlMock.mockReturnValue({ host: 'localhost', port: 6379 })
   })
 
   afterEach(() => {
@@ -88,7 +85,6 @@ describe('createModuleQueue', () => {
     expect(queue.strategy).toBe('async')
     expect(queue.name).toBe('test-queue')
     expect(getRedisUrlOrThrowMock).toHaveBeenCalledWith('QUEUE')
-    expect(parseRedisUrlMock).toHaveBeenCalledWith('redis://localhost:6379')
   })
 
   it('passes concurrency to local strategy', () => {

package/src/__tests__/pending-probe.test.ts

@@ -2,22 +2,7 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { createQueue } from '../factory'
-import { __resetPendingProbeBullMQCache, getQueuePendingProbe } from '../pending-probe'
-
-const asyncQueueConstructor = jest.fn()
-const asyncQueueClose = jest.fn(async () => {})
-const asyncQueueGetJobCounts = jest.fn(async () => ({ waiting: 1, delayed: 0, active: 0 }))
-
-jest.mock('bullmq', () => ({
-  Queue: class MockQueue {
-    constructor(name: string, options: unknown) {
-      asyncQueueConstructor(name, options)
-    }
-
-    getJobCounts = asyncQueueGetJobCounts
-    close = asyncQueueClose
-  },
-}))
+import { getQueuePendingProbe } from '../pending-probe'
 
 describe('getQueuePendingProbe — local strategy', () => {
   const origCwd = process.cwd()
@@ -110,11 +95,6 @@ describe('getQueuePendingProbe — local strategy', () => {
 })
 
 describe('getQueuePendingProbe — async strategy', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    __resetPendingProbeBullMQCache()
-  })
-
   it('reports an error when QUEUE Redis URL is unset and no connection override is provided', async () => {
     const original = process.env.QUEUE_REDIS_URL
     const fallback = process.env.REDIS_URL
@@ -129,23 +109,4 @@ describe('getQueuePendingProbe — async strategy', () => {
       if (fallback !== undefined) process.env.REDIS_URL = fallback
     }
   })
-
-  it('converts a URL override to BullMQ connection fields', async () => {
-    const probe = await getQueuePendingProbe('async-probe', 'async', {
-      connection: { url: 'rediss://probe:secret@example.com:6380/3?family=6' },
-    })
-
-    expect(probe).toEqual(expect.objectContaining({ error: false, ready: 1 }))
-    expect(asyncQueueConstructor).toHaveBeenCalledWith('async-probe', {
-      connection: {
-        host: 'example.com',
-        port: 6380,
-        username: 'probe',
-        password: 'secret',
-        db: 3,
-        tls: {},
-        family: 6,
-      },
-    })
-  })
 })

package/src/factory.ts

@@ -82,16 +82,13 @@ export function resolveQueueStrategy(): QueueStrategyType {
  */
 export function createModuleQueue<T = unknown>(
   name: string,
-  options?: Pick<AsyncQueueOptions, 'attempts' | 'concurrency' | 'lockDuration' | 'maxStalledCount'>,
+  options?: { concurrency?: number },
 ): Queue<T> {
   const strategy = resolveQueueStrategy()
   if (strategy === 'async') {
     return createAsyncQueue<T>(name, {
       connection: { url: getRedisUrlOrThrow('QUEUE') },
       concurrency: options?.concurrency,
-      attempts: options?.attempts,
-      lockDuration: options?.lockDuration,
-      maxStalledCount: options?.maxStalledCount,
     })
   }
   return createLocalQueue<T>(name, { concurrency: options?.concurrency })

package/src/pending-probe.ts

@@ -149,16 +149,14 @@ async function probeAsyncQueue(
     return errorResult(queueName, 'async', new Error('bullmq is not installed'))
   }
 
-  const { getRedisUrl, parseRedisUrl } = await import('@open-mercato/shared/lib/redis/connection')
+  const { getRedisUrl } = await import('@open-mercato/shared/lib/redis/connection')
   let connection = options?.connection
   if (!connection) {
     const url = getRedisUrl('QUEUE')
     if (!url) {
       return errorResult(queueName, 'async', new Error('QUEUE Redis URL is not configured'))
     }
-    connection = parseRedisUrl(url)
-  } else if (connection.url) {
-    connection = parseRedisUrl(connection.url)
+    connection = { url }
   }
 
   let queue: InstanceType<BullMQModuleShape['Queue']> | null = null

package/src/strategies/async.ts

@@ -1,7 +1,5 @@
 import type { Queue, QueuedJob, JobHandler, AsyncQueueOptions, ProcessResult, EnqueueOptions, QueueJobScope } from '../types'
-import { getRedisUrlOrThrow, parseRedisUrl } from '@open-mercato/shared/lib/redis/connection'
-import { getTelemetryRuntime } from '@open-mercato/shared/lib/telemetry/runtime'
-import { attachTraceMetadata, runJobInTrace } from '../tracing'
+import { getRedisUrlOrThrow } from '@open-mercato/shared/lib/redis/connection'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
 const packageLogger = createLogger('queue')
@@ -9,13 +7,13 @@ const packageLogger = createLogger('queue')
 // BullMQ interface types - we define the shape we use to maintain type safety
 // while keeping bullmq as an optional peer dependency
 type ConnectionOptions = {
+  url?: string
   host?: string
   port?: number
   username?: string
   password?: string
   db?: number
   tls?: Record<string, unknown>
-  family?: number
 }
 
 interface BullQueueInterface<T> {
@@ -45,23 +43,14 @@ interface BullWorkerInterface {
 }
 
 interface BullMQModule {
-  Queue: new <T>(name: string, opts: { connection: ConnectionOptions; telemetry?: unknown }) => BullQueueInterface<T>
+  Queue: new <T>(name: string, opts: { connection: ConnectionOptions }) => BullQueueInterface<T>
   Worker: new <T>(
     name: string,
     processor: (job: { id?: string; data: T; attemptsMade: number }) => Promise<void>,
-    opts: {
-      connection: ConnectionOptions
-      concurrency: number
-      telemetry?: unknown
-      lockDuration?: number
-      maxStalledCount?: number
-    }
+    opts: { connection: ConnectionOptions; concurrency: number }
   ) => BullWorkerInterface
 }
 
-/** The `bullmq-otel` package (optional). Loaded only when an OTLP backend is active. */
-type BullMQOtelModule = { BullMQOtel: new (tracerName: string) => object }
-
 const REMOVABLE_JOB_STATES = ['waiting', 'delayed', 'prioritized', 'paused', 'waiting-children']
 
 function payloadMatchesScope(payload: unknown, scope: QueueJobScope): boolean {
@@ -80,13 +69,13 @@ function payloadMatchesScope(payload: unknown, scope: QueueJobScope): boolean {
 /**
  * Resolves Redis connection options from various sources.
  *
- * BullMQ expects ioredis connection fields rather than a nested URL string.
- * Parse URL-based configuration at this boundary while keeping the public
- * queue API compatible with existing `{ url }` callers.
+ * BullMQ expects an ioredis-compatible connection object. Preserve the full
+ * Redis URL under the `url` key so rediss://, username, database, and query
+ * params are not lost in translation.
  */
 function resolveConnection(options?: AsyncQueueOptions['connection']): ConnectionOptions {
   if (options?.url) {
-    return parseRedisUrl(options.url)
+    return { url: options.url }
   }
 
   if (options?.host) {
@@ -97,11 +86,10 @@ function resolveConnection(options?: AsyncQueueOptions['connection']): Connectio
       password: options.password,
       db: options.db,
       tls: options.tls,
-      family: options.family,
     }
   }
 
-  return parseRedisUrl(getRedisUrlOrThrow('QUEUE'))
+  return { url: getRedisUrlOrThrow('QUEUE') }
 }
 
 /**
@@ -123,18 +111,11 @@ export function createAsyncQueue<T = unknown>(
 ): Queue<T> {
   const connection = resolveConnection(options?.connection)
   const concurrency = options?.concurrency ?? 1
-  const attempts = options?.attempts ?? 3
-  const lockDuration = options?.lockDuration
-  const maxStalledCount = options?.maxStalledCount
   const logger = packageLogger.child({ queue: name })
 
   let bullQueue: BullQueueInterface<QueuedJob<T>> | null = null
   let bullWorker: BullWorkerInterface | null = null
   let bullmqModule: BullMQModule | null = null
-  // Resolved once: a BullMQOtel instance (delegate async tracing to BullMQ) or
-  // undefined (use our own metadata._trace carrier instead). Memoized as the
-  // in-flight promise so concurrent first-time callers share one resolution.
-  let telemetryPromise: Promise<object | undefined> | null = null
 
   // -------------------------------------------------------------------------
   // Lazy BullMQ initialization
@@ -153,35 +134,10 @@ export function createAsyncQueue<T = unknown>(
     return bullmqModule
   }
 
-  /**
-   * When an OTLP backend is active, delegate async-queue tracing to `bullmq-otel`
-   * (richer BullMQ-internal spans: add / process / wait / attempts). Returns
-   * `undefined` — meaning "use our own `metadata._trace` carrier" — when telemetry
-   * is off, a non-OTEL backend is selected, or `bullmq-otel` isn't installed. (The
-   * `local` strategy always uses our carrier; it isn't BullMQ, so `bullmq-otel`
-   * cannot instrument it.)
-   */
-  async function getQueueTelemetry(): Promise<object | undefined> {
-    if (!telemetryPromise) {
-      telemetryPromise = (async () => {
-        if (!getTelemetryRuntime()?.canUseGlobalTracePropagation()) return undefined
-        try {
-          const mod = (await import('bullmq-otel')) as unknown as BullMQOtelModule
-          return new mod.BullMQOtel('open-mercato')
-        } catch {
-          packageLogger.warn('bullmq-otel not available; using built-in trace carrier', { queue: name })
-          return undefined
-        }
-      })()
-    }
-    return telemetryPromise
-  }
-
   async function getQueue(): Promise<BullQueueInterface<QueuedJob<T>>> {
     if (!bullQueue) {
       const { Queue: BullQueueClass } = await getBullMQ()
-      const telemetry = await getQueueTelemetry()
-      bullQueue = new BullQueueClass<QueuedJob<T>>(name, { connection, ...(telemetry ? { telemetry } : {}) })
+      bullQueue = new BullQueueClass<QueuedJob<T>>(name, { connection })
     }
     return bullQueue
   }
@@ -192,21 +148,17 @@ export function createAsyncQueue<T = unknown>(
 
   async function enqueue(data: T, options?: EnqueueOptions): Promise<string> {
     const queue = await getQueue()
-    // When bullmq-otel handles propagation, don't also attach our carrier.
-    const telemetry = await getQueueTelemetry()
-    const metadata = telemetry ? undefined : attachTraceMetadata(undefined)
     const jobData: QueuedJob<T> = {
       id: crypto.randomUUID(),
       payload: data,
       createdAt: new Date().toISOString(),
-      ...(metadata ? { metadata } : {}),
     }
 
     const job = await queue.add(jobData.id, jobData, {
       delay: options?.delayMs && options.delayMs > 0 ? options.delayMs : undefined,
       removeOnComplete: true,
       removeOnFail: 1000,
-      attempts,
+      attempts: 3,
       backoff: { type: 'exponential', delay: 1000 },
     })
 
@@ -215,33 +167,21 @@ export function createAsyncQueue<T = unknown>(
 
   async function process(handler: JobHandler<T>): Promise<ProcessResult> {
     const { Worker } = await getBullMQ()
-    const telemetry = await getQueueTelemetry()
 
     // Create worker that processes jobs
     bullWorker = new Worker<QueuedJob<T>>(
       name,
       async (job) => {
         const jobData = job.data
-        const ctx = {
+        await handler(jobData, {
           jobId: job.id ?? jobData.id,
           attemptNumber: job.attemptsMade + 1,
           queueName: name,
-        }
-        // With bullmq-otel active, BullMQ owns the process span and active
-        // context (the handler's pg/undici spans nest under it). Otherwise
-        // continue the trace from our own carrier.
-        if (telemetry) {
-          await handler(jobData, ctx)
-        } else {
-          await runJobInTrace(name, jobData.metadata, () => handler(jobData, ctx))
-        }
+        })
       },
       {
         connection,
         concurrency,
-        ...(telemetry ? { telemetry } : {}),
-        ...(lockDuration !== undefined ? { lockDuration } : {}),
-        ...(maxStalledCount !== undefined ? { maxStalledCount } : {}),
       }
     )
 
@@ -257,16 +197,6 @@ export function createAsyncQueue<T = unknown>(
       logger.error('Job failed', { jobId: jobWithId?.id, err: error })
     })
 
-    // A stalled job is redelivered under the same id while the previous worker
-    // may still be running it, so this is the signal that a handler is about to
-    // be executed twice. BullMQ's docs require surfacing it: without this line
-    // duplicate processing is invisible.
-    bullWorker.on('stalled', (jobId) => {
-      logger.warn('Job stalled and will be redelivered — the handler may run concurrently with a previous delivery', {
-        jobId: typeof jobId === 'string' ? jobId : null,
-      })
-    })
-
     bullWorker.on('error', (err) => {
       const error = err as Error
       logger.error('Worker error', { err: error })

package/src/strategies/local.ts

@@ -3,7 +3,6 @@ import path from 'node:path'
 import crypto from 'node:crypto'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 import type { Queue, QueuedJob, JobHandler, LocalQueueOptions, ProcessOptions, ProcessResult, EnqueueOptions, QueueJobScope } from '../types'
-import { attachTraceMetadata, runJobInTrace } from '../tracing'
 
 const packageLogger = createLogger('queue')
 
@@ -50,18 +49,9 @@ const fsp = fs.promises
  * - Jobs are processed sequentially (concurrency option is for logging/compatibility only)
  * - Not suitable for production or multi-process environments
  *
- * Failed jobs are retried up to `DEFAULT_MAX_ATTEMPTS` times with exponential backoff.
- * **This strategy keeps no failed-job store**: once attempts are exhausted the job is
- * removed from `queue.json` and only counted in `state.failedCount`, so the payload is
- * lost and the failure survives solely as an error log line. The `async` strategy keeps
- * only a bounded inspection window: `removeOnFail: 1000` retains the most recent 1000
- * failures and removes older ones as later failures arrive. Workflows that require
- * no-loss persistence must write their own durable record before enqueueing, regardless
- * of strategy.
- *
- * `DEFAULT_MAX_ATTEMPTS` is a module constant, not a per-job option — callers cannot
- * request a different attempt count. (`async` likewise hard-codes `attempts: 3`.)
- * See the retry handling in `process()` below.
+ * Failed jobs are retried up to `DEFAULT_MAX_ATTEMPTS` times with exponential
+ * backoff and moved to a dead-letter store once attempts are exhausted (see the
+ * retry handling in `process()` below).
  *
  * All file I/O is asynchronous (`fs.promises.*`) so queue operations do not
  * block the Node.js event loop. A per-queue promise chain serializes
@@ -206,13 +196,11 @@ export function createLocalQueue<T = unknown>(
     const availableAt = options?.delayMs && options.delayMs > 0
       ? new Date(Date.now() + options.delayMs).toISOString()
       : undefined
-    const metadata = attachTraceMetadata(undefined)
     const job: StoredJob<T> = {
       id: generateId(),
       payload: data,
       createdAt: new Date().toISOString(),
       ...(availableAt ? { availableAt } : {}),
-      ...(metadata ? { metadata } : {}),
     }
     await withFileLock(async () => {
       const jobs = await readQueue()
@@ -258,14 +246,12 @@ export function createLocalQueue<T = unknown>(
       for (const job of jobsToProcess) {
         const attemptNumber = (job.attemptCount ?? 0) + 1
         try {
-          await runJobInTrace(name, job.metadata, () =>
-            Promise.resolve(
-              handler(job, {
-                jobId: job.id,
-                attemptNumber,
-                queueName: name,
-              })
-            )
+          await Promise.resolve(
+            handler(job, {
+              jobId: job.id,
+              attemptNumber,
+              queueName: name,
+            })
           )
           processed++
           lastJobId = job.id
@@ -276,7 +262,7 @@ export function createLocalQueue<T = unknown>(
           failed++
           lastJobId = job.id
           if (attemptNumber >= DEFAULT_MAX_ATTEMPTS) {
-            logger.error('Job exhausted all attempts; dropping it (no dead-letter store)', { jobId: job.id, maxAttempts: DEFAULT_MAX_ATTEMPTS })
+            logger.error('Job exhausted all attempts, moving to dead letter', { jobId: job.id, maxAttempts: DEFAULT_MAX_ATTEMPTS })
             deadJobIds.add(job.id)
           } else {
             const backoffMs = RETRY_BACKOFF_BASE_MS * Math.pow(2, attemptNumber - 1)

package/src/types.ts

@@ -81,8 +81,6 @@ export type RedisConnectionOptions = {
   db?: number
   /** TLS configuration for rediss / encrypted Redis */
   tls?: Record<string, unknown>
-  /** IP family used by Redis DNS resolution */
-  family?: number
 }
 
 /**
@@ -93,12 +91,6 @@ export type AsyncQueueOptions = {
   connection?: RedisConnectionOptions
   /** Number of concurrent job processors. Defaults to 1 */
   concurrency?: number
-  /** Number of attempts for newly enqueued jobs. Defaults to 3. */
-  attempts?: number
-  /** How long a job lock is held before the job counts as stalled, in ms. Defaults to 30000. */
-  lockDuration?: number
-  /** Number of stalled-job recoveries BullMQ permits before failing a job. Defaults to 1. */
-  maxStalledCount?: number
 }
 
 /**
@@ -258,10 +250,6 @@ export type WorkerMeta = {
   id?: string
   /** Worker concurrency (default: 1) */
   concurrency?: number
-  /** How long a job lock is held before the job counts as stalled, in ms. */
-  lockDuration?: number
-  /** Number of stalled-job recoveries BullMQ permits before failing a job. */
-  maxStalledCount?: number
 }
 
 /**
@@ -277,8 +265,4 @@ export type WorkerDescriptor<T = unknown> = {
   handler: JobHandler<T>
   /** Concurrency level */
   concurrency: number
-  /** How long a job lock is held before the job counts as stalled, in ms. */
-  lockDuration?: number
-  /** Number of stalled-job recoveries BullMQ permits before failing a job. */
-  maxStalledCount?: number
 }