bunqueue-client 0.1.1 → 0.1.3

package/src/bunqueue/aging.ts

@@ -0,0 +1,62 @@
+/**
+ * Bunqueue Simple Mode — priority aging.
+ * Port of src/client/bunqueue/aging.ts: automatically boosts the priority of
+ * old waiting jobs. Same semantics; the job scan goes over TCP (GetJobs on
+ * the waiting and prioritized states) instead of the embedded manager.
+ */
+
+import type { Queue } from '../queue.js';
+import type { PriorityAgingConfig } from './types.js';
+
+export class PriorityAger<T = unknown> {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private readonly config: PriorityAgingConfig;
+  private readonly queue: Queue<T>;
+
+  constructor(config: PriorityAgingConfig, queue: Queue<T>) {
+    this.config = config;
+    this.queue = queue;
+  }
+
+  start(): void {
+    const interval = this.config.interval ?? 60000;
+    this.timer = setInterval(() => {
+      void this.tick();
+    }, interval);
+    this.timer.unref?.();
+  }
+
+  private async tick(): Promise<void> {
+    const minAge = this.config.minAge ?? 60000;
+    const boost = this.config.boost ?? 1;
+    const maxPriority = this.config.maxPriority ?? 100;
+    const maxScan = this.config.maxScan ?? 100;
+
+    // Both waiting and prioritized jobs (priority > 0 means "prioritized")
+    const [waiting, prioritized] = await Promise.all([
+      this.queue.getJobs({ state: 'waiting', start: 0, end: maxScan }),
+      this.queue.getJobs({ state: 'prioritized', start: 0, end: maxScan }),
+    ]);
+    const jobs = [...waiting, ...prioritized];
+    const now = Date.now();
+
+    for (const job of jobs) {
+      const age = now - job.timestamp;
+      if (age >= minAge && job.priority < maxPriority) {
+        const newPriority = Math.min(job.priority + boost, maxPriority);
+        try {
+          await this.queue.changeJobPriority(job.id, { priority: newPriority });
+        } catch {
+          // Best-effort — the job may have been processed meanwhile
+        }
+      }
+    }
+  }
+
+  destroy(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+}

package/src/bunqueue/batch.ts

@@ -0,0 +1,79 @@
+/**
+ * Bunqueue Simple Mode — batch processing.
+ * 1:1 port of src/client/bunqueue/batch.ts: accumulates jobs and processes
+ * them in groups; flushes on size, on timeout, and on destroy (close).
+ */
+
+import type { Job } from '../job.js';
+import type { Processor } from '../worker-types.js';
+import type { BatchConfig } from './types.js';
+
+interface BufferEntry<T, R> {
+  job: Job<T>;
+  resolve: (value: R) => void;
+  reject: (err: Error) => void;
+}
+
+export class BatchAccumulator<T = unknown, R = unknown> {
+  private readonly buffer: BufferEntry<T, R>[] = [];
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private readonly config: BatchConfig<T, R>;
+
+  constructor(config: BatchConfig<T, R>) {
+    this.config = config;
+  }
+
+  /** Build a Processor that buffers jobs into batches. */
+  buildProcessor(): Processor<T, R> {
+    return (job: Job<T>): Promise<R> => {
+      return new Promise<R>((resolve, reject) => {
+        this.buffer.push({ job, resolve, reject });
+
+        if (this.buffer.length >= this.config.size) {
+          this.flush();
+        } else if (!this.timer) {
+          const timeout = this.config.timeout ?? 5000;
+          this.timer = setTimeout(() => {
+            this.flush();
+          }, timeout);
+        }
+      });
+    };
+  }
+
+  flush(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+
+    const batch = this.buffer.splice(0);
+    if (batch.length === 0) return;
+
+    const jobs = batch.map((b) => b.job);
+    this.config.processor(jobs).then(
+      (results) => {
+        for (let i = 0; i < batch.length; i++) {
+          batch[i].resolve(results[i] ?? (undefined as unknown as R));
+        }
+      },
+      (err: unknown) => {
+        const error = err instanceof Error ? err : new Error(String(err));
+        for (const b of batch) {
+          b.reject(error);
+        }
+      }
+    );
+  }
+
+  destroy(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    // Flush remaining
+    if (this.buffer.length > 0) {
+      this.flush();
+    }
+  }
+}

package/src/bunqueue/bunqueue-api.ts

@@ -0,0 +1,212 @@
+/**
+ * Bunqueue Simple Mode — delegation API surface (cron, cancellation, circuit
+ * breaker, TTL, DLQ, rate limit, events, control). Merged onto the Bunqueue
+ * prototype by bunqueue.ts; split out to keep files small.
+ */
+
+import type { Job } from '../job.js';
+import type { JobOptions } from '../types.js';
+import type { Bunqueue } from './bunqueue.js';
+import type { DlqFilter, DlqStats } from './dlq-rate-limit.js';
+import type { CircuitState, TriggerRule } from './types.js';
+
+type Raw = Record<string, unknown>;
+// biome-ignore lint/suspicious/noExplicitAny: mixin context needs the erased generic instance
+type Ctx = Bunqueue<any, any>;
+
+export const bunqueueApi = {
+  // --------------------------------------------------------------------- cron
+
+  async cron(
+    this: Ctx,
+    id: string,
+    pattern: string,
+    data?: unknown,
+    opts?: { timezone?: string; jobOpts?: JobOptions }
+  ): Promise<Raw | null> {
+    await this.queue.upsertJobScheduler(
+      id,
+      { pattern, tz: opts?.timezone },
+      { name: id, data, opts: opts?.jobOpts }
+    );
+    return this.queue.getJobScheduler(id);
+  },
+
+  async every(
+    this: Ctx,
+    id: string,
+    intervalMs: number,
+    data?: unknown,
+    opts?: { jobOpts?: JobOptions }
+  ): Promise<Raw | null> {
+    await this.queue.upsertJobScheduler(
+      id,
+      { every: intervalMs },
+      { name: id, data, opts: opts?.jobOpts }
+    );
+    return this.queue.getJobScheduler(id);
+  },
+
+  removeCron(this: Ctx, id: string): Promise<void> {
+    return this.queue.removeJobScheduler(id);
+  },
+  listCrons(this: Ctx): Promise<Raw[]> {
+    return this.queue.getJobSchedulers();
+  },
+
+  // ------------------------------------------------------------- cancellation
+
+  cancel(this: Ctx, jobId: string, gracePeriodMs = 0): void {
+    this.cancellation.cancel(jobId, gracePeriodMs);
+  },
+  isCancelled(this: Ctx, jobId: string): boolean {
+    return this.cancellation.isCancelled(jobId);
+  },
+  getSignal(this: Ctx, jobId: string): AbortSignal | null {
+    return this.cancellation.getSignal(jobId);
+  },
+
+  // ---------------------------------------------------------- circuit breaker
+
+  getCircuitState(this: Ctx): CircuitState {
+    return this.cb?.currentState ?? 'closed';
+  },
+  resetCircuit(this: Ctx): void {
+    this.cb?.reset();
+  },
+
+  // ----------------------------------------------------------------- triggers
+
+  trigger(this: Ctx, rule: TriggerRule): Ctx {
+    this.triggerMgr.add(rule);
+    return this;
+  },
+
+  // ---------------------------------------------------------------------- ttl
+
+  setDefaultTtl(this: Ctx, ttlMs: number): void {
+    this.ttlChecker?.setDefaultTtl(ttlMs);
+  },
+  setNameTtl(this: Ctx, name: string, ttlMs: number): void {
+    this.ttlChecker?.setNameTtl(name, ttlMs);
+  },
+
+  // ---------------------------------------------------------------------- dlq
+
+  setDlqConfig(this: Ctx, config: Raw): Promise<void> {
+    return this.dlqrl.setDlqConfig(config);
+  },
+  getDlqConfig(this: Ctx): Promise<Raw> {
+    return this.dlqrl.getDlqConfig();
+  },
+  getDlq(this: Ctx, filter?: DlqFilter): Promise<Raw[]> {
+    return this.dlqrl.getDlq(filter);
+  },
+  getDlqStats(this: Ctx): Promise<DlqStats> {
+    return this.dlqrl.getDlqStats();
+  },
+  retryDlq(this: Ctx, id?: string): Promise<number> {
+    return this.dlqrl.retryDlq(id);
+  },
+  purgeDlq(this: Ctx): Promise<number> {
+    return this.dlqrl.purgeDlq();
+  },
+
+  // ------------------------------------------------------------ rate limiting
+
+  setGlobalRateLimit(this: Ctx, max: number, duration?: number): Promise<void> {
+    return this.dlqrl.setGlobalRateLimit(max, duration);
+  },
+  removeGlobalRateLimit(this: Ctx): Promise<void> {
+    return this.dlqrl.removeGlobalRateLimit();
+  },
+
+  // ------------------------------------------------------------------- events
+
+  on(this: Ctx, event: string, listener: (...args: never[]) => void): Ctx {
+    this.worker.on(event, listener as (...args: unknown[]) => void);
+    return this;
+  },
+  once(this: Ctx, event: string, listener: (...args: never[]) => void): Ctx {
+    this.worker.once(event, listener as (...args: unknown[]) => void);
+    return this;
+  },
+  off(this: Ctx, event: string, listener: (...args: never[]) => void): Ctx {
+    this.worker.off(event, listener as (...args: unknown[]) => void);
+    return this;
+  },
+
+  // ------------------------------------------------------------------ control
+
+  pause(this: Ctx): void {
+    void this.queue.pause().catch(() => {});
+    this.worker.pause();
+  },
+  resume(this: Ctx): void {
+    void this.queue.resume().catch(() => {});
+    this.worker.resume();
+  },
+
+  async close(this: Ctx, force = false): Promise<void> {
+    this.ager?.destroy();
+    this.cb?.destroy();
+    this.batchAcc?.destroy();
+    this.cancellation.destroyAll();
+    await this.worker.close(force);
+    this.queue.close();
+  },
+
+  isRunning(this: Ctx): boolean {
+    return this.worker.isRunning();
+  },
+  isPaused(this: Ctx): boolean {
+    return this.worker.isPaused();
+  },
+  isClosed(this: Ctx): boolean {
+    return this.worker.isClosed();
+  },
+};
+
+/** Declaration-merged API installed on the Bunqueue prototype. */
+export interface BunqueueApi<T = unknown, R = unknown> {
+  cron(
+    id: string,
+    pattern: string,
+    data?: T,
+    opts?: { timezone?: string; jobOpts?: JobOptions }
+  ): Promise<Raw | null>;
+  every(
+    id: string,
+    intervalMs: number,
+    data?: T,
+    opts?: { jobOpts?: JobOptions }
+  ): Promise<Raw | null>;
+  removeCron(id: string): Promise<void>;
+  listCrons(): Promise<Raw[]>;
+  cancel(jobId: string, gracePeriodMs?: number): void;
+  isCancelled(jobId: string): boolean;
+  getSignal(jobId: string): AbortSignal | null;
+  getCircuitState(): CircuitState;
+  resetCircuit(): void;
+  trigger(rule: TriggerRule<T>): Bunqueue<T, R>;
+  setDefaultTtl(ttlMs: number): void;
+  setNameTtl(name: string, ttlMs: number): void;
+  setDlqConfig(config: Raw): Promise<void>;
+  getDlqConfig(): Promise<Raw>;
+  getDlq(filter?: DlqFilter): Promise<Raw[]>;
+  getDlqStats(): Promise<DlqStats>;
+  retryDlq(id?: string): Promise<number>;
+  purgeDlq(): Promise<number>;
+  setGlobalRateLimit(max: number, duration?: number): Promise<void>;
+  removeGlobalRateLimit(): Promise<void>;
+  on(event: string, listener: (...args: never[]) => void): Bunqueue<T, R>;
+  once(event: string, listener: (...args: never[]) => void): Bunqueue<T, R>;
+  off(event: string, listener: (...args: never[]) => void): Bunqueue<T, R>;
+  pause(): void;
+  resume(): void;
+  close(force?: boolean): Promise<void>;
+  isRunning(): boolean;
+  isPaused(): boolean;
+  isClosed(): boolean;
+  getJob(id: string): Promise<Job<T> | null>;
+}

package/src/bunqueue/bunqueue.ts

@@ -0,0 +1,210 @@
+/**
+ * Bunqueue — simplified all-in-one Queue + Worker (Simple Mode).
+ * 1:1 port of src/client/bunqueue.ts from the official client, TCP mode only
+ * (the embedded mode requires the in-process Bun runtime). The delegation
+ * API (cron, DLQ, events, control, …) lives in bunqueue-api.ts and is merged
+ * onto the prototype below.
+ */
+
+import type { Job } from '../job.js';
+import { Queue } from '../queue.js';
+import type { JobOptions } from '../types.js';
+import { Worker } from '../worker.js';
+import type { Processor } from '../worker-types.js';
+import { PriorityAger } from './aging.js';
+import { BatchAccumulator } from './batch.js';
+import { type BunqueueApi, bunqueueApi } from './bunqueue-api.js';
+import { CancellationManager } from './cancellation.js';
+import { WorkerCircuitBreaker } from './circuit-breaker.js';
+import { DedupDebounceMerger } from './dedup-debounce.js';
+import { DlqRateLimitManager } from './dlq-rate-limit.js';
+import { RateGate } from './rate-gate.js';
+import { executeWithRetry } from './retry.js';
+import { TriggerManager } from './triggers.js';
+import { TtlChecker } from './ttl.js';
+import type { BunqueueMiddleware, BunqueueOptions } from './types.js';
+
+type Raw = Record<string, unknown>;
+
+// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: prototype-mixin composition — Object.assign below installs exactly the methods BunqueueApi declares
+export class Bunqueue<T = unknown, R = unknown> {
+  readonly name: string;
+  readonly queue: Queue<T>;
+  readonly worker: Worker<T, R>;
+  /** @internal */ readonly cancellation = new CancellationManager();
+  /** @internal */ readonly cb: WorkerCircuitBreaker | null;
+  /** @internal */ readonly triggerMgr: TriggerManager<T, R>;
+  /** @internal */ readonly ager: PriorityAger<T> | null;
+  /** @internal */ readonly ttlChecker: TtlChecker | null;
+  /** @internal */ readonly batchAcc: BatchAccumulator<T, R> | null;
+  /** @internal */ readonly dlqrl: DlqRateLimitManager<T>;
+  private readonly middlewares: BunqueueMiddleware<T, R>[] = [];
+  private readonly baseProcessor: Processor<T, R>;
+  private readonly retryConfig: BunqueueOptions<T, R>['retry'] | null;
+  private readonly merger: DedupDebounceMerger;
+  private readonly rateGate: RateGate | null;
+  private readonly defaultJobOptions: JobOptions | undefined;
+
+  constructor(name: string, opts: BunqueueOptions<T, R>) {
+    if ((opts as Raw).embedded || (opts as Raw).dataPath) {
+      throw new Error(
+        'Bunqueue (bunqueue-client) is TCP-only: embedded mode requires the Bun runtime — use the official "bunqueue" package on Bun instead'
+      );
+    }
+    const modes = [opts.processor, opts.routes, opts.batch].filter(Boolean).length;
+    if (modes === 0) throw new Error('Bunqueue requires "processor", "routes", or "batch"');
+    if (modes > 1) throw new Error('Bunqueue: use only one of "processor", "routes", or "batch"');
+
+    this.name = (opts.prefixKey ?? '') + name;
+    this.retryConfig = opts.retry ?? null;
+    this.ttlChecker = opts.ttl ? new TtlChecker(opts.ttl) : null;
+    this.merger = new DedupDebounceMerger(opts.deduplication ?? null, opts.debounce ?? null);
+    const limiter = opts.rateLimit ?? opts.limiter;
+    this.rateGate = limiter ? new RateGate(limiter) : null;
+    this.defaultJobOptions = this.buildDefaultJobOptions(opts);
+
+    // Build base processor
+    if (opts.batch) {
+      this.batchAcc = new BatchAccumulator<T, R>(opts.batch);
+      this.baseProcessor = this.batchAcc.buildProcessor();
+    } else {
+      this.batchAcc = null;
+      this.baseProcessor = opts.routes
+        ? this.buildRouteProcessor(opts.routes)
+        : (opts.processor as Processor<T, R>);
+    }
+
+    const wrappedProcessor: Processor<T, R> = (job: Job<T>) => this.processJob(job);
+
+    const conn = opts.connection ?? {};
+    this.queue = new Queue<T>(this.name, conn);
+    this.worker = new Worker<T, R>(this.name, wrappedProcessor, {
+      ...conn,
+      concurrency: opts.concurrency,
+      autorun: opts.autorun,
+      heartbeatIntervalS:
+        opts.heartbeatInterval !== undefined ? opts.heartbeatInterval / 1000 : undefined,
+      batchSize: opts.batchSize,
+      pollTimeoutMs: opts.pollTimeout,
+    });
+
+    // DLQ & rate limit manager
+    this.dlqrl = new DlqRateLimitManager<T>(this.queue);
+    if (opts.dlq) void this.dlqrl.setDlqConfig(opts.dlq);
+
+    // Subsystems
+    this.cb = opts.circuitBreaker
+      ? new WorkerCircuitBreaker(opts.circuitBreaker, this.worker)
+      : null;
+    this.triggerMgr = new TriggerManager<T, R>(this.queue, this.worker);
+    this.ager = opts.priorityAging ? new PriorityAger<T>(opts.priorityAging, this.queue) : null;
+    this.ager?.start();
+  }
+
+  private buildRouteProcessor(routes: Record<string, Processor<T, R>>): Processor<T, R> {
+    const routeMap: Partial<Record<string, Processor<T, R>>> = routes;
+    return (job: Job<T>): Promise<R> | R => {
+      const handler = routeMap[job.name ?? ''];
+      if (!handler) throw new Error(`No route for job "${job.name}" in queue "${this.name}"`);
+      return handler(job);
+    };
+  }
+
+  private buildDefaultJobOptions(opts: BunqueueOptions<T, R>): JobOptions | undefined {
+    const base: JobOptions = { ...opts.defaultJobOptions };
+    if (opts.removeOnComplete !== undefined) base.removeOnComplete ??= opts.removeOnComplete;
+    if (opts.removeOnFail !== undefined) base.removeOnFail ??= opts.removeOnFail;
+    return Object.keys(base).length > 0 ? base : undefined;
+  }
+
+  // ------------------------------------------------- core processing pipeline
+
+  private async processJob(job: Job<T>): Promise<R> {
+    if (this.rateGate) await this.rateGate.acquire(this.rateGate.groupFor(job.data));
+    // Circuit breaker check
+    if (this.cb?.isOpen()) {
+      throw new Error('Circuit breaker is open');
+    }
+    // TTL check
+    if (this.ttlChecker?.isExpired(job.name ?? '', job.timestamp)) {
+      throw new Error(`Job expired (age: ${Date.now() - job.timestamp}ms)`);
+    }
+    // Register cancellation
+    const ac = this.cancellation.register(job.id);
+    const runChain = () => this.runMiddlewareChain(job, ac);
+    const execute = this.retryConfig ? executeWithRetry(runChain, this.retryConfig) : runChain();
+
+    return execute.then(
+      (result) => {
+        this.cb?.onSuccess();
+        this.cancellation.unregister(job.id);
+        return result;
+      },
+      (err: unknown) => {
+        this.cb?.onFailure();
+        this.cancellation.unregister(job.id);
+        throw err;
+      }
+    );
+  }
+
+  private runMiddlewareChain(job: Job<T>, ac: AbortController): Promise<R> {
+    if (this.middlewares.length === 0) {
+      const result = this.baseProcessor(job);
+      return result instanceof Promise ? result : Promise.resolve(result);
+    }
+    let index = 0;
+    const mws = this.middlewares;
+    const base = this.baseProcessor;
+    const next = (): Promise<R> => {
+      if (ac.signal.aborted) return Promise.reject(new Error('Job cancelled'));
+      if (index < mws.length) return mws[index++](job, next);
+      const result = base(job);
+      return result instanceof Promise ? result : Promise.resolve(result);
+    };
+    return next();
+  }
+
+  // --------------------------------------------------------------- middleware
+
+  use(middleware: BunqueueMiddleware<T, R>): this {
+    this.middlewares.push(middleware);
+    return this;
+  }
+
+  // --------------------------------------------------------- queue operations
+
+  add(name: string, data: T, opts?: JobOptions): Promise<Job<T>> {
+    const merged = { ...this.defaultJobOptions, ...opts };
+    return this.queue.add(name, data, this.merger.merge(name, merged, data));
+  }
+
+  addBulk(jobs: Array<{ name: string; data: T; opts?: JobOptions }>): Promise<Job<T>[]> {
+    return this.queue.addBulk(
+      jobs.map((j) => ({
+        ...j,
+        opts: this.merger.merge(j.name, { ...this.defaultJobOptions, ...j.opts }, j.data),
+      }))
+    );
+  }
+
+  getJob(id: string): Promise<Job<T> | null> {
+    return this.queue.getJob(id);
+  }
+  getJobCounts() {
+    return this.queue.getJobCounts();
+  }
+  getJobCountsAsync() {
+    return this.queue.getJobCounts();
+  }
+  count() {
+    return this.queue.count();
+  }
+  countAsync() {
+    return this.queue.count();
+  }
+}
+
+export interface Bunqueue<T = unknown, R = unknown> extends BunqueueApi<T, R> {}
+
+Object.assign(Bunqueue.prototype, bunqueueApi);

package/src/bunqueue/cancellation.ts

@@ -0,0 +1,54 @@
+/**
+ * Bunqueue Simple Mode — graceful job cancellation.
+ * 1:1 port of src/client/bunqueue/cancellation.ts: AbortController-based
+ * cancellation with optional grace period.
+ */
+
+export class CancellationManager {
+  private readonly controllers = new Map<string, AbortController>();
+
+  /** Register a new AbortController for a job. */
+  register(jobId: string): AbortController {
+    const ac = new AbortController();
+    this.controllers.set(jobId, ac);
+    return ac;
+  }
+
+  /** Remove a job's controller (on completion). */
+  unregister(jobId: string): void {
+    this.controllers.delete(jobId);
+  }
+
+  /** Cancel a job with optional grace period. */
+  cancel(jobId: string, gracePeriodMs = 0): void {
+    const ac = this.controllers.get(jobId);
+    if (!ac) return;
+
+    if (gracePeriodMs > 0) {
+      setTimeout(() => {
+        ac.abort();
+      }, gracePeriodMs);
+    } else {
+      ac.abort();
+    }
+  }
+
+  /** Check if a job is cancelled. */
+  isCancelled(jobId: string): boolean {
+    const ac = this.controllers.get(jobId);
+    return ac ? ac.signal.aborted : false;
+  }
+
+  /** Get the AbortSignal for a job. */
+  getSignal(jobId: string): AbortSignal | null {
+    return this.controllers.get(jobId)?.signal ?? null;
+  }
+
+  /** Cancel all and clear. */
+  destroyAll(): void {
+    for (const ac of this.controllers.values()) {
+      ac.abort();
+    }
+    this.controllers.clear();
+  }
+}

package/src/bunqueue/circuit-breaker.ts

@@ -0,0 +1,81 @@
+/**
+ * Bunqueue Simple Mode — circuit breaker for worker protection.
+ * 1:1 port of src/client/bunqueue/circuitBreaker.ts.
+ */
+
+import type { WorkerBase } from '../worker-base.js';
+import type { CircuitBreakerConfig, CircuitState } from './types.js';
+
+export class WorkerCircuitBreaker {
+  private state: CircuitState = 'closed';
+  private failures = 0;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private readonly config: CircuitBreakerConfig;
+  private readonly worker: WorkerBase;
+
+  constructor(config: CircuitBreakerConfig, worker: WorkerBase) {
+    this.config = config;
+    this.worker = worker;
+  }
+
+  get currentState(): CircuitState {
+    return this.state;
+  }
+
+  isOpen(): boolean {
+    return this.state === 'open';
+  }
+
+  onSuccess(): void {
+    if (this.state === 'half-open') {
+      this.state = 'closed';
+      this.failures = 0;
+      this.config.onClose?.();
+    } else if (this.state === 'closed') {
+      this.failures = 0;
+    }
+  }
+
+  onFailure(): void {
+    this.failures++;
+    const threshold = this.config.threshold ?? 5;
+
+    if (this.state === 'half-open' || this.failures >= threshold) {
+      this.open();
+    }
+  }
+
+  private open(): void {
+    this.state = 'open';
+    this.config.onOpen?.(this.failures);
+    this.worker.pause();
+
+    const resetTimeout = this.config.resetTimeout ?? 30000;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.state = 'half-open';
+      this.config.onHalfOpen?.();
+      this.worker.resume();
+    }, resetTimeout);
+    this.timer.unref?.();
+  }
+
+  reset(): void {
+    this.state = 'closed';
+    this.failures = 0;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.worker.isPaused()) {
+      this.worker.resume();
+    }
+  }
+
+  destroy(): void {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+}