@boringnode/queue 0.1.0 → 0.3.0

package/README.md

@@ -20,558 +20,430 @@ npm install @boringnode/queue
 
 ## Features
 
-- **Multiple Queue Adapters**: Support for Redis, Knex (PostgreSQL, MySQL, SQLite), and Sync
-- **Type-Safe Jobs**: Define jobs as TypeScript classes with typed payloads
-- **Delayed Jobs**: Schedule jobs to run after a specific delay
-- **Multiple Queues**: Organize jobs into different queues for better organization
-- **Worker Management**: Process jobs with configurable concurrency
-- **Auto-Discovery**: Automatically discover and register jobs from specified locations
+- **Multiple Queue Adapters**: Redis, Knex (PostgreSQL, MySQL, SQLite), and Sync
+- **Type-Safe Jobs**: TypeScript classes with typed payloads
+- **Delayed Jobs**: Schedule jobs to run after a delay
 - **Priority Queues**: Process high-priority jobs first
-- **Retry with Backoff**: Automatic retries with exponential, linear, or fixed backoff strategies
-- **Job Timeout**: Automatically fail or retry jobs that exceed a time limit
-- **Scheduled Jobs**: Cron-based or interval-based job scheduling with pause/resume support
+- **Bulk Dispatch**: Efficiently dispatch thousands of jobs at once
+- **Job Grouping**: Organize related jobs for monitoring
+- **Retry with Backoff**: Exponential, linear, or fixed backoff strategies
+- **Job Timeout**: Fail or retry jobs that exceed a time limit
+- **Job History**: Retain completed/failed jobs for debugging
+- **Scheduled Jobs**: Cron or interval-based recurring jobs
+- **Auto-Discovery**: Automatically register jobs from specified locations
 
 ## Quick Start
 
 ### 1. Define a Job
 
-Create a job by extending the `Job` class:
-
 ```typescript
 import { Job } from '@boringnode/queue'
-import type { JobContext, JobOptions } from '@boringnode/queue/types'
+import type { JobOptions } from '@boringnode/queue/types'
 
 interface SendEmailPayload {
   to: string
 }
 
 export default class SendEmailJob extends Job<SendEmailPayload> {
-  static readonly jobName = 'SendEmailJob'
-
   static options: JobOptions = {
     queue: 'email',
   }
 
   async execute(): Promise<void> {
-    console.log(`[Attempt ${this.context.attempt}] Sending email to: ${this.payload.to}`)
+    console.log(`Sending email to: ${this.payload.to}`)
   }
 }
 ```
 
+> [!NOTE]
+> The job name defaults to the class name (`SendEmailJob`). You can override it with `name: 'CustomName'` in options.
+
+> [!WARNING]
+> If you minify your code in production, class names may be mangled. Always specify `name` explicitly in your job options.
+
 ### 2. Configure the Queue Manager
 
 ```typescript
 import { QueueManager } from '@boringnode/queue'
 import { redis } from '@boringnode/queue/drivers/redis_adapter'
-import { sync } from '@boringnode/queue/drivers/sync_adapter'
-import { Redis } from 'ioredis'
 
-const redisConnection = new Redis({
-  host: 'localhost',
-  port: 6379,
-  keyPrefix: 'boringnode::queue::',
-  db: 0,
-})
-
-const config = {
+await QueueManager.init({
   default: 'redis',
-
   adapters: {
-    sync: sync(),
-    redis: redis(redisConnection),
+    redis: redis({ host: 'localhost', port: 6379 }),
   },
-
-  worker: {
-    concurrency: 5,
-    idleDelay: '2s',
-  },
-
   locations: ['./app/jobs/**/*.ts'],
-}
-
-await QueueManager.init(config)
+})
 ```
 
 ### 3. Dispatch Jobs
 
 ```typescript
-import SendEmailJob from './jobs/send_email_job.ts'
-
-// Dispatch immediately
+// Simple dispatch
 await SendEmailJob.dispatch({ to: 'user@example.com' })
 
-// Dispatch with delay
-await SendEmailJob.dispatch({ to: 'user@example.com' }).in('5m')
+// With options
+await SendEmailJob.dispatch({ to: 'user@example.com' })
+  .toQueue('high-priority')
+  .priority(1)
+  .in('5m')
 ```
 
 ### 4. Start a Worker
 
-Create a worker to process jobs:
-
 ```typescript
 import { Worker } from '@boringnode/queue'
 
 const worker = new Worker(config)
-await worker.start(['default', 'email', 'reports'])
+await worker.start(['default', 'email'])
 ```
 
-## Configuration
+## Bulk Dispatch
 
-### Queue Manager Options
+Efficiently dispatch thousands of jobs in a single batch operation:
 
 ```typescript
-interface QueueManagerConfig {
-  // Default adapter to use
-  default: string
+const { jobIds } = await SendEmailJob.dispatchMany([
+  { to: 'user1@example.com' },
+  { to: 'user2@example.com' },
+  { to: 'user3@example.com' },
+])
+  .group('newsletter-jan-2025')
+  .toQueue('emails')
+  .priority(3)
+
+console.log(`Dispatched ${jobIds.length} jobs`)
+```
 
-  // Available queue adapters
-  adapters: {
-    [key: string]: QueueAdapter
-  }
+This uses Redis MULTI/EXEC or SQL batch insert for optimal performance.
 
-  // Worker configuration
-  worker: {
-    concurrency: number
-    idleDelay: Duration
-  }
+## Job Grouping
 
-  // Job discovery locations
-  locations: string[]
-}
+Organize related jobs together for monitoring and filtering:
+
+```typescript
+// Group newsletter jobs
+await SendEmailJob.dispatch({ to: 'user@example.com' })
+  .group('newsletter-jan-2025')
+
+// Group with bulk dispatch
+await SendEmailJob.dispatchMany(recipients)
+  .group('newsletter-jan-2025')
 ```
 
-### Job Options
+The `groupId` is stored with job data and accessible via `job.data.groupId`.
+
+## Job History & Retention
 
-Configure individual jobs with the `options` property:
+Keep completed and failed jobs for debugging:
 
 ```typescript
-static options: JobOptions = {
-  queue: 'email',       // Queue name (default: 'default')
-  adapter: 'redis',     // Override default adapter
-  priority: 1,          // Lower number = higher priority (default: 5)
-  maxRetries: 3,        // Maximum retry attempts
-  timeout: '30s',       // Job timeout duration
-  failOnTimeout: true,  // Fail permanently on timeout (default: false, will retry)
+export default class ImportantJob extends Job<Payload> {
+  static options: JobOptions = {
+    // Keep last 1000 completed jobs
+    removeOnComplete: { count: 1000 },
+
+    // Keep failed jobs for 7 days
+    removeOnFail: { age: '7d' },
+  }
 }
 ```
 
-## Adapters
+<details>
+<summary><strong>Retention options</strong></summary>
 
-### Redis Adapter
+| Value                       | Behavior           |
+|-----------------------------|--------------------|
+| `true` (default)            | Remove immediately |
+| `false`                     | Keep forever       |
+| `{ count: n }`              | Keep last n jobs   |
+| `{ age: '7d' }`             | Keep for duration  |
+| `{ count: 100, age: '1d' }` | Both limits apply  |
 
-For production use with distributed systems:
+Query job history:
 
 ```typescript
-import { redis } from '@boringnode/queue/drivers/redis_adapter'
-import { Redis } from 'ioredis'
-
-const redisConnection = new Redis({
-  host: 'localhost',
-  port: 6379,
-  keyPrefix: 'boringnode::queue::',
-})
-
-const adapter = redis(redisConnection)
+const job = await adapter.getJob('job-id', 'queue-name')
+console.log(job.status)      // 'completed' | 'failed'
+console.log(job.finishedAt)  // timestamp
+console.log(job.error)       // error message (if failed)
 ```
 
-### Sync Adapter
+</details>
+
+## Adapters
 
-For testing and development:
+### Redis (recommended for production)
 
 ```typescript
-import { sync } from '@boringnode/queue/drivers/sync_adapter'
+import { redis } from '@boringnode/queue/drivers/redis_adapter'
 
-const adapter = sync()
-```
+// With options
+const adapter = redis({ host: 'localhost', port: 6379 })
 
-### Knex Adapter
+// With existing ioredis instance
+import { Redis } from 'ioredis'
+const connection = new Redis({ host: 'localhost' })
+const adapter = redis(connection)
+```
 
-For SQL databases (PostgreSQL, MySQL, SQLite) using Knex:
+### Knex (PostgreSQL, MySQL, SQLite)
 
 ```typescript
 import { knex } from '@boringnode/queue/drivers/knex_adapter'
 
-// With configuration (adapter manages connection lifecycle)
 const adapter = knex({
   client: 'pg',
-  connection: {
-    host: 'localhost',
-    port: 5432,
-    user: 'postgres',
-    password: 'postgres',
-    database: 'myapp',
-  },
+  connection: { host: 'localhost', database: 'myapp' },
 })
+```
 
-// Or with an existing Knex instance (you manage connection lifecycle)
-import Knex from 'knex'
+<details>
+<summary><strong>More Knex examples</strong></summary>
 
+```typescript
+// With existing Knex instance
+import Knex from 'knex'
 const connection = Knex({ client: 'pg', connection: '...' })
 const adapter = knex(connection)
-```
 
-The adapter automatically creates the `queue_jobs` table on first use. You can customize the table name:
-
-```typescript
+// Custom table name
 const adapter = knex(config, 'custom_jobs_table')
 ```
 
-## Worker Configuration
+The adapter automatically creates tables on first use.
 
-Workers process jobs from one or more queues:
+</details>
+
+### Sync (for testing)
 
 ```typescript
-const worker = new Worker(config)
+import { sync } from '@boringnode/queue/drivers/sync_adapter'
 
-// Process specific queues
-await worker.start(['default', 'email', 'reports'])
+const adapter = sync() // Jobs execute immediately
+```
+
+## Job Options
 
-// Worker will:
-// - Process jobs with configured concurrency
-// - Poll queues at the configured interval
-// - Execute jobs in the order they were queued
+```typescript
+export default class MyJob extends Job<Payload> {
+  static options: JobOptions = {
+    queue: 'email',       // Queue name (default: 'default')
+    priority: 1,          // Lower = higher priority (default: 5)
+    maxRetries: 3,        // Retry attempts before failing
+    timeout: '30s',       // Max execution time
+    failOnTimeout: true,  // Fail permanently on timeout (default: retry)
+    removeOnComplete: { count: 100 },  // Keep last 100 completed
+    removeOnFail: { age: '7d' },       // Keep failed for 7 days
+  }
+}
 ```
 
 ## Delayed Jobs
 
-Schedule jobs to run in the future:
-
 ```typescript
-// Various time formats
-await SendEmailJob.dispatch(payload).in('30s') // 30 seconds
-await SendEmailJob.dispatch(payload).in('5m')  // 5 minutes
-await SendEmailJob.dispatch(payload).in('2h')  // 2 hours
-await SendEmailJob.dispatch(payload).in('1d')  // 1 day
+await SendEmailJob.dispatch(payload).in('30s')  // 30 seconds
+await SendEmailJob.dispatch(payload).in('5m')   // 5 minutes
+await SendEmailJob.dispatch(payload).in('2h')   // 2 hours
+await SendEmailJob.dispatch(payload).in('1d')   // 1 day
 ```
 
-## Priority
-
-Jobs with lower priority numbers are processed first:
+## Retry & Backoff
 
 ```typescript
-export default class UrgentJob extends Job<Payload> {
-  static readonly jobName = 'UrgentJob'
+import { exponentialBackoff } from '@boringnode/queue'
 
+export default class ReliableJob extends Job<Payload> {
   static options: JobOptions = {
-    priority: 1, // Processed before default priority (5)
-  }
-
-  async execute(): Promise<void> {
-    // ...
+    maxRetries: 5,
+    retry: {
+      backoff: () => exponentialBackoff({
+        baseDelay: '1s',
+        maxDelay: '1m',
+        multiplier: 2,
+        jitter: true,
+      }),
+    },
   }
 }
 ```
 
-## Retry and Backoff
-
-Configure automatic retries with backoff strategies:
+<details>
+<summary><strong>Available strategies</strong></summary>
 
 ```typescript
 import { exponentialBackoff, linearBackoff, fixedBackoff } from '@boringnode/queue'
 
-export default class ReliableJob extends Job<Payload> {
-  static readonly jobName = 'ReliableJob'
+// Exponential: 1s, 2s, 4s, 8s...
+exponentialBackoff({ baseDelay: '1s', maxDelay: '1m', multiplier: 2 })
 
-  static options: JobOptions = {
-    maxRetries: 5,
-    retry: {
-      backoff: () =>
-        exponentialBackoff({
-          baseDelay: '1s',
-          maxDelay: '1m',
-          multiplier: 2,
-          jitter: true,
-        }),
-    },
-  }
+// Linear: 1s, 2s, 3s, 4s...
+linearBackoff({ baseDelay: '1s', maxDelay: '30s', multiplier: 1 })
 
-  async execute(): Promise<void> {
-    // ...
-  }
-}
+// Fixed: 5s, 5s, 5s...
+fixedBackoff({ baseDelay: '5s', jitter: true })
 ```
 
-Available backoff strategies:
-
-- `exponentialBackoff({ baseDelay, maxDelay, multiplier, jitter })` - Exponential increase
-- `linearBackoff({ baseDelay, maxDelay, multiplier })` - Linear increase
-- `fixedBackoff({ baseDelay, jitter })` - Fixed delay between retries
+</details>
 
 ## Job Timeout
 
-Set a maximum execution time for jobs:
-
 ```typescript
-export default class LimitedJob extends Job<Payload> {
-  static readonly jobName = 'LimitedJob'
-
+export default class LongRunningJob extends Job<Payload> {
   static options: JobOptions = {
-    timeout: '30s', // Maximum execution time
-    failOnTimeout: false, // Retry on timeout (default)
+    timeout: '30s',
+    failOnTimeout: false, // Will retry (default)
   }
 
   async execute(): Promise<void> {
-    // Long running operation...
+    for (const item of this.payload.items) {
+      // Check abort signal for graceful timeout handling
+      if (this.signal?.aborted) {
+        throw new Error('Job timed out')
+      }
+      await this.processItem(item)
+    }
   }
 }
 ```
 
-You can also set a global timeout in the worker configuration:
+## Job Context
+
+Access execution metadata via `this.context`:
 
 ```typescript
-const config = {
-  worker: {
-    timeout: '1m', // Default timeout for all jobs
-  },
+async execute(): Promise<void> {
+  console.log(this.context.jobId)       // Unique job ID
+  console.log(this.context.attempt)     // 1, 2, 3...
+  console.log(this.context.queue)       // Queue name
+  console.log(this.context.priority)    // Priority value
+  console.log(this.context.acquiredAt)  // When acquired
+  console.log(this.context.stalledCount) // Stall recoveries
 }
 ```
 
-## Job Context
+## Scheduled Jobs
 
-Every job has access to execution context via `this.context`. This provides metadata about the current job execution:
+Run jobs on a recurring basis:
 
 ```typescript
-import { Job } from '@boringnode/queue'
-import type { JobContext } from '@boringnode/queue'
+// Every 10 seconds
+await MetricsJob.schedule({ endpoint: '/health' })
+  .every('10s')
 
-export default class MyJob extends Job<Payload> {
-  constructor(payload: Payload, context: JobContext) {
-    super(payload, context)
-  }
+// Cron schedule
+await CleanupJob.schedule({ days: 30 })
+  .id('daily-cleanup')
+  .cron('0 0 * * *')  // Midnight daily
+  .timezone('Europe/Paris')
+```
 
-  async execute(): Promise<void> {
-    console.log(`Job ID: ${this.context.jobId}`)
-    console.log(`Attempt: ${this.context.attempt}`) // 1, 2, 3...
-    console.log(`Queue: ${this.context.queue}`)
-    console.log(`Priority: ${this.context.priority}`)
-    console.log(`Acquired at: ${this.context.acquiredAt}`)
-
-    if (this.context.attempt > 1) {
-      console.log('This is a retry!')
-    }
-  }
-}
+<details>
+<summary><strong>Schedule management</strong></summary>
+
+```typescript
+import { Schedule } from '@boringnode/queue'
+
+// Find and manage
+const schedule = await Schedule.find('daily-cleanup')
+await schedule.pause()
+await schedule.resume()
+await schedule.trigger()  // Run now
+await schedule.delete()
+
+// List schedules
+const all = await Schedule.list()
+const active = await Schedule.list({ status: 'active' })
 ```
 
-### Context Properties
+**Schedule options:**
 
-| Property       | Type   | Description                                     |
-|----------------|--------|-------------------------------------------------|
-| `jobId`        | string | Unique identifier for this job                  |
-| `name`         | string | Job class name                                  |
-| `attempt`      | number | Current attempt number (1-based)                |
-| `queue`        | string | Queue name this job is being processed from     |
-| `priority`     | number | Job priority (lower = higher priority)          |
-| `acquiredAt`   | Date   | When this job was acquired by the worker        |
-| `stalledCount` | number | Times this job was recovered from stalled state |
+| Method              | Description                       |
+|---------------------|-----------------------------------|
+| `.id(string)`       | Unique identifier                 |
+| `.every(duration)`  | Fixed interval ('5s', '1m', '1h') |
+| `.cron(expression)` | Cron schedule                     |
+| `.timezone(tz)`     | Timezone (default: 'UTC')         |
+| `.from(date)`       | Start boundary                    |
+| `.to(date)`         | End boundary                      |
+| `.limit(n)`         | Maximum runs                      |
+
+</details>
 
 ## Dependency Injection
 
-Use the `jobFactory` option to integrate with IoC containers for dependency injection. This allows your jobs to receive injected services in their constructor.
+Integrate with IoC containers:
 
 ```typescript
-import { QueueManager } from '@boringnode/queue'
-
 await QueueManager.init({
-  default: 'redis',
-  adapters: { redis: redis(connection) },
-  jobFactory: async (JobClass, payload, context) => {
-    // Use your IoC container to instantiate jobs
-    return app.container.make(JobClass, [payload, context])
+  // ...
+  jobFactory: async (JobClass) => {
+    return app.container.make(JobClass)
   },
 })
 ```
 
-Example with injected dependencies:
+<details>
+<summary><strong>Example with injected services</strong></summary>
 
 ```typescript
-import { Job } from '@boringnode/queue'
-import type { JobContext } from '@boringnode/queue'
-
-interface SendEmailPayload {
-  to: string
-  subject: string
-}
-
 export default class SendEmailJob extends Job<SendEmailPayload> {
-  static readonly jobName = 'SendEmailJob'
-
   constructor(
-    payload: SendEmailPayload,
-    context: JobContext,
-    private mailer: MailerService, // Injected by IoC container
-    private logger: Logger // Injected by IoC container
+    private mailer: MailerService,
+    private logger: Logger
   ) {
-    super(payload, context)
+    super()
   }
 
   async execute(): Promise<void> {
-    this.logger.info(`[Attempt ${this.context.attempt}] Sending email to ${this.payload.to}`)
+    this.logger.info(`Sending email to ${this.payload.to}`)
     await this.mailer.send(this.payload)
   }
 }
 ```
 
-Without a `jobFactory`, jobs are instantiated with `new JobClass(payload, context)`.
-
-## Scheduled Jobs
-
-Schedule jobs to run on a recurring basis using cron expressions or fixed intervals. Schedules are persisted and survive worker restarts.
-
-### Creating a Schedule
-
-```typescript
-import { Schedule } from '@boringnode/queue'
-
-// Run every 10 seconds (uses job name as schedule ID by default)
-const { scheduleId } = await MetricsJob.schedule({ endpoint: '/api/health' }).every('10s').run()
-
-// Run on a cron schedule with custom ID
-await CleanupJob.schedule({ days: 30 })
-  .id('daily-cleanup') // Custom ID (optional, defaults to job name)
-  .cron('0 * * * *') // Every hour at minute 0
-  .timezone('Europe/Paris') // Optional timezone (default: UTC)
-  .run()
-
-// Schedule with constraints
-await ReportJob.schedule({ type: 'weekly' })
-  .id('weekly-report')
-  .cron('0 9 * * MON') // Every Monday at 9am
-  .from(new Date('2024-01-01')) // Start date
-  .to(new Date('2024-12-31')) // End date
-  .limit(52) // Maximum 52 runs
-  .run()
-```
+</details>
 
-### Managing Schedules
-
-```typescript
-import { Schedule } from '@boringnode/queue'
-
-// Find a schedule by ID
-const schedule = await Schedule.find('health-check')
-
-if (schedule) {
-  console.log(`Status: ${schedule.status}`) // 'active' or 'paused'
-  console.log(`Run count: ${schedule.runCount}`)
-  console.log(`Next run: ${schedule.nextRunAt}`)
-  console.log(`Last run: ${schedule.lastRunAt}`)
-
-  // Pause the schedule
-  await schedule.pause()
-
-  // Resume the schedule
-  await schedule.resume()
-
-  // Trigger an immediate run (outside of the normal schedule)
-  await schedule.trigger()
-
-  // Delete the schedule
-  await schedule.delete()
-}
-```
-
-### Listing Schedules
-
-```typescript
-import { Schedule } from '@boringnode/queue'
-
-// List all schedules
-const all = await Schedule.list()
-
-// Filter by status
-const active = await Schedule.list({ status: 'active' })
-const paused = await Schedule.list({ status: 'paused' })
-```
-
-### Schedule Options
-
-| Method               | Description                                     |
-|----------------------|-------------------------------------------------|
-| `.id(string)`        | Unique identifier (defaults to job name)        |
-| `.every(duration)`   | Run at fixed intervals ('5s', '1m', '1h', '1d') |
-| `.cron(expression)`  | Run on a cron schedule                          |
-| `.timezone(tz)`      | Timezone for cron expressions (default: 'UTC')  |
-| `.from(date)`        | Don't run before this date                      |
-| `.to(date)`          | Don't run after this date                       |
-| `.between(from, to)` | Shorthand for `.from().to()`                    |
-| `.limit(n)`          | Maximum number of runs                          |
-
-### How Scheduling Works
-
-- Schedules are **persisted** in the database (via the adapter)
-- The **Worker** polls for due schedules and dispatches jobs automatically
-- Each schedule run creates a **new job** with a unique ID
-- Multiple workers can run concurrently - only one will claim each due schedule
-- Failed jobs do **not** affect the schedule (the next run will still occur)
-
-## Job Discovery
-
-The queue manager automatically discovers and registers jobs from the specified locations:
+## Worker Configuration
 
 ```typescript
 const config = {
-  locations: ['./app/jobs/**/*.ts', './modules/**/jobs/**/*.ts'],
+  worker: {
+    concurrency: 5,        // Parallel jobs
+    idleDelay: '2s',       // Poll interval when idle
+    timeout: '1m',         // Default job timeout
+    stalledThreshold: '30s', // When to consider job stalled
+    stalledInterval: '30s',  // How often to check
+    maxStalledCount: 1,      // Max recoveries before failing
+    gracefulShutdown: true,  // Wait for jobs on SIGTERM
+  },
 }
 ```
 
-Jobs must:
-
-- Extend the `Job` class
-- Have a static `jobName` property
-- Implement the `execute` method
-- Be exported as default
-
 ## Logging
 
-You can pass a logger to the queue manager for debugging or monitoring. The logger must be compatible with the [pino](https://github.com/pinojs/pino) interface.
-
 ```typescript
 import { pino } from 'pino'
 
-const config = {
-  default: 'redis',
-  adapters: {
-    /* ... */
-  },
+await QueueManager.init({
+  // ...
   logger: pino(),
-}
-
-await QueueManager.init(config)
+})
 ```
 
-By default, a simple console logger is used that only outputs warnings and errors.
-
 ## Benchmarks
 
-Performance comparison with BullMQ using realistic jobs (5ms simulated work per job):
+Performance comparison with BullMQ (5ms simulated work per job):
 
 | Jobs | Concurrency | @boringnode/queue | BullMQ | Diff        |
 |------|-------------|-------------------|--------|-------------|
-| 100  | 1           | 562ms             | 596ms  | 5.7% faster |
-| 100  | 5           | 116ms             | 117ms  | ~same       |
-| 100  | 10          | 62ms              | 62ms   | ~same       |
-| 500  | 1           | 2728ms            | 2798ms | 2.5% faster |
-| 500  | 5           | 565ms             | 565ms  | ~same       |
-| 500  | 10          | 287ms             | 288ms  | ~same       |
-| 1000 | 1           | 5450ms            | 5547ms | 1.7% faster |
 | 1000 | 5           | 1096ms            | 1116ms | 1.8% faster |
 | 1000 | 10          | 565ms             | 579ms  | 2.4% faster |
-| 100K | 5           | 110.5s            | 112.3s | 1.5% faster |
 | 100K | 10          | 56.2s             | 57.5s  | 2.1% faster |
 | 100K | 20          | 29.1s             | 29.6s  | 1.7% faster |
 
-Run benchmarks yourself:
-
 ```bash
-# Realistic benchmark (5ms job duration)
 npm run benchmark -- --realistic
-
-# Pure dequeue overhead (no-op jobs)
-npm run benchmark
-
-# Custom job duration
-npm run benchmark -- --duration=10
 ```
 
 [gh-workflow-image]: https://img.shields.io/github/actions/workflow/status/boringnode/queue/checks.yml?branch=main&style=for-the-badge