bunqueue-client 0.1.8 → 0.2.0

package/dist/legacy.js

@@ -0,0 +1,2081 @@
+import {
+  BunqueueError2,
+  ConnectionClosedError2,
+  CommandTimeoutError2,
+  CommandError2,
+  SerializationError2,
+  AuthError2,
+  UnrecoverableError2,
+  PROTOCOL_VERSION2,
+  MAX_FRAME_SIZE2,
+  compact2
+} from "./chunk-b967v3w3.js";
+import {
+  noopLogger2,
+  consoleLogger2,
+  Connection2,
+  ConnectionPool2
+} from "./chunk-jxkszwqp.js";
+import {
+  terminalOutcomeWasApplied,
+  AckBatcher2
+} from "./chunk-fekm0ma6.js";
+
+// src/job.ts
+class Job {
+  raw;
+  token;
+  conn;
+  onProgress;
+  constructor(raw, connection, token, onProgress) {
+    this.raw = raw;
+    this.conn = connection;
+    this.token = token;
+    this.onProgress = onProgress;
+  }
+  get id() {
+    return String(this.raw.id);
+  }
+  get queue() {
+    return String(this.raw.queue);
+  }
+  get data() {
+    const data = this.raw.data;
+    if (this.topLevelName() !== undefined)
+      return data;
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const record = data;
+      if (typeof record.name === "string") {
+        const { name: _legacyName, ...userData } = record;
+        return userData;
+      }
+    }
+    return data;
+  }
+  get name() {
+    const modern = this.topLevelName();
+    if (modern !== undefined)
+      return modern;
+    const data = this.raw.data;
+    if (data && typeof data === "object" && !Array.isArray(data) && "name" in data) {
+      const name = data.name;
+      return typeof name === "string" ? name : undefined;
+    }
+    return;
+  }
+  topLevelName() {
+    const name = this.raw.name;
+    return name === undefined || name === null ? undefined : String(name);
+  }
+  get priority() {
+    return Number(this.raw.priority ?? 0);
+  }
+  get attempts() {
+    return Number(this.raw.attempts ?? 0);
+  }
+  get maxAttempts() {
+    return Number(this.raw.maxAttempts ?? 0);
+  }
+  get createdAt() {
+    return this.raw.createdAt === undefined ? undefined : Number(this.raw.createdAt);
+  }
+  get timestamp() {
+    return this.createdAt ?? Date.now();
+  }
+  get startedAt() {
+    return this.raw.startedAt === undefined || this.raw.startedAt === null ? null : Number(this.raw.startedAt);
+  }
+  get completedAt() {
+    return this.raw.completedAt === undefined || this.raw.completedAt === null ? null : Number(this.raw.completedAt);
+  }
+  get customId() {
+    return this.raw.customId === undefined || this.raw.customId === null ? null : String(this.raw.customId);
+  }
+  get tags() {
+    return Array.isArray(this.raw.tags) ? this.raw.tags.map(String) : [];
+  }
+  get groupId() {
+    return this.raw.groupId === undefined || this.raw.groupId === null ? null : String(this.raw.groupId);
+  }
+  get parentId() {
+    return this.raw.parentId === undefined || this.raw.parentId === null ? null : String(this.raw.parentId);
+  }
+  get childrenIds() {
+    return Array.isArray(this.raw.childrenIds) ? this.raw.childrenIds.map(String) : [];
+  }
+  get dependsOn() {
+    return Array.isArray(this.raw.dependsOn) ? this.raw.dependsOn.map(String) : [];
+  }
+  get progress() {
+    return Number(this.raw.progress ?? 0);
+  }
+  get stacktrace() {
+    return Array.isArray(this.raw.stacktrace) ? this.raw.stacktrace.map(String) : null;
+  }
+  get state() {
+    return this.raw.state === undefined ? undefined : String(this.raw.state);
+  }
+  call(command) {
+    if (!this.conn)
+      return Promise.reject(new Error("Job is not bound to a connection"));
+    return this.conn.call(command);
+  }
+  async updateProgress(progress, message) {
+    await this.call({ cmd: "Progress", id: this.id, progress, message });
+    this.onProgress?.(this, progress);
+  }
+  async log(message, level) {
+    await this.call({ cmd: "AddLog", id: this.id, message, level });
+  }
+  async heartbeat() {
+    await this.call({ cmd: "JobHeartbeat", id: this.id, token: this.token });
+  }
+  async extendLock(durationMs) {
+    await this.call({ cmd: "ExtendLock", id: this.id, token: this.token, duration: durationMs });
+  }
+  async getState() {
+    const response = await this.call({ cmd: "GetState", id: this.id });
+    return String(response.state);
+  }
+  async getChildrenValues() {
+    const response = await this.call({ cmd: "GetChildrenValues", id: this.id });
+    const data = response.data ?? {};
+    return data.values ?? response.values ?? {};
+  }
+  async remove() {
+    await this.call({ cmd: "Cancel", id: this.id });
+  }
+  async discard() {
+    await this.call({
+      cmd: "Discard",
+      id: this.id,
+      ...this.token === undefined ? {} : { token: this.token }
+    });
+  }
+  async promote() {
+    await this.call({ cmd: "Promote", id: this.id });
+  }
+  async retry() {
+    await this.call({
+      cmd: "MoveToWait",
+      id: this.id,
+      ...this.token === undefined ? {} : { token: this.token }
+    });
+  }
+  async updateData(data) {
+    await this.call({ cmd: "Update", id: this.id, data });
+  }
+  async changePriority(opts) {
+    await this.call({
+      cmd: "ChangePriority",
+      id: this.id,
+      priority: opts.priority,
+      lifo: opts.lifo
+    });
+  }
+  async changeDelay(delayMs) {
+    await this.call({
+      cmd: "ChangeDelay",
+      id: this.id,
+      delay: delayMs,
+      ...this.token === undefined ? {} : { token: this.token }
+    });
+  }
+  async moveToDelayed(delayMs) {
+    await this.call({
+      cmd: "MoveToDelayed",
+      id: this.id,
+      delay: delayMs,
+      ...this.token === undefined ? {} : { token: this.token }
+    });
+  }
+}
+
+// src/types.ts
+function wireJobOptions(opts = {}) {
+  return compact2({
+    priority: opts.priority,
+    delay: opts.delay,
+    maxAttempts: opts.attempts,
+    backoff: opts.backoff,
+    ttl: opts.ttl,
+    timeout: opts.timeout,
+    jobId: opts.jobId,
+    uniqueKey: opts.deduplication?.id,
+    dedup: opts.deduplication ? compact2({
+      ttl: opts.deduplication.ttl,
+      extend: opts.deduplication.extend,
+      replace: opts.deduplication.replace
+    }) : undefined,
+    dependsOn: opts.dependsOn,
+    parentId: opts.parentId,
+    childrenIds: opts.childrenIds,
+    tags: opts.tags,
+    groupId: opts.groupId,
+    lifo: opts.lifo,
+    removeOnComplete: typeof opts.removeOnComplete === "boolean" ? opts.removeOnComplete : undefined,
+    removeOnFail: typeof opts.removeOnFail === "boolean" ? opts.removeOnFail : undefined,
+    stallTimeout: opts.stallTimeout,
+    durable: opts.durable,
+    repeat: opts.repeat,
+    debounceId: opts.debounce?.id,
+    debounceTtl: opts.debounce?.ttl,
+    stackTraceLimit: opts.stackTraceLimit,
+    keepLogs: opts.keepLogs,
+    sizeLimit: opts.sizeLimit,
+    timestamp: opts.timestamp,
+    failParentOnFailure: opts.failParentOnFailure,
+    removeDependencyOnFailure: opts.removeDependencyOnFailure,
+    ignoreDependencyOnFailure: opts.ignoreDependencyOnFailure,
+    continueParentOnFailure: opts.continueParentOnFailure
+  });
+}
+function jobPayload(name, data) {
+  return { name, data };
+}
+
+// src/queue-admin.ts
+var adminMethods = {
+  async getDlq(count) {
+    const response = await this.call(compact2({ cmd: "Dlq", queue: this.name, count }));
+    return response.jobs ?? response.data ?? [];
+  },
+  async retryDlq(jobId) {
+    const response = await this.call(compact2({ cmd: "RetryDlq", queue: this.name, jobId }));
+    return Number(response.count ?? 0);
+  },
+  async purgeDlq() {
+    const response = await this.call({ cmd: "PurgeDlq", queue: this.name });
+    return Number(response.count ?? 0);
+  },
+  async setDlqConfig(config) {
+    await this.call({ cmd: "SetDlqConfig", queue: this.name, config });
+  },
+  async getDlqConfig() {
+    const response = await this.call({ cmd: "GetDlqConfig", queue: this.name });
+    return response.config ?? response.data ?? {};
+  },
+  async setStallConfig(config) {
+    await this.call({ cmd: "SetStallConfig", queue: this.name, config });
+  },
+  async getStallConfig() {
+    const response = await this.call({ cmd: "GetStallConfig", queue: this.name });
+    return response.config ?? response.data ?? {};
+  },
+  async setGlobalRateLimit(max, duration) {
+    await this.call({ cmd: "RateLimit", queue: this.name, limit: max, duration });
+  },
+  async removeGlobalRateLimit() {
+    await this.call({ cmd: "RateLimitClear", queue: this.name });
+  },
+  async setGlobalConcurrency(concurrency) {
+    await this.call({ cmd: "SetConcurrency", queue: this.name, limit: concurrency });
+  },
+  async removeGlobalConcurrency() {
+    await this.call({ cmd: "ClearConcurrency", queue: this.name });
+  },
+  async upsertJobScheduler(schedulerId, repeat, template = {}) {
+    const dedup = template.opts?.deduplication;
+    await this.call(compact2({
+      cmd: "Cron",
+      name: schedulerId,
+      jobName: template.name ?? schedulerId,
+      queue: this.name,
+      data: "data" in template ? template.data : {},
+      schedule: repeat.pattern,
+      repeatEvery: repeat.every,
+      priority: template.opts?.priority,
+      timezone: repeat.tz,
+      immediately: repeat.immediately,
+      maxLimit: repeat.limit,
+      uniqueKey: dedup?.id,
+      dedup: dedup ? compact2({ ttl: dedup.ttl, extend: dedup.extend, replace: dedup.replace }) : undefined,
+      skipMissedOnRestart: repeat.skipMissedOnRestart,
+      skipIfNoWorker: repeat.skipIfNoWorker,
+      preventOverlap: repeat.preventOverlap,
+      jobOptions: template.opts ? wireJobOptions(template.opts) : undefined
+    }));
+  },
+  async removeJobScheduler(schedulerId) {
+    await this.call({ cmd: "CronDelete", name: schedulerId });
+  },
+  async getJobScheduler(schedulerId) {
+    try {
+      const response = await this.call({ cmd: "CronGet", name: schedulerId });
+      return response.cron ?? response.data ?? null;
+    } catch (err) {
+      if (err instanceof CommandError2 && /not found/i.test(err.message))
+        return null;
+      throw err;
+    }
+  },
+  async getJobSchedulers() {
+    const response = await this.call({ cmd: "CronList" });
+    const crons = response.crons ?? [];
+    return crons.filter((cron) => cron.queue === this.name);
+  },
+  async getJobSchedulersCount() {
+    return (await this.getJobSchedulers()).length;
+  },
+  addCron(name, schedule, data, opts) {
+    return this.upsertJobScheduler(name, { pattern: schedule }, { name, data, opts });
+  },
+  every(name, intervalMs, data, opts) {
+    return this.upsertJobScheduler(name, { every: intervalMs }, { name, data, opts });
+  },
+  async getWorkers() {
+    const response = await this.call({ cmd: "ListWorkers" });
+    const data = response.data ?? {};
+    return data.workers ?? response.workers ?? [];
+  },
+  async getWorkersCount() {
+    return (await this.getWorkers()).length;
+  },
+  async getStats() {
+    const response = await this.call({ cmd: "Stats" });
+    return response.stats ?? {};
+  },
+  async getMetrics() {
+    const response = await this.call({ cmd: "Metrics" });
+    return response.metrics ?? {};
+  },
+  async listQueues() {
+    const response = await this.call({ cmd: "ListQueues" });
+    const queues = response.queues ?? [];
+    return queues.map((q) => typeof q === "string" ? q : String(q.name));
+  },
+  async addWebhook(opts) {
+    const response = await this.call(compact2({
+      cmd: "AddWebhook",
+      url: opts.url,
+      events: opts.events,
+      queue: opts.queue ?? this.name,
+      secret: opts.secret
+    }));
+    const data = response.data ?? {};
+    return data.webhook ?? data;
+  },
+  async removeWebhook(webhookId) {
+    await this.call({ cmd: "RemoveWebhook", webhookId });
+  },
+  async listWebhooks() {
+    const response = await this.call({ cmd: "ListWebhooks" });
+    const data = response.data ?? {};
+    return data.webhooks ?? response.webhooks ?? [];
+  },
+  async setWebhookEnabled(webhookId, enabled) {
+    await this.call({ cmd: "SetWebhookEnabled", id: webhookId, enabled });
+  }
+};
+
+// src/worker-types.ts
+var MAX_POLL_TIMEOUT_MS = 30000;
+var MAX_STACK_LINES = 20;
+var RECONNECT_BACKOFF_MS = [500, 1000, 2000, 5000];
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/queue-control.ts
+var controlMethods = {
+  async pause() {
+    await this.call({ cmd: "Pause", queue: this.name });
+  },
+  async resume() {
+    await this.call({ cmd: "Resume", queue: this.name });
+  },
+  async isPaused() {
+    return (await this.call({ cmd: "IsPaused", queue: this.name })).paused === true;
+  },
+  async drain() {
+    const response = await this.call({ cmd: "Drain", queue: this.name });
+    return response.count ?? 0;
+  },
+  async obliterate() {
+    await this.call({ cmd: "Obliterate", queue: this.name });
+  },
+  async clean(graceMs, limit, state) {
+    const response = await this.call(compact2({ cmd: "Clean", queue: this.name, grace: graceMs, limit, state }));
+    return response.count ?? 0;
+  },
+  async remove(id) {
+    await this.call({ cmd: "Cancel", id });
+  },
+  async discard(id) {
+    await this.call({ cmd: "Discard", id });
+  },
+  async promoteJob(id) {
+    await this.call({ cmd: "Promote", id });
+  },
+  async promoteJobs(opts = {}) {
+    const response = await this.call(compact2({ cmd: "PromoteJobs", queue: this.name, count: opts.count }));
+    return response.count ?? 0;
+  },
+  async retryJob(id) {
+    await this.call({ cmd: "MoveToWait", id });
+  },
+  async retryJobs(opts = {}) {
+    if (opts.state === "completed") {
+      await this.call({ cmd: "RetryCompleted", queue: this.name });
+      return;
+    }
+    await this.call(compact2({ cmd: "RetryDlq", queue: this.name, count: opts.count }));
+  },
+  async retryCompleted(id) {
+    await this.call(compact2({ cmd: "RetryCompleted", queue: this.name, id }));
+  },
+  async updateJobProgress(id, progress, message) {
+    await this.call(compact2({ cmd: "Progress", id, progress, message }));
+  },
+  async updateJobData(id, data) {
+    await this.call({ cmd: "Update", id, data });
+  },
+  async changeJobPriority(id, opts) {
+    await this.call({ cmd: "ChangePriority", id, priority: opts.priority, lifo: opts.lifo });
+  },
+  async changeJobDelay(id, delayMs, token) {
+    await this.call(compact2({ cmd: "ChangeDelay", id, delay: delayMs, token }));
+  },
+  async moveJobToWait(id, token) {
+    await this.call(compact2({ cmd: "MoveToWait", id, token }));
+  },
+  async moveJobToDelayed(id, delayMs, token) {
+    await this.call(compact2({ cmd: "MoveToDelayed", id, delay: delayMs, token }));
+  },
+  async extendJobLock(id, token, durationMs) {
+    await this.call({ cmd: "ExtendLock", id, token, duration: durationMs });
+  },
+  async moveJobToCompleted(id, returnValue, token) {
+    await this.call(compact2({ cmd: "ACK", id, result: returnValue, token }));
+  },
+  async moveJobToFailed(id, error, token) {
+    const err = typeof error === "string" ? undefined : error;
+    const message = err ? err.message || err.name : error;
+    const stack = err ? (err.stack ?? err.message).split(`
+`).slice(0, MAX_STACK_LINES) : undefined;
+    await this.call(compact2({
+      cmd: "FAIL",
+      id,
+      error: message,
+      stack,
+      unrecoverable: err instanceof UnrecoverableError2 ? true : undefined,
+      token
+    }));
+  }
+};
+
+// src/queue-query.ts
+function unwrapValues(response) {
+  const data = response.data ?? {};
+  return data.values ?? response.values ?? data ?? {};
+}
+var queryMethods = {
+  async getJob(id) {
+    try {
+      const response = await this.call({ cmd: "GetJob", id });
+      return response.job ? new Job(response.job, this.connection) : null;
+    } catch (err) {
+      if (err instanceof CommandError2 && /not found/i.test(err.message))
+        return null;
+      throw err;
+    }
+  },
+  async getJobByCustomId(customId) {
+    try {
+      const response = await this.call({ cmd: "GetJobByCustomId", customId });
+      return response.job ? new Job(response.job, this.connection) : null;
+    } catch (err) {
+      if (err instanceof CommandError2 && /not found/i.test(err.message))
+        return null;
+      throw err;
+    }
+  },
+  async getDeduplicationJobId(deduplicationId) {
+    const job = await this.getJobByCustomId(deduplicationId);
+    return job ? job.id : null;
+  },
+  async getJobs(opts = {}) {
+    const start = opts.start ?? 0;
+    const end = opts.end !== undefined && opts.end >= 0 ? opts.end : 1000;
+    const response = await this.call(compact2({
+      cmd: "GetJobs",
+      queue: this.name,
+      state: opts.state,
+      offset: start,
+      limit: end - start
+    }));
+    return (response.jobs ?? []).map((raw) => new Job(raw, this.connection));
+  },
+  getWaiting(start, end) {
+    return this.getJobs({ state: "waiting", start, end });
+  },
+  getDelayed(start, end) {
+    return this.getJobs({ state: "delayed", start, end });
+  },
+  getActive(start, end) {
+    return this.getJobs({ state: "active", start, end });
+  },
+  getCompleted(start, end) {
+    return this.getJobs({ state: "completed", start, end });
+  },
+  getFailed(start, end) {
+    return this.getJobs({ state: "failed", start, end });
+  },
+  getPrioritized(start, end) {
+    return this.getJobs({ state: "prioritized", start, end });
+  },
+  getWaitingChildren(start, end) {
+    return this.getJobs({ state: "waiting-children", start, end });
+  },
+  async getJobState(id) {
+    return (await this.call({ cmd: "GetState", id })).state;
+  },
+  async getResult(id) {
+    return (await this.call({ cmd: "GetResult", id })).result;
+  },
+  async getChildrenValues(id) {
+    return unwrapValues(await this.call({ cmd: "GetChildrenValues", id }));
+  },
+  async getFailedChildrenValues(id) {
+    return unwrapValues(await this.call({ cmd: "GetFailedChildrenValues", id }));
+  },
+  async getIgnoredChildrenFailures(id) {
+    return unwrapValues(await this.call({ cmd: "GetIgnoredChildrenFailures", id }));
+  },
+  async removeChildDependency(id) {
+    await this.call({ cmd: "RemoveChildDependency", id });
+  },
+  async removeUnprocessedChildren(id) {
+    await this.call({ cmd: "RemoveUnprocessedChildren", id });
+  },
+  async waitForJob(id, ttlMs = 30000) {
+    ttlMs = Math.min(Math.max(ttlMs, 0), 600000);
+    const response = await this.call({ cmd: "WaitJob", id, timeout: ttlMs }, ttlMs + 5000);
+    if (response.completed !== true) {
+      let state;
+      try {
+        state = await this.getJobState(id);
+      } catch {}
+      if (state === "failed")
+        throw new CommandError2(`job ${id} failed before completion`);
+      throw new CommandTimeoutError2(`waitUntilFinished timed out after ${ttlMs}ms`);
+    }
+    return response.result;
+  },
+  waitJobUntilFinished(id, _queueEvents, ttlMs) {
+    return this.waitForJob(id, ttlMs);
+  },
+  async getProgress(id) {
+    const response = await this.call({ cmd: "GetProgress", id });
+    return { progress: response.progress ?? 0, message: response.message ?? null };
+  },
+  async getJobCounts() {
+    return (await this.call({ cmd: "GetJobCounts", queue: this.name })).counts;
+  },
+  async getWaitingCount() {
+    return (await this.getJobCounts()).waiting;
+  },
+  async getActiveCount() {
+    return (await this.getJobCounts()).active;
+  },
+  async getCompletedCount() {
+    return (await this.getJobCounts()).completed;
+  },
+  async getFailedCount() {
+    return (await this.getJobCounts()).failed;
+  },
+  async getDelayedCount() {
+    return (await this.getJobCounts()).delayed;
+  },
+  async getPrioritizedCount() {
+    return (await this.getJobCounts()).prioritized;
+  },
+  async getWaitingChildrenCount() {
+    return (await this.getJobCounts())["waiting-children"];
+  },
+  async count() {
+    return (await this.call({ cmd: "Count", queue: this.name })).count ?? 0;
+  },
+  async getCountsPerPriority() {
+    const response = await this.call({ cmd: "GetCountsPerPriority", queue: this.name });
+    return response.counts ?? response.data ?? {};
+  },
+  async addJobLog(id, message, level) {
+    await this.call(compact2({ cmd: "AddLog", id, message, level }));
+  },
+  async getJobLogs(id, start, end) {
+    const response = await this.call(compact2({ cmd: "GetLogs", id, start, end }));
+    const data = response.data ?? {};
+    const logs = data.logs ?? response.logs ?? [];
+    return logs.map((row) => {
+      if (typeof row === "string")
+        return row;
+      const r = row;
+      return r.level ? `[${r.level}] ${r.message}` : String(r.message ?? row);
+    });
+  },
+  async clearJobLogs(id, keepLogs) {
+    await this.call(compact2({ cmd: "ClearLogs", id, keepLogs }));
+  }
+};
+
+// src/queue.ts
+class Queue {
+  name;
+  connection;
+  ownsConnection;
+  constructor(name, opts = {}) {
+    this.name = name;
+    const connOptions = {
+      host: opts.host,
+      port: opts.port,
+      token: opts.token,
+      tls: opts.tls,
+      commandTimeoutMs: opts.commandTimeoutMs,
+      maxInFlight: opts.maxInFlight,
+      logger: opts.logger,
+      onTelemetry: opts.onTelemetry
+    };
+    this.connection = opts.connection ?? (opts.poolSize && opts.poolSize > 1 ? new ConnectionPool2(opts.poolSize, connOptions) : new Connection2(connOptions));
+    this.ownsConnection = opts.connection === undefined;
+  }
+  call(command, timeoutMs) {
+    return this.connection.call(command, timeoutMs);
+  }
+  async add(name, data, opts) {
+    const payload = jobPayload(name, data);
+    const response = await this.call({
+      cmd: "PUSH",
+      queue: this.name,
+      ...payload,
+      ...wireJobOptions(opts)
+    });
+    return new Job({ id: response.id, queue: this.name, ...payload }, this.connection);
+  }
+  async addBulk(jobs) {
+    const inputs = jobs.map((entry) => {
+      const opts = wireJobOptions(entry.opts);
+      if (opts.jobId !== undefined) {
+        opts.customId = opts.jobId;
+        delete opts.jobId;
+      }
+      return { ...jobPayload(entry.name, entry.data), ...opts };
+    });
+    const response = await this.call({ cmd: "PUSHB", queue: this.name, jobs: inputs });
+    const ids = response.ids ?? [];
+    return ids.map((id, i) => new Job({ id, queue: this.name, name: inputs[i].name, data: inputs[i].data }, this.connection));
+  }
+  ping() {
+    return this.connection.ping();
+  }
+  async waitUntilReady() {
+    await this.connection.connect();
+  }
+  close() {
+    if (this.ownsConnection)
+      this.connection.close();
+  }
+  async disconnect() {
+    this.close();
+  }
+}
+Object.assign(Queue.prototype, queryMethods, controlMethods, adminMethods);
+
+// src/worker.ts
+import { hostname as hostname2 } from "node:os";
+
+// src/worker-base.ts
+import { randomBytes } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { hostname } from "node:os";
+class WorkerBase extends EventEmitter {
+  queue;
+  concurrency;
+  batchSize;
+  pollTimeoutMs;
+  lockTtlMs;
+  heartbeatIntervalS;
+  workerId;
+  name;
+  connection;
+  active = new Map;
+  cancelledJobs = new Set;
+  stopped = false;
+  paused = false;
+  closedFlag = false;
+  running = false;
+  wasBusy = false;
+  processed = 0;
+  failedCount = 0;
+  readyPromise;
+  readyResolve = null;
+  readyFired = false;
+  loopPromise = null;
+  heartbeatTimer = null;
+  registeredGeneration = -1;
+  constructor(queue, opts = {}) {
+    super();
+    if ((opts.concurrency ?? 4) < 1)
+      throw new Error("concurrency must be >= 1");
+    this.queue = queue;
+    this.concurrency = opts.concurrency ?? 4;
+    const rawBatch = opts.batchSize ?? 10;
+    this.batchSize = Number.isFinite(rawBatch) ? Math.min(Math.max(1, rawBatch), 1000) : 10;
+    this.pollTimeoutMs = Math.min(opts.pollTimeoutMs ?? 5000, MAX_POLL_TIMEOUT_MS);
+    this.lockTtlMs = opts.lockTtlMs ?? 30000;
+    this.heartbeatIntervalS = opts.heartbeatIntervalS ?? 10;
+    this.workerId = `ts-${hostname()}-${process.pid}-${randomBytes(4).toString("hex")}`;
+    this.name = opts.name ?? this.workerId;
+    this.connection = new Connection2({
+      host: opts.host,
+      port: opts.port,
+      token: opts.token,
+      tls: opts.tls,
+      logger: opts.logger,
+      onTelemetry: opts.onTelemetry
+    });
+    this.readyPromise = new Promise((resolve) => {
+      this.readyResolve = resolve;
+    });
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+  }
+  isRunning() {
+    return this.running && !this.closedFlag;
+  }
+  isPaused() {
+    return this.paused;
+  }
+  isClosed() {
+    return this.closedFlag;
+  }
+  async waitUntilReady() {
+    await this.readyPromise;
+  }
+  on(event, listener) {
+    if (event === "ready" && this.readyFired)
+      listener();
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    if (event === "ready" && this.readyFired) {
+      listener();
+      return this;
+    }
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  cancelJob(jobId, reason) {
+    if (this.active.has(jobId)) {
+      this.cancelledJobs.add(jobId);
+      this.emit("cancelled", { jobId, reason: reason ?? "Job cancelled by worker" });
+      return true;
+    }
+    return false;
+  }
+  cancelAllJobs(reason) {
+    for (const jobId of this.active.keys()) {
+      this.cancelledJobs.add(jobId);
+      this.emit("cancelled", { jobId, reason: reason ?? "All jobs cancelled" });
+    }
+  }
+  isJobCancelled(jobId) {
+    return this.cancelledJobs.has(jobId);
+  }
+  async close(force = false) {
+    if (this.closedFlag)
+      return;
+    this.stopped = true;
+    if (this.loopPromise)
+      await this.loopPromise;
+    await this.beforeClose();
+    while (!force && this.active.size > 0)
+      await sleep(20);
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.registeredGeneration >= 0) {
+      await this.safeCall({ cmd: "UnregisterWorker", workerId: this.workerId });
+    }
+    this.connection.close();
+    this.closedFlag = true;
+    this.running = false;
+    this.emit("closed");
+  }
+  async safeCall(command, outcome = () => true) {
+    try {
+      const response = await this.connection.call(command);
+      return outcome(response);
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+      return false;
+    }
+  }
+  async beforeClose() {}
+}
+
+// src/worker-slot-signal.ts
+class SlotSignal {
+  waiter = null;
+  wait(timeoutMs) {
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = () => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        if (this.waiter === finish)
+          this.waiter = null;
+        resolve();
+      };
+      const timer = setTimeout(finish, timeoutMs);
+      this.waiter = finish;
+    });
+  }
+  notify() {
+    this.waiter?.();
+  }
+}
+
+// src/worker.ts
+class Worker extends WorkerBase {
+  processor;
+  ackBatcher;
+  slotSignal = new SlotSignal;
+  constructor(queue, processor, opts = {}) {
+    super(queue, opts);
+    this.processor = processor;
+    const ab = opts.ackBatch;
+    this.ackBatcher = ab?.enabled ? new AckBatcher2(this.connection, ab.maxSize ?? 50, ab.maxDelayMs ?? 5) : null;
+    if (opts.autorun !== false)
+      this.run();
+  }
+  async beforeClose() {
+    if (this.ackBatcher)
+      await this.ackBatcher.flush();
+  }
+  run() {
+    if (this.running || this.closedFlag)
+      return;
+    this.running = true;
+    this.loopPromise = this.loop().catch((err) => {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+  async loop() {
+    await this.register();
+    this.readyResolve?.();
+    this.readyFired = true;
+    this.emit("ready");
+    this.startHeartbeat();
+    let backoffIdx = 0;
+    while (!this.stopped) {
+      if (this.paused) {
+        await sleep(50);
+        continue;
+      }
+      try {
+        await this.pollOnce();
+        backoffIdx = 0;
+      } catch (err) {
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+        if (err instanceof ConnectionClosedError2 || err instanceof CommandTimeoutError2) {
+          const delay = RECONNECT_BACKOFF_MS[Math.min(backoffIdx, RECONNECT_BACKOFF_MS.length - 1)];
+          backoffIdx += 1;
+          await sleep(delay);
+        } else {
+          await sleep(200);
+        }
+      }
+    }
+  }
+  async pollOnce() {
+    const free = this.concurrency - this.active.size;
+    if (free <= 0) {
+      await this.slotSignal.wait(20);
+      return;
+    }
+    if (this.connection.isConnected && this.connection.generation !== this.registeredGeneration) {
+      await this.register();
+    }
+    const response = await this.connection.call({
+      cmd: "PULLB",
+      queue: this.queue,
+      count: Math.min(free, this.batchSize),
+      timeout: this.pollTimeoutMs,
+      owner: this.workerId,
+      lockTtl: this.lockTtlMs
+    }, this.pollTimeoutMs + 1e4);
+    const jobs = response.jobs ?? [];
+    const tokens = response.tokens ?? [];
+    if (jobs.length === 0) {
+      if (this.wasBusy && this.active.size === 0) {
+        this.wasBusy = false;
+        this.emit("drained");
+      }
+      return;
+    }
+    this.wasBusy = true;
+    for (let i = 0;i < jobs.length; i++) {
+      const jobId = String(jobs[i].id);
+      this.active.set(jobId, tokens[i]);
+      this.runJob(jobs[i], tokens[i]);
+    }
+  }
+  async runJob(raw, token) {
+    const job = new Job(raw, this.connection, token, (j, p) => this.emit("progress", j, p));
+    this.emit("active", job);
+    try {
+      const result = await this.processor(job);
+      if (this.ackBatcher) {
+        this.ackBatcher.add({
+          id: job.id,
+          token,
+          result: result ?? undefined,
+          onSettled: (err, applied) => {
+            this.finishJob(job.id);
+            if (err) {
+              this.emit("error", err instanceof Error ? err : new Error(String(err)));
+            } else if (applied) {
+              this.processed += 1;
+              this.emit("completed", job, result);
+            }
+          }
+        });
+        return;
+      }
+      const acked = await this.safeCall(compact2({ cmd: "ACK", id: job.id, token, result: result ?? undefined }), (response) => terminalOutcomeWasApplied(response.data));
+      this.finishJob(job.id);
+      if (acked) {
+        this.processed += 1;
+        this.emit("completed", job, result);
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const stack = (error.stack ?? error.message).split(`
+`).slice(0, MAX_STACK_LINES);
+      const failed = await this.safeCall(compact2({
+        cmd: "FAIL",
+        id: job.id,
+        token,
+        error: error.message || error.name,
+        stack,
+        unrecoverable: err instanceof UnrecoverableError2 ? true : undefined
+      }), (response) => terminalOutcomeWasApplied(response.data));
+      this.finishJob(job.id);
+      if (failed) {
+        this.failedCount += 1;
+        this.emit("failed", job, error);
+      }
+    }
+  }
+  finishJob(id) {
+    this.active.delete(id);
+    this.cancelledJobs.delete(id);
+    this.slotSignal.notify();
+  }
+  startHeartbeat() {
+    if (!(Number.isFinite(this.heartbeatIntervalS) && this.heartbeatIntervalS > 0))
+      return;
+    this.heartbeatTimer = setInterval(() => {
+      (async () => {
+        await this.safeCall({
+          cmd: "Heartbeat",
+          id: this.workerId,
+          activeJobs: this.active.size,
+          processed: this.processed,
+          failed: this.failedCount
+        });
+        if (this.active.size > 0) {
+          const ids = [...this.active.keys()];
+          const tokens = ids.map((id) => this.active.get(id));
+          await this.safeCall({ cmd: "JobHeartbeatB", ids, tokens });
+        }
+      })();
+    }, this.heartbeatIntervalS * 1000);
+    this.heartbeatTimer.unref?.();
+  }
+  async register() {
+    await this.safeCall({
+      cmd: "RegisterWorker",
+      name: this.name,
+      queues: [this.queue],
+      concurrency: this.concurrency,
+      workerId: this.workerId,
+      hostname: hostname2(),
+      pid: process.pid,
+      startedAt: Date.now()
+    });
+    this.registeredGeneration = this.connection.generation;
+  }
+}
+
+// src/bunqueue/aging.ts
+class PriorityAger {
+  timer = null;
+  config;
+  queue;
+  constructor(config, queue) {
+    this.config = config;
+    this.queue = queue;
+  }
+  start() {
+    const interval = this.config.interval ?? 60000;
+    this.timer = setInterval(() => {
+      this.tick();
+    }, interval);
+    this.timer.unref?.();
+  }
+  async tick() {
+    const minAge = this.config.minAge ?? 60000;
+    const boost = this.config.boost ?? 1;
+    const maxPriority = this.config.maxPriority ?? 100;
+    const maxScan = this.config.maxScan ?? 100;
+    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 {}
+      }
+    }
+  }
+  destroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+}
+
+// src/bunqueue/batch.ts
+class BatchAccumulator {
+  buffer = [];
+  timer = null;
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  buildProcessor() {
+    return (job) => {
+      return new Promise((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() {
+    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);
+      }
+    }, (err) => {
+      const error = err instanceof Error ? err : new Error(String(err));
+      for (const b of batch) {
+        b.reject(error);
+      }
+    });
+  }
+  destroy() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.buffer.length > 0) {
+      this.flush();
+    }
+  }
+}
+
+// src/bunqueue/bunqueue-api.ts
+var bunqueueApi = {
+  async cron(id, pattern, data, opts) {
+    await this.queue.upsertJobScheduler(id, { pattern, tz: opts?.timezone, limit: opts?.limit }, { name: id, data, opts: opts?.jobOpts });
+    return this.queue.getJobScheduler(id);
+  },
+  async every(id, intervalMs, data, opts) {
+    await this.queue.upsertJobScheduler(id, { every: intervalMs, limit: opts?.limit }, { name: id, data, opts: opts?.jobOpts });
+    return this.queue.getJobScheduler(id);
+  },
+  removeCron(id) {
+    return this.queue.removeJobScheduler(id);
+  },
+  listCrons() {
+    return this.queue.getJobSchedulers();
+  },
+  cancel(jobId, gracePeriodMs = 0) {
+    this.cancellation.cancel(jobId, gracePeriodMs);
+  },
+  isCancelled(jobId) {
+    return this.cancellation.isCancelled(jobId);
+  },
+  getSignal(jobId) {
+    return this.cancellation.getSignal(jobId);
+  },
+  getCircuitState() {
+    return this.cb?.currentState ?? "closed";
+  },
+  resetCircuit() {
+    this.cb?.reset();
+  },
+  trigger(rule) {
+    this.triggerMgr.add(rule);
+    return this;
+  },
+  setDefaultTtl(ttlMs) {
+    this.ttlChecker?.setDefaultTtl(ttlMs);
+  },
+  setNameTtl(name, ttlMs) {
+    this.ttlChecker?.setNameTtl(name, ttlMs);
+  },
+  setDlqConfig(config) {
+    return this.dlqrl.setDlqConfig(config);
+  },
+  getDlqConfig() {
+    return this.dlqrl.getDlqConfig();
+  },
+  getDlq(filter) {
+    return this.dlqrl.getDlq(filter);
+  },
+  getDlqStats() {
+    return this.dlqrl.getDlqStats();
+  },
+  retryDlq(id) {
+    return this.dlqrl.retryDlq(id);
+  },
+  purgeDlq() {
+    return this.dlqrl.purgeDlq();
+  },
+  setGlobalRateLimit(max, duration) {
+    return this.dlqrl.setGlobalRateLimit(max, duration);
+  },
+  removeGlobalRateLimit() {
+    return this.dlqrl.removeGlobalRateLimit();
+  },
+  on(event, listener) {
+    this.worker.on(event, listener);
+    return this;
+  },
+  once(event, listener) {
+    this.worker.once(event, listener);
+    return this;
+  },
+  off(event, listener) {
+    this.worker.off(event, listener);
+    return this;
+  },
+  pause() {
+    this.queue.pause().catch(() => {});
+    this.worker.pause();
+  },
+  resume() {
+    this.queue.resume().catch(() => {});
+    this.worker.resume();
+  },
+  async close(force = false) {
+    this.ager?.destroy();
+    this.cb?.destroy();
+    this.batchAcc?.destroy();
+    this.cancellation.destroyAll();
+    await this.worker.close(force);
+    this.queue.close();
+  },
+  isRunning() {
+    return this.worker.isRunning();
+  },
+  isPaused() {
+    return this.worker.isPaused();
+  },
+  isClosed() {
+    return this.worker.isClosed();
+  }
+};
+
+// src/bunqueue/cancellation.ts
+class CancellationManager {
+  controllers = new Map;
+  register(jobId) {
+    const ac = new AbortController;
+    this.controllers.set(jobId, ac);
+    return ac;
+  }
+  unregister(jobId) {
+    this.controllers.delete(jobId);
+  }
+  cancel(jobId, gracePeriodMs = 0) {
+    const ac = this.controllers.get(jobId);
+    if (!ac)
+      return;
+    if (gracePeriodMs > 0) {
+      setTimeout(() => {
+        ac.abort();
+      }, gracePeriodMs);
+    } else {
+      ac.abort();
+    }
+  }
+  isCancelled(jobId) {
+    const ac = this.controllers.get(jobId);
+    return ac ? ac.signal.aborted : false;
+  }
+  getSignal(jobId) {
+    return this.controllers.get(jobId)?.signal ?? null;
+  }
+  destroyAll() {
+    for (const ac of this.controllers.values()) {
+      ac.abort();
+    }
+    this.controllers.clear();
+  }
+}
+
+// src/bunqueue/circuit-breaker.ts
+class WorkerCircuitBreaker {
+  state = "closed";
+  failures = 0;
+  timer = null;
+  config;
+  worker;
+  constructor(config, worker) {
+    this.config = config;
+    this.worker = worker;
+  }
+  get currentState() {
+    return this.state;
+  }
+  isOpen() {
+    return this.state === "open";
+  }
+  onSuccess() {
+    if (this.state === "half-open") {
+      this.state = "closed";
+      this.failures = 0;
+      this.config.onClose?.();
+    } else if (this.state === "closed") {
+      this.failures = 0;
+    }
+  }
+  onFailure() {
+    this.failures++;
+    const threshold = this.config.threshold ?? 5;
+    if (this.state === "half-open" || this.failures >= threshold) {
+      this.open();
+    }
+  }
+  open() {
+    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() {
+    this.state = "closed";
+    this.failures = 0;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.worker.isPaused()) {
+      this.worker.resume();
+    }
+  }
+  destroy() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+}
+
+// src/bunqueue/dedup-debounce.ts
+class DedupDebounceMerger {
+  dedup;
+  debounce;
+  constructor(dedup, debounce) {
+    this.dedup = dedup;
+    this.debounce = debounce;
+  }
+  get active() {
+    return this.dedup !== null || this.debounce !== null;
+  }
+  merge(name, opts, data) {
+    if (!this.active)
+      return opts;
+    const merged = { ...opts };
+    if (this.dedup && !merged.deduplication) {
+      const dataKey = data !== undefined ? JSON.stringify(data) : "";
+      merged.deduplication = {
+        id: `${name}:${dataKey}`,
+        ttl: this.dedup.ttl ?? 3600000,
+        extend: this.dedup.extend,
+        replace: this.dedup.replace
+      };
+    }
+    if (this.debounce && !merged.debounce) {
+      merged.debounce = {
+        id: name,
+        ttl: this.debounce.ttl
+      };
+    }
+    return merged;
+  }
+}
+
+// src/bunqueue/dlq-rate-limit.ts
+function entryReason(entry) {
+  return String(entry.reason ?? entry.entry?.reason ?? "unknown");
+}
+function entryName(entry) {
+  const data = entry.data ?? entry.entry?.data;
+  return data?.name === undefined ? undefined : String(data.name);
+}
+
+class DlqRateLimitManager {
+  queue;
+  constructor(queue) {
+    this.queue = queue;
+  }
+  async setDlqConfig(config) {
+    await this.queue.setDlqConfig(config);
+  }
+  getDlqConfig() {
+    return this.queue.getDlqConfig();
+  }
+  async getDlq(filter) {
+    const entries = await this.queue.getDlq();
+    if (!filter)
+      return entries;
+    return entries.filter((entry) => {
+      if (filter.reason && entryReason(entry) !== filter.reason)
+        return false;
+      if (filter.jobName && entryName(entry) !== filter.jobName)
+        return false;
+      if (filter.since !== undefined) {
+        const at = Number(entry.enteredAt ?? entry.failedAt ?? 0);
+        if (at < filter.since)
+          return false;
+      }
+      return true;
+    });
+  }
+  async getDlqStats() {
+    const entries = await this.queue.getDlq();
+    const byReason = {};
+    for (const entry of entries) {
+      const reason = entryReason(entry);
+      byReason[reason] = (byReason[reason] ?? 0) + 1;
+    }
+    return { total: entries.length, byReason };
+  }
+  retryDlq(id) {
+    return this.queue.retryDlq(id);
+  }
+  purgeDlq() {
+    return this.queue.purgeDlq();
+  }
+  async setGlobalRateLimit(max, duration) {
+    await this.queue.setGlobalRateLimit(max, duration);
+  }
+  async removeGlobalRateLimit() {
+    await this.queue.removeGlobalRateLimit();
+  }
+}
+
+// src/bunqueue/rate-gate.ts
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+class RateGate {
+  max;
+  duration;
+  groupKey;
+  windows = new Map;
+  constructor(options) {
+    this.max = options.max;
+    this.duration = options.duration;
+    this.groupKey = options.groupKey;
+  }
+  groupFor(data) {
+    if (!this.groupKey)
+      return "";
+    if (typeof data === "object" && data !== null) {
+      const value = data[this.groupKey];
+      if (value !== undefined && value !== null)
+        return String(value);
+    }
+    return "";
+  }
+  async acquire(group) {
+    for (;; ) {
+      const now = Date.now();
+      const window = this.windows.get(group) ?? [];
+      const fresh = window.filter((t) => now - t < this.duration);
+      if (fresh.length < this.max) {
+        fresh.push(now);
+        this.windows.set(group, fresh);
+        return;
+      }
+      this.windows.set(group, fresh);
+      const oldest = fresh[0];
+      await sleep2(Math.max(oldest + this.duration - now, 10));
+    }
+  }
+  prune() {
+    const now = Date.now();
+    for (const [group, window] of this.windows) {
+      if (window.length === 0 || now - window[window.length - 1] >= this.duration) {
+        this.windows.delete(group);
+      }
+    }
+  }
+}
+
+// src/bunqueue/retry.ts
+function calculateBackoff(strategy, attempt, baseDelay, error, config) {
+  switch (strategy) {
+    case "fixed":
+      return baseDelay;
+    case "exponential":
+      return baseDelay * 2 ** (attempt - 1);
+    case "jitter": {
+      const exp = baseDelay * 2 ** (attempt - 1);
+      return Math.floor(exp * (0.5 + Math.random()));
+    }
+    case "fibonacci": {
+      let a = 1;
+      let b = 1;
+      for (let i = 0;i < attempt - 1; i++) {
+        const next = a + b;
+        a = b;
+        b = next;
+      }
+      return baseDelay * b;
+    }
+    case "custom":
+      if (config.customBackoff) {
+        return config.customBackoff(attempt, error);
+      }
+      return baseDelay;
+    default:
+      return baseDelay;
+  }
+}
+function executeWithRetry(fn, config) {
+  const maxAttempts = config.maxAttempts ?? 3;
+  const baseDelay = config.delay ?? 1000;
+  const strategy = config.strategy ?? "exponential";
+  const attempt = (n) => {
+    return fn().catch((err) => {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (n >= maxAttempts)
+        throw error;
+      if (config.retryIf && !config.retryIf(error, n))
+        throw error;
+      const delay = calculateBackoff(strategy, n, baseDelay, error, config);
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(attempt(n + 1));
+        }, delay);
+      });
+    });
+  };
+  return attempt(1);
+}
+
+// src/bunqueue/triggers.ts
+class TriggerManager {
+  rules = [];
+  active = false;
+  queue;
+  worker;
+  constructor(queue, worker) {
+    this.queue = queue;
+    this.worker = worker;
+  }
+  add(rule) {
+    this.rules.push(rule);
+    this.ensureActive();
+  }
+  ensureActive() {
+    if (this.active)
+      return;
+    this.active = true;
+    this.worker.on("completed", (job, result) => {
+      this.fire("completed", job, result);
+    });
+    this.worker.on("failed", (job, error) => {
+      this.fire("failed", job, error);
+    });
+  }
+  fire(event, job, resultOrError) {
+    for (const rule of this.rules) {
+      if (rule.on !== job.name)
+        continue;
+      if ((rule.event ?? "completed") !== event)
+        continue;
+      if (rule.condition && !rule.condition(resultOrError, job))
+        continue;
+      const data = rule.data(resultOrError, job);
+      this.queue.add(rule.create, data, rule.opts);
+    }
+  }
+}
+
+// src/bunqueue/ttl.ts
+class TtlChecker {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getTtl(jobName) {
+    return this.config.perName?.[jobName] ?? this.config.defaultTtl ?? 0;
+  }
+  isExpired(jobName, jobTimestamp) {
+    const ttl = this.getTtl(jobName);
+    if (ttl <= 0)
+      return false;
+    return Date.now() - jobTimestamp > ttl;
+  }
+  setDefaultTtl(ttlMs) {
+    this.config.defaultTtl = ttlMs;
+  }
+  setNameTtl(jobName, ttlMs) {
+    this.config.perName ??= {};
+    this.config.perName[jobName] = ttlMs;
+  }
+}
+
+// src/bunqueue/bunqueue.ts
+class Bunqueue {
+  name;
+  queue;
+  worker;
+  cancellation = new CancellationManager;
+  cb;
+  triggerMgr;
+  ager;
+  ttlChecker;
+  batchAcc;
+  dlqrl;
+  middlewares = [];
+  baseProcessor;
+  retryConfig;
+  merger;
+  rateGate;
+  defaultJobOptions;
+  constructor(name, opts) {
+    if (opts.embedded || opts.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);
+    if (opts.batch) {
+      this.batchAcc = new BatchAccumulator(opts.batch);
+      this.baseProcessor = this.batchAcc.buildProcessor();
+    } else {
+      this.batchAcc = null;
+      this.baseProcessor = opts.routes ? this.buildRouteProcessor(opts.routes) : opts.processor;
+    }
+    const wrappedProcessor = (job) => this.processJob(job);
+    const conn = opts.connection ?? {};
+    this.queue = new Queue(this.name, conn);
+    this.worker = new Worker(this.name, wrappedProcessor, {
+      ...conn,
+      concurrency: opts.concurrency,
+      autorun: opts.autorun,
+      heartbeatIntervalS: opts.heartbeatInterval !== undefined ? opts.heartbeatInterval / 1000 : undefined,
+      batchSize: opts.batchSize,
+      pollTimeoutMs: opts.pollTimeout
+    });
+    this.dlqrl = new DlqRateLimitManager(this.queue);
+    if (opts.dlq) {
+      this.dlqrl.setDlqConfig(opts.dlq).catch((err) => {
+        if (this.worker.listenerCount("error") > 0) {
+          this.worker.emit("error", err instanceof Error ? err : new Error(String(err)));
+        }
+      });
+    }
+    this.cb = opts.circuitBreaker ? new WorkerCircuitBreaker(opts.circuitBreaker, this.worker) : null;
+    this.triggerMgr = new TriggerManager(this.queue, this.worker);
+    this.ager = opts.priorityAging ? new PriorityAger(opts.priorityAging, this.queue) : null;
+    this.ager?.start();
+  }
+  buildRouteProcessor(routes) {
+    const routeMap = routes;
+    return (job) => {
+      const handler = routeMap[job.name ?? ""];
+      if (!handler)
+        throw new Error(`No route for job "${job.name}" in queue "${this.name}"`);
+      return handler(job);
+    };
+  }
+  buildDefaultJobOptions(opts) {
+    const base = { ...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;
+  }
+  async processJob(job) {
+    if (this.rateGate) {
+      this.rateGate.prune();
+      await this.rateGate.acquire(this.rateGate.groupFor(job.data));
+    }
+    if (this.cb?.isOpen()) {
+      throw new Error("Circuit breaker is open");
+    }
+    if (this.ttlChecker?.isExpired(job.name ?? "", job.timestamp)) {
+      throw new Error(`Job expired (age: ${Date.now() - job.timestamp}ms)`);
+    }
+    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) => {
+      this.cb?.onFailure();
+      this.cancellation.unregister(job.id);
+      throw err;
+    });
+  }
+  runMiddlewareChain(job, ac) {
+    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 = () => {
+      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();
+  }
+  use(middleware) {
+    this.middlewares.push(middleware);
+    return this;
+  }
+  add(name, data, opts) {
+    const merged = { ...this.defaultJobOptions, ...opts };
+    return this.queue.add(name, data, this.merger.merge(name, merged, data));
+  }
+  addBulk(jobs) {
+    return this.queue.addBulk(jobs.map((j) => ({
+      ...j,
+      opts: this.merger.merge(j.name, { ...this.defaultJobOptions, ...j.opts }, j.data)
+    })));
+  }
+  getJob(id) {
+    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();
+  }
+}
+Object.assign(Bunqueue.prototype, bunqueueApi);
+// src/flow-commit.ts
+function validateFlowSnapshots(jobs, snapshots) {
+  if (!Array.isArray(snapshots) || snapshots.length !== jobs.length) {
+    throw new Error("Invalid PUSHF response: committed job snapshots are missing");
+  }
+  const expected = new Map(jobs.map((job) => [job.id, job.queue]));
+  const byId = new Map;
+  for (const value of snapshots) {
+    if (!value || typeof value !== "object") {
+      throw new Error("Invalid PUSHF response: job snapshot is invalid");
+    }
+    const snapshot = value;
+    if (typeof snapshot.id !== "string" || !expected.has(snapshot.id)) {
+      throw new Error("Invalid PUSHF response: committed job IDs do not match the request");
+    }
+    if (byId.has(snapshot.id) || snapshot.queue !== expected.get(snapshot.id)) {
+      throw new Error("Invalid PUSHF response: committed job IDs do not match the request");
+    }
+    byId.set(snapshot.id, snapshot);
+  }
+  return byId;
+}
+async function commitFlow(connection, jobs) {
+  if (jobs.length === 0)
+    return new Map;
+  const response = await connection.call({
+    cmd: "PUSHF",
+    jobs
+  });
+  return validateFlowSnapshots(jobs, response.data?.jobs);
+}
+
+// src/flow-plan.ts
+import { randomUUID } from "node:crypto";
+var MAX_FLOW_DEPTH = 100;
+var MAX_FLOW_JOBS = 1e4;
+var QUEUE_RE = /^[a-zA-Z0-9_\-.:]+$/;
+function assertNameAndQueue(name, queueName, depth) {
+  if (typeof name !== "string" || name.length === 0 || name.length > 256) {
+    throw new Error("flow job name must be a non-empty string of at most 256 characters");
+  }
+  if (typeof queueName !== "string" || queueName.length === 0 || queueName.length > 256 || !QUEUE_RE.test(queueName)) {
+    throw new Error("flow queueName is invalid");
+  }
+  if (depth > MAX_FLOW_DEPTH) {
+    throw new Error(`flow exceeds the ${MAX_FLOW_DEPTH} level depth limit`);
+  }
+}
+function assertAtomicOptions(opts) {
+  if (opts.repeat !== undefined)
+    throw new Error("repeat is not supported inside an atomic flow");
+  if (opts.deduplication !== undefined) {
+    throw new Error("deduplication is not supported inside an atomic flow");
+  }
+  if (opts.debounce !== undefined) {
+    throw new Error("debounce is not supported inside an atomic flow");
+  }
+  if (opts.parentId !== undefined || opts.dependsOn !== undefined || opts.childrenIds !== undefined) {
+    throw new Error("flow topology options are owned by FlowProducer");
+  }
+}
+function assertUserData(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data))
+    return;
+  for (const key of Object.keys(data)) {
+    if (key === "name" || key.startsWith("__")) {
+      throw new Error(`flow job data key is reserved: ${key}`);
+    }
+  }
+}
+function flowData(name, data, internal = {}) {
+  assertUserData(data);
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    return { ...data, name, ...internal };
+  }
+  return data === undefined || data === null ? { name, ...internal } : { name, payload: data, ...internal };
+}
+function flowInput(data, opts, links = {}) {
+  assertAtomicOptions(opts);
+  const mapped = { ...wireJobOptions(opts) };
+  delete mapped.jobId;
+  delete mapped.parentId;
+  delete mapped.dependsOn;
+  delete mapped.childrenIds;
+  return compact2({
+    data,
+    ...mapped,
+    customId: opts.jobId,
+    parentId: links.parentId,
+    dependsOn: links.dependsOn,
+    childrenIds: links.childrenIds
+  });
+}
+function allocateFlowId(opts, ids, idFactory) {
+  const id = opts.jobId ?? idFactory();
+  if (typeof id !== "string" || id.length === 0 || id.length > 1024 || id.includes(":")) {
+    throw new Error("flow jobId must be non-empty and cannot contain a colon");
+  }
+  if (ids.has(id))
+    throw new Error(`duplicate flow job id: ${id}`);
+  ids.add(id);
+  return id;
+}
+function visit(node, parent, depth, options, state) {
+  if (!node || typeof node !== "object")
+    throw new Error("flow node must be an object");
+  assertNameAndQueue(node.name, node.queueName, depth);
+  if (node.children !== undefined && !Array.isArray(node.children)) {
+    throw new Error("flow children must be an array");
+  }
+  if (state.seen.has(node))
+    throw new Error("flow contains a cycle or shared node");
+  state.seen.add(node);
+  state.count += 1;
+  if (state.count > MAX_FLOW_JOBS) {
+    throw new Error(`flow exceeds the ${MAX_FLOW_JOBS} job limit`);
+  }
+  const defaults = options?.queuesOptions?.[node.queueName];
+  const opts = defaults ? { ...defaults, ...node.opts } : node.opts ?? {};
+  assertAtomicOptions(opts);
+  const id = allocateFlowId(opts, state.ids, state.idFactory);
+  const children = (node.children ?? []).map((child) => visit(child, { id, queue: node.queueName }, depth + 1, options, state));
+  const childIds = children.map((child) => child.id);
+  const internal = {};
+  if (parent) {
+    internal.__parentId = parent.id;
+    internal.__parentQueue = parent.queue;
+  }
+  if (childIds.length > 0)
+    internal.__childrenIds = childIds;
+  const data = flowData(node.name, node.data, internal);
+  state.jobs.push({
+    id,
+    queue: node.queueName,
+    input: flowInput(data, opts, {
+      parentId: parent?.id,
+      dependsOn: childIds.length > 0 ? childIds : undefined,
+      childrenIds: childIds.length > 0 ? childIds : undefined
+    })
+  });
+  return {
+    id,
+    name: node.name,
+    queueName: node.queueName,
+    data: node.data,
+    children: children.length > 0 ? children : undefined
+  };
+}
+function planFlows(flows, options, idFactory = randomUUID) {
+  for (const defaults of Object.values(options?.queuesOptions ?? {})) {
+    if (defaults.jobId !== undefined) {
+      throw new Error("jobId cannot be a queue default");
+    }
+  }
+  const state = {
+    ids: new Set,
+    seen: new WeakSet,
+    jobs: [],
+    idFactory,
+    count: 0
+  };
+  const roots = flows.map((flow) => visit(flow, undefined, 0, options, state));
+  return { jobs: state.jobs, roots };
+}
+
+// src/flow-plan-legacy.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var MAX_FLOW_JOBS2 = 1e4;
+var QUEUE_RE2 = /^[a-zA-Z0-9_\-.:]+$/;
+function allocateSteps(steps, ids, idFactory) {
+  if (steps.length > MAX_FLOW_JOBS2) {
+    throw new Error(`flow exceeds the ${MAX_FLOW_JOBS2} job limit`);
+  }
+  return steps.map((step) => {
+    if (!step || typeof step !== "object")
+      throw new Error("flow step must be an object");
+    if (typeof step.name !== "string" || !step.name || step.name.length > 256) {
+      throw new Error("flow job name must be a non-empty string of at most 256 characters");
+    }
+    if (typeof step.queueName !== "string" || !step.queueName || step.queueName.length > 256 || !QUEUE_RE2.test(step.queueName)) {
+      throw new Error("flow queueName is invalid");
+    }
+    const children = step.children;
+    if (children !== undefined && !Array.isArray(children)) {
+      throw new Error("flow children must be an array");
+    }
+    if ((children?.length ?? 0) > 0) {
+      throw new Error("nested children are not supported by this flow method");
+    }
+    return allocateFlowId(step.opts ?? {}, ids, idFactory);
+  });
+}
+function planChain(steps, idFactory = randomUUID2) {
+  const ids = allocateSteps(steps, new Set, idFactory);
+  const jobs = steps.map((step, index) => {
+    const dependency = index > 0 ? ids[index - 1] : undefined;
+    const data = flowData(step.name, step.data, {
+      __flowParentId: dependency ?? null
+    });
+    return {
+      id: ids[index],
+      queue: step.queueName,
+      input: flowInput(data, step.opts ?? {}, {
+        dependsOn: dependency ? [dependency] : undefined
+      })
+    };
+  });
+  return { jobs, ids };
+}
+function planBulkThen(parallel, final, idFactory = randomUUID2) {
+  if (parallel.length >= MAX_FLOW_JOBS2) {
+    throw new Error(`flow exceeds the ${MAX_FLOW_JOBS2} job limit`);
+  }
+  const ids = new Set;
+  const parallelIds = allocateSteps(parallel, ids, idFactory);
+  const [finalId] = allocateSteps([final], ids, idFactory);
+  const parallelJobs = parallel.map((step, index) => ({
+    id: parallelIds[index],
+    queue: step.queueName,
+    input: flowInput(flowData(step.name, step.data, {
+      __parentId: finalId,
+      __parentQueue: final.queueName
+    }), step.opts ?? {}, { parentId: finalId })
+  }));
+  const finalJob = {
+    id: finalId,
+    queue: final.queueName,
+    input: flowInput(flowData(final.name, final.data, {
+      __flowParentIds: parallelIds,
+      __childrenIds: parallelIds
+    }), final.opts ?? {}, {
+      dependsOn: parallelIds.length > 0 ? parallelIds : undefined,
+      childrenIds: parallelIds.length > 0 ? parallelIds : undefined
+    })
+  };
+  return { jobs: [...parallelJobs, finalJob], parallelIds, finalId };
+}
+
+// src/flow.ts
+class FlowProducer {
+  connection;
+  ownsConnection;
+  constructor(opts = {}) {
+    this.connection = opts.connection ?? new Connection2({
+      host: opts.host,
+      port: opts.port,
+      token: opts.token,
+      tls: opts.tls,
+      logger: opts.logger,
+      onTelemetry: opts.onTelemetry
+    });
+    this.ownsConnection = opts.connection === undefined;
+  }
+  async add(flow, options) {
+    const plan = planFlows([flow], options);
+    const snapshots = await commitFlow(this.connection, plan.jobs);
+    return this.buildNode(plan.roots[0], snapshots);
+  }
+  async addBulk(flows) {
+    const plan = planFlows(flows);
+    const snapshots = await commitFlow(this.connection, plan.jobs);
+    return plan.roots.map((root) => this.buildNode(root, snapshots));
+  }
+  getFlow(opts) {
+    return this.fetchNode(opts.id, opts.depth ?? Number.POSITIVE_INFINITY, opts.maxChildren, new Set);
+  }
+  async addChain(steps) {
+    if (steps.length === 0)
+      return { jobIds: [] };
+    const plan = planChain(steps);
+    await commitFlow(this.connection, plan.jobs);
+    return { jobIds: plan.ids };
+  }
+  async addBulkThen(parallel, final) {
+    const plan = planBulkThen(parallel, final);
+    await commitFlow(this.connection, plan.jobs);
+    return { parallelIds: plan.parallelIds, finalId: plan.finalId };
+  }
+  close() {
+    if (this.ownsConnection)
+      this.connection.close();
+  }
+  buildNode(node, snapshots) {
+    const snapshot = snapshots.get(node.id);
+    if (!snapshot)
+      throw new Error(`Committed flow snapshot missing for ${node.id}`);
+    const children = node.children?.map((child) => this.buildNode(child, snapshots));
+    return {
+      job: new Job(snapshot, this.connection),
+      children: children && children.length > 0 ? children : undefined
+    };
+  }
+  async fetchNode(id, depth, maxChildren, visited) {
+    if (visited.has(id))
+      return null;
+    visited.add(id);
+    let response;
+    try {
+      response = await this.connection.call({ cmd: "GetJob", id });
+    } catch (err) {
+      if (err instanceof CommandError2 && /not found/i.test(err.message))
+        return null;
+      throw err;
+    }
+    const raw = response.job;
+    if (!raw)
+      return null;
+    const job = new Job(raw, this.connection);
+    if (depth <= 0 || job.childrenIds.length === 0)
+      return { job };
+    const limit = maxChildren ?? job.childrenIds.length;
+    const children = [];
+    for (const childId of job.childrenIds.slice(0, limit)) {
+      const child = await this.fetchNode(childId, depth - 1, maxChildren, visited);
+      if (child)
+        children.push(child);
+    }
+    return { job, children: children.length > 0 ? children : undefined };
+  }
+}
+
+// src/legacy.ts
+var __version__ = "0.2.0";
+export {
+  AuthError2 as AuthError,
+  Bunqueue,
+  BunqueueError2 as BunqueueError,
+  CommandError2 as CommandError,
+  CommandTimeoutError2 as CommandTimeoutError,
+  Connection2 as Connection,
+  ConnectionClosedError2 as ConnectionClosedError,
+  ConnectionPool2 as ConnectionPool,
+  FlowProducer,
+  Job,
+  MAX_FRAME_SIZE2 as MAX_FRAME_SIZE,
+  PROTOCOL_VERSION2 as PROTOCOL_VERSION,
+  Queue,
+  SerializationError2 as SerializationError,
+  UnrecoverableError2 as UnrecoverableError,
+  Worker,
+  __version__,
+  consoleLogger2 as consoleLogger,
+  noopLogger2 as noopLogger
+};