qwerk 0.1.0

package/dist/index.js

@@ -0,0 +1,1739 @@
+// src/backoff.ts
+var DEFAULT_MAX_DELAY = 30000;
+function calculateBackoff(options, attempt) {
+  const maxDelay = options.maxDelay ?? DEFAULT_MAX_DELAY;
+  let delay;
+  switch (options.type) {
+    case "exponential":
+      delay = Math.pow(2, attempt) * options.delay;
+      break;
+    case "linear":
+      delay = (attempt + 1) * options.delay;
+      break;
+    case "fixed":
+      delay = options.delay;
+      break;
+    default:
+      delay = options.delay;
+  }
+  const jitter = delay * 0.1 * (Math.random() * 2 - 1);
+  delay = Math.floor(delay + jitter);
+  return Math.min(delay, maxDelay);
+}
+var defaultBackoff = {
+  type: "exponential",
+  delay: 1000,
+  maxDelay: DEFAULT_MAX_DELAY
+};
+
+// src/cron.ts
+var MONTH_NAMES = {
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  may: 5,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+var DAY_NAMES = {
+  sun: 0,
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6
+};
+var FIELD_CONFIG = {
+  minute: { min: 0, max: 59, names: null },
+  hour: { min: 0, max: 23, names: null },
+  dayOfMonth: { min: 1, max: 31, names: null },
+  month: { min: 1, max: 12, names: MONTH_NAMES },
+  dayOfWeek: { min: 0, max: 6, names: DAY_NAMES }
+};
+function parseValue(value, names) {
+  if (names) {
+    const lower = value.toLowerCase();
+    if (lower in names) {
+      return names[lower];
+    }
+  }
+  const num = parseInt(value, 10);
+  if (Number.isNaN(num)) {
+    throw new Error(`Invalid value: "${value}"`);
+  }
+  return num;
+}
+function validateRange(value, min, max, field) {
+  if (value < min || value > max) {
+    throw new Error(`${field} value ${value} out of range [${min}-${max}]`);
+  }
+}
+function parseField(field, fieldName) {
+  const config = FIELD_CONFIG[fieldName];
+  const { min, max, names } = config;
+  const validationMax = fieldName === "dayOfWeek" ? 7 : max;
+  const values = new Set;
+  let isWildcard = false;
+  const addValue = (v) => {
+    values.add(fieldName === "dayOfWeek" && v === 7 ? 0 : v);
+  };
+  const parts = field.split(",");
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (trimmed === "*") {
+      isWildcard = true;
+      for (let i = min;i <= max; i++) {
+        values.add(i);
+      }
+    } else if (trimmed.includes("/")) {
+      const slashIndex = trimmed.indexOf("/");
+      const range = trimmed.slice(0, slashIndex);
+      const stepStr = trimmed.slice(slashIndex + 1);
+      const step = parseInt(stepStr, 10);
+      if (Number.isNaN(step) || step <= 0) {
+        throw new Error(`Invalid step value: "${stepStr}"`);
+      }
+      let start = min;
+      let end = max;
+      if (range === "*") {
+        isWildcard = true;
+      } else if (range.includes("-")) {
+        const dashIndex = range.indexOf("-");
+        start = parseValue(range.slice(0, dashIndex), names);
+        end = parseValue(range.slice(dashIndex + 1), names);
+        validateRange(start, min, validationMax, fieldName);
+        validateRange(end, min, validationMax, fieldName);
+        if (start > end) {
+          throw new Error(`Invalid range: ${start}-${end}`);
+        }
+      } else {
+        start = parseValue(range, names);
+        validateRange(start, min, validationMax, fieldName);
+      }
+      for (let i = start;i <= end; i += step) {
+        addValue(i);
+      }
+    } else if (trimmed.includes("-")) {
+      const dashIndex = trimmed.indexOf("-");
+      const start = parseValue(trimmed.slice(0, dashIndex), names);
+      const end = parseValue(trimmed.slice(dashIndex + 1), names);
+      validateRange(start, min, validationMax, fieldName);
+      validateRange(end, min, validationMax, fieldName);
+      if (start > end) {
+        throw new Error(`Invalid range: ${start}-${end}`);
+      }
+      for (let i = start;i <= end; i++) {
+        addValue(i);
+      }
+    } else {
+      const value = parseValue(trimmed, names);
+      validateRange(value, min, validationMax, fieldName);
+      addValue(value);
+    }
+  }
+  if (values.size === 0) {
+    throw new Error(`No valid values for field: ${fieldName}`);
+  }
+  return { values, isWildcard };
+}
+function parseCron(expression) {
+  const trimmed = expression.trim();
+  if (!trimmed) {
+    throw new Error("Empty cron expression");
+  }
+  const fields = trimmed.split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(`Invalid cron expression: expected 5 fields, got ${fields.length}`);
+  }
+  return {
+    minute: parseField(fields[0], "minute"),
+    hour: parseField(fields[1], "hour"),
+    dayOfMonth: parseField(fields[2], "dayOfMonth"),
+    month: parseField(fields[3], "month"),
+    dayOfWeek: parseField(fields[4], "dayOfWeek")
+  };
+}
+function getNextCronTime(expression, after = new Date) {
+  const cron = parseCron(expression);
+  const next = new Date(after);
+  next.setSeconds(0, 0);
+  next.setMinutes(next.getMinutes() + 1);
+  const maxIterations = 4 * 366 * 24 * 60;
+  let iterations = 0;
+  while (iterations < maxIterations) {
+    iterations++;
+    const minute = next.getMinutes();
+    const hour = next.getHours();
+    const dayOfMonth = next.getDate();
+    const month = next.getMonth() + 1;
+    const dayOfWeek = next.getDay();
+    if (!cron.month.values.has(month)) {
+      next.setMonth(next.getMonth() + 1, 1);
+      next.setHours(0, 0, 0, 0);
+      continue;
+    }
+    const dayOfMonthMatch = cron.dayOfMonth.values.has(dayOfMonth);
+    const dayOfWeekMatch = cron.dayOfWeek.values.has(dayOfWeek);
+    let dayMatches;
+    if (cron.dayOfMonth.isWildcard && cron.dayOfWeek.isWildcard) {
+      dayMatches = true;
+    } else if (cron.dayOfMonth.isWildcard) {
+      dayMatches = dayOfWeekMatch;
+    } else if (cron.dayOfWeek.isWildcard) {
+      dayMatches = dayOfMonthMatch;
+    } else {
+      dayMatches = dayOfMonthMatch || dayOfWeekMatch;
+    }
+    if (!dayMatches) {
+      next.setDate(next.getDate() + 1);
+      next.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (!cron.hour.values.has(hour)) {
+      next.setHours(next.getHours() + 1, 0, 0, 0);
+      continue;
+    }
+    if (!cron.minute.values.has(minute)) {
+      next.setMinutes(next.getMinutes() + 1, 0, 0);
+      continue;
+    }
+    return next;
+  }
+  return null;
+}
+
+// src/job-handle.ts
+class JobHandle {
+  queue;
+  name;
+  defaults;
+  events = new Map;
+  onceEvents = new Map;
+  handler = null;
+  constructor(queue, name, defaults = {}) {
+    this.queue = queue;
+    this.name = name;
+    this.defaults = defaults;
+  }
+  process(handler) {
+    this.handler = handler;
+    this.queue.processJob(this.name, async (job, ctx) => {
+      return handler(job.data, ctx);
+    });
+    return this;
+  }
+  async add(data, options = {}) {
+    const mergedOptions = {
+      maxAttempts: options.maxAttempts ?? this.defaults.maxAttempts,
+      timeout: options.timeout ?? this.defaults.timeout,
+      backoff: options.backoff ?? this.defaults.backoff,
+      priority: options.priority ?? this.defaults.priority,
+      delay: options.delay,
+      jobId: options.jobId,
+      repeat: options.repeat
+    };
+    const job = await this.queue.addJob(this.name, data, mergedOptions);
+    return job;
+  }
+  async addBulk(items) {
+    const jobs = items.map(({ data, options = {} }) => ({
+      name: this.name,
+      data,
+      options: {
+        maxAttempts: options.maxAttempts ?? this.defaults.maxAttempts,
+        timeout: options.timeout ?? this.defaults.timeout,
+        backoff: options.backoff ?? this.defaults.backoff,
+        priority: options.priority ?? this.defaults.priority,
+        delay: options.delay,
+        jobId: options.jobId,
+        repeat: options.repeat
+      }
+    }));
+    const result = await this.queue.addJobBulk(jobs);
+    return result;
+  }
+  on(event, callback) {
+    if (!this.events.has(event)) {
+      this.events.set(event, new Set);
+    }
+    this.events.get(event).add(callback);
+    this.queue.subscribeToEvent(event, this.name, callback);
+    return this;
+  }
+  once(event, callback) {
+    if (!this.onceEvents.has(event)) {
+      this.onceEvents.set(event, new Set);
+    }
+    const wrappedCallback = (...args) => {
+      this.onceEvents.get(event)?.delete(wrappedCallback);
+      this.queue.unsubscribeFromEvent(event, this.name, wrappedCallback);
+      callback(...args);
+    };
+    this.onceEvents.get(event).add(wrappedCallback);
+    this.queue.subscribeToEvent(event, this.name, wrappedCallback);
+    return this;
+  }
+  off(event, callback) {
+    this.events.get(event)?.delete(callback);
+    this.queue.unsubscribeFromEvent(event, this.name, callback);
+    return this;
+  }
+}
+
+// src/types.ts
+var consoleLogger = {
+  debug: (msg, ...args) => console.debug(`[jobqueue] ${msg}`, ...args),
+  info: (msg, ...args) => console.info(`[jobqueue] ${msg}`, ...args),
+  warn: (msg, ...args) => console.warn(`[jobqueue] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[jobqueue] ${msg}`, ...args)
+};
+var silentLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+
+// src/queue.ts
+var DEFAULT_VISIBILITY_TIMEOUT = 30000;
+var DEFAULT_STALLED_INTERVAL = 5000;
+var DEFAULT_JOB_TIMEOUT = 30000;
+
+class Queue {
+  backend;
+  handlers = new Map;
+  events = new Map;
+  onceEvents = new Map;
+  jobEvents = new Map;
+  running = false;
+  processing = 0;
+  pollInterval;
+  concurrency;
+  visibilityTimeout;
+  stalledInterval;
+  pollTimer = null;
+  stalledTimer = null;
+  activeJobs = new Map;
+  shuttingDown = false;
+  shutdownResolve = null;
+  rateLimit = null;
+  rateLimitTokens = 0;
+  rateLimitLastRefill = 0;
+  logger;
+  maxPayloadSize = null;
+  maxQueueSize = null;
+  metricsData = {
+    completed: 0,
+    totalFailed: 0,
+    totalProcessingTime: 0,
+    jobCount: 0,
+    recentCompletions: []
+  };
+  constructor(backend, options = {}) {
+    this.backend = backend;
+    this.pollInterval = options.pollInterval ?? 1000;
+    this.concurrency = options.concurrency ?? 1;
+    this.visibilityTimeout = options.visibilityTimeout ?? DEFAULT_VISIBILITY_TIMEOUT;
+    this.stalledInterval = options.stalledInterval ?? DEFAULT_STALLED_INTERVAL;
+    this.logger = options.logger ?? consoleLogger;
+    this.maxPayloadSize = options.maxPayloadSize ?? null;
+    this.maxQueueSize = options.maxQueueSize ?? null;
+    if (options.rateLimit) {
+      this.rateLimit = {
+        max: options.rateLimit.max,
+        duration: options.rateLimit.duration ?? 1000
+      };
+      this.rateLimitTokens = this.rateLimit.max;
+      this.rateLimitLastRefill = Date.now();
+    }
+  }
+  async add(name, data, options = {}) {
+    if (this.maxPayloadSize !== null) {
+      const payloadSize = JSON.stringify(data).length;
+      if (payloadSize > this.maxPayloadSize) {
+        throw new Error(`Job payload size (${payloadSize} bytes) exceeds limit (${this.maxPayloadSize} bytes)`);
+      }
+    }
+    if (this.maxQueueSize !== null) {
+      const currentSize = await this.backend.size();
+      if (currentSize >= this.maxQueueSize) {
+        throw new Error(`Queue size (${currentSize}) has reached limit (${this.maxQueueSize})`);
+      }
+    }
+    const repeat = options.repeat ? {
+      ...options.repeat,
+      key: options.repeat.key ?? `${name}:${options.repeat.cron ?? options.repeat.every}`,
+      count: 0
+    } : undefined;
+    const job = {
+      id: options.jobId ?? crypto.randomUUID(),
+      name,
+      data,
+      attempts: 0,
+      maxAttempts: options.maxAttempts ?? 3,
+      createdAt: Date.now(),
+      scheduledAt: Date.now() + (options.delay ?? 0),
+      backoff: options.backoff ?? defaultBackoff,
+      priority: options.priority ?? 0,
+      timeout: options.timeout ?? DEFAULT_JOB_TIMEOUT,
+      repeat
+    };
+    const added = await this.backend.push(job);
+    if (added) {
+      this.logger.debug(`Job added: ${job.id} (${name})`);
+      this.emit("added", job);
+    }
+    return added ? job : null;
+  }
+  async addBulk(jobs) {
+    let availableSlots = Infinity;
+    if (this.maxQueueSize !== null) {
+      const currentSize = await this.backend.size();
+      availableSlots = Math.max(0, this.maxQueueSize - currentSize);
+      if (availableSlots === 0) {
+        this.logger.warn("Queue is full, rejecting bulk add");
+        return [];
+      }
+    }
+    const jobsToAdd = [];
+    const skippedPayload = [];
+    for (let i = 0;i < jobs.length && jobsToAdd.length < availableSlots; i++) {
+      const { name, data, options = {} } = jobs[i];
+      if (this.maxPayloadSize !== null) {
+        const payloadSize = JSON.stringify(data).length;
+        if (payloadSize > this.maxPayloadSize) {
+          skippedPayload.push(i);
+          continue;
+        }
+      }
+      const repeat = options.repeat ? {
+        ...options.repeat,
+        key: options.repeat.key ?? `${name}:${options.repeat.cron ?? options.repeat.every}`,
+        count: 0
+      } : undefined;
+      jobsToAdd.push({
+        id: options.jobId ?? crypto.randomUUID(),
+        name,
+        data,
+        attempts: 0,
+        maxAttempts: options.maxAttempts ?? 3,
+        createdAt: Date.now(),
+        scheduledAt: Date.now() + (options.delay ?? 0),
+        backoff: options.backoff ?? defaultBackoff,
+        priority: options.priority ?? 0,
+        timeout: options.timeout ?? DEFAULT_JOB_TIMEOUT,
+        repeat
+      });
+    }
+    if (skippedPayload.length > 0) {
+      this.logger.warn(`Skipped ${skippedPayload.length} jobs due to payload size limit`);
+    }
+    if (jobsToAdd.length === 0) {
+      return [];
+    }
+    const addedJobs = [];
+    for (const job of jobsToAdd) {
+      const added = await this.backend.push(job);
+      if (added) {
+        addedJobs.push(job);
+        this.emit("added", job);
+      }
+    }
+    this.logger.debug(`Bulk added ${addedJobs.length}/${jobs.length} jobs`);
+    return addedJobs;
+  }
+  define(name, defaults = {}) {
+    return new JobHandle(this, name, defaults);
+  }
+  addJob(name, data, options) {
+    return this.add(name, data, options);
+  }
+  addJobBulk(jobs) {
+    return this.addBulk(jobs);
+  }
+  processJob(name, handler) {
+    this.handlers.set(name, handler);
+  }
+  subscribeToEvent(event, name, callback) {
+    if (!this.jobEvents.has(event)) {
+      this.jobEvents.set(event, new Map);
+    }
+    const eventMap = this.jobEvents.get(event);
+    if (!eventMap.has(name)) {
+      eventMap.set(name, new Set);
+    }
+    eventMap.get(name).add(callback);
+  }
+  unsubscribeFromEvent(event, name, callback) {
+    this.jobEvents.get(event)?.get(name)?.delete(callback);
+  }
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.shuttingDown = false;
+    this.backend.subscribe(() => void this.tick());
+    this.tick();
+    this.startStalledChecker();
+    this.logger.info("Queue started");
+  }
+  async stop(timeout = 30000) {
+    if (!this.running)
+      return;
+    this.logger.info(`Stopping queue (waiting up to ${timeout}ms for ${this.processing} in-flight jobs)`);
+    this.shuttingDown = true;
+    this.running = false;
+    this.backend.unsubscribe();
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.stalledTimer) {
+      clearInterval(this.stalledTimer);
+      this.stalledTimer = null;
+    }
+    if (this.processing > 0) {
+      await Promise.race([
+        new Promise((resolve) => {
+          this.shutdownResolve = resolve;
+        }),
+        new Promise((resolve) => setTimeout(resolve, timeout))
+      ]);
+    }
+    const abortedCount = this.activeJobs.size;
+    for (const [, { controller }] of this.activeJobs) {
+      controller.abort();
+    }
+    if (abortedCount > 0) {
+      this.logger.warn(`Force aborted ${abortedCount} jobs after timeout`);
+    }
+    this.activeJobs.clear();
+    this.shuttingDown = false;
+    this.shutdownResolve = null;
+    this.logger.info("Queue stopped");
+  }
+  pause() {
+    this.running = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  resume() {
+    if (this.running || this.shuttingDown)
+      return;
+    this.running = true;
+    this.tick();
+  }
+  async drain() {
+    while (this.processing > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+  }
+  on(event, callback) {
+    if (!this.events.has(event)) {
+      this.events.set(event, new Set);
+    }
+    this.events.get(event).add(callback);
+    return this;
+  }
+  once(event, callback) {
+    if (!this.onceEvents.has(event)) {
+      this.onceEvents.set(event, new Set);
+    }
+    this.onceEvents.get(event).add(callback);
+    return this;
+  }
+  off(event, callback) {
+    this.events.get(event)?.delete(callback);
+    this.onceEvents.get(event)?.delete(callback);
+    return this;
+  }
+  async size() {
+    return this.backend.size();
+  }
+  async activeCount() {
+    return this.backend.activeCount();
+  }
+  async failedCount() {
+    return this.backend.failedCount();
+  }
+  async getFailed(limit) {
+    return this.backend.getFailed(limit);
+  }
+  async getCompleted(jobId) {
+    return this.backend.getCompleted(jobId);
+  }
+  async completedCount() {
+    return this.backend.completedCount();
+  }
+  async getCompletedJobs(limit) {
+    return this.backend.getCompletedJobs(limit);
+  }
+  async retryFailed(jobId) {
+    return this.backend.retryFailed(jobId);
+  }
+  async remove(jobId) {
+    return this.backend.remove(jobId);
+  }
+  async clear() {
+    return this.backend.clear();
+  }
+  async close() {
+    await this.stop();
+    if (this.backend.close) {
+      await this.backend.close();
+    }
+  }
+  async getMetrics() {
+    const now = Date.now();
+    this.metricsData.recentCompletions = this.metricsData.recentCompletions.filter((t) => now - t < 60000);
+    const throughput = this.metricsData.recentCompletions.length > 0 ? this.metricsData.recentCompletions.length / 60 : 0;
+    return {
+      waiting: await this.backend.size(),
+      active: await this.backend.activeCount(),
+      failed: await this.backend.failedCount(),
+      completed: this.metricsData.completed,
+      totalFailed: this.metricsData.totalFailed,
+      totalProcessingTime: this.metricsData.totalProcessingTime,
+      avgProcessingTime: this.metricsData.jobCount > 0 ? this.metricsData.totalProcessingTime / this.metricsData.jobCount : 0,
+      throughput
+    };
+  }
+  startStalledChecker() {
+    this.stalledTimer = setInterval(() => {
+      this.checkStalled();
+    }, this.stalledInterval);
+  }
+  async checkStalled() {
+    const stalledJobs = await this.backend.getStalled();
+    for (const job of stalledJobs) {
+      this.logger.warn(`Job stalled: ${job.id} (${job.name})`);
+      this.emit("stalled", job);
+      if (job.attempts + 1 >= job.maxAttempts) {
+        const err = new Error("Job stalled and exceeded max attempts");
+        await this.backend.fail(job, err);
+        this.logger.error(`Stalled job failed permanently: ${job.id} (${job.name})`);
+        this.emit("failed", job, err);
+        this.metricsData.totalFailed++;
+      } else {
+        const delay = calculateBackoff(job.backoff, job.attempts);
+        await this.backend.nack(job, Date.now() + delay);
+        this.logger.debug(`Stalled job will retry: ${job.id} (${job.name})`);
+      }
+    }
+  }
+  checkRateLimit() {
+    if (!this.rateLimit)
+      return true;
+    const now = Date.now();
+    const elapsed = now - this.rateLimitLastRefill;
+    if (elapsed >= this.rateLimit.duration) {
+      const periods = Math.floor(elapsed / this.rateLimit.duration);
+      this.rateLimitTokens = Math.min(this.rateLimit.max, this.rateLimitTokens + periods * this.rateLimit.max);
+      this.rateLimitLastRefill = now - elapsed % this.rateLimit.duration;
+    }
+    if (this.rateLimitTokens > 0) {
+      this.rateLimitTokens--;
+      return true;
+    }
+    return false;
+  }
+  async tick() {
+    if (!this.running)
+      return;
+    while (this.processing < this.concurrency && this.running) {
+      if (!this.checkRateLimit()) {
+        break;
+      }
+      const job = await this.backend.pop(this.visibilityTimeout);
+      if (!job)
+        break;
+      this.processing++;
+      this.emit("active", job);
+      this.executeJob(job).finally(() => {
+        this.processing--;
+        if (this.shuttingDown && this.processing === 0 && this.shutdownResolve) {
+          this.shutdownResolve();
+        }
+      });
+    }
+    if (this.running && !this.pollTimer) {
+      this.pollTimer = setTimeout(() => {
+        this.pollTimer = null;
+        this.tick();
+      }, this.pollInterval);
+    }
+  }
+  async executeJob(job) {
+    const handler = this.handlers.get(job.name);
+    const startTime = Date.now();
+    if (!handler) {
+      this.logger.warn(`No handler registered for job type: ${job.name}`);
+      await this.backend.ack(job.id);
+      return;
+    }
+    const controller = new AbortController;
+    this.activeJobs.set(job.id, { controller, job });
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+    }, job.timeout);
+    const ctx = {
+      signal: controller.signal,
+      updateProgress: async (progress) => {
+        const clampedProgress = Math.max(0, Math.min(100, progress));
+        await this.backend.updateProgress(job.id, clampedProgress);
+        this.emit("progress", job, clampedProgress);
+      }
+    };
+    try {
+      const result = await Promise.race([
+        handler(job, ctx),
+        new Promise((_, reject) => {
+          controller.signal.addEventListener("abort", () => {
+            reject(new Error(`Job timed out after ${job.timeout}ms`));
+          });
+        })
+      ]);
+      clearTimeout(timeoutId);
+      await this.backend.ack(job.id, result);
+      const processingTime = Date.now() - startTime;
+      this.metricsData.completed++;
+      this.metricsData.jobCount++;
+      this.metricsData.totalProcessingTime += processingTime;
+      this.metricsData.recentCompletions.push(Date.now());
+      this.logger.debug(`Job completed: ${job.id} (${job.name}) in ${processingTime}ms`);
+      this.emit("completed", job, result);
+      if (job.repeat) {
+        await this.scheduleNextRepeat(job);
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      const err = error instanceof Error ? error : new Error(String(error));
+      const isTimeout = err.message.includes("timed out");
+      if (isTimeout) {
+        this.logger.warn(`Job timed out: ${job.id} (${job.name})`);
+        this.emit("timeout", job);
+      }
+      if (job.attempts + 1 >= job.maxAttempts) {
+        await this.backend.fail(job, err);
+        this.logger.error(`Job failed permanently: ${job.id} (${job.name})`, err.message);
+        this.emit("failed", job, err);
+        this.metricsData.totalFailed++;
+      } else {
+        const delay = calculateBackoff(job.backoff, job.attempts);
+        const nextAttemptAt = Date.now() + delay;
+        await this.backend.nack(job, nextAttemptAt);
+        this.logger.debug(`Job will retry: ${job.id} (${job.name}) attempt ${job.attempts + 1}/${job.maxAttempts}`);
+        this.emit("retry", job, err);
+      }
+    } finally {
+      this.activeJobs.delete(job.id);
+    }
+  }
+  async scheduleNextRepeat(job) {
+    if (!job.repeat)
+      return;
+    const repeat = job.repeat;
+    const newCount = (repeat.count ?? 0) + 1;
+    if (repeat.limit !== undefined && newCount >= repeat.limit) {
+      return;
+    }
+    let nextScheduledAt;
+    if (repeat.cron) {
+      const nextTime = getNextCronTime(repeat.cron);
+      if (!nextTime)
+        return;
+      nextScheduledAt = nextTime.getTime();
+    } else if (repeat.every) {
+      nextScheduledAt = Date.now() + repeat.every;
+    } else {
+      return;
+    }
+    const nextJob = {
+      ...job,
+      id: `${repeat.key}:${newCount}`,
+      attempts: 0,
+      createdAt: Date.now(),
+      scheduledAt: nextScheduledAt,
+      startedAt: undefined,
+      repeat: {
+        ...repeat,
+        count: newCount
+      }
+    };
+    await this.backend.push(nextJob);
+  }
+  emit(event, ...args) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(...args);
+        } catch (error) {
+          this.logger.error(`Error in ${event} listener:`, error);
+        }
+      }
+    }
+    const onceListeners = this.onceEvents.get(event);
+    if (onceListeners && onceListeners.size > 0) {
+      const listenersToCall = [...onceListeners];
+      onceListeners.clear();
+      for (const listener of listenersToCall) {
+        try {
+          listener(...args);
+        } catch (error) {
+          this.logger.error(`Error in ${event} once listener:`, error);
+        }
+      }
+    }
+    const job = args[0];
+    if (job?.name) {
+      const jobListeners = this.jobEvents.get(event)?.get(job.name);
+      if (jobListeners) {
+        for (const listener of jobListeners) {
+          try {
+            listener(...args);
+          } catch (error) {
+            this.logger.error(`Error in ${event} job listener for ${job.name}:`, error);
+          }
+        }
+      }
+    }
+  }
+}
+// src/backends/memory.ts
+class MinHeap {
+  compare;
+  items = [];
+  constructor(compare) {
+    this.compare = compare;
+  }
+  get size() {
+    return this.items.length;
+  }
+  push(item) {
+    this.items.push(item);
+    this.bubbleUp(this.items.length - 1);
+  }
+  pop() {
+    if (this.items.length === 0)
+      return;
+    if (this.items.length === 1)
+      return this.items.pop();
+    const result = this.items[0];
+    this.items[0] = this.items.pop();
+    this.bubbleDown(0);
+    return result;
+  }
+  peek() {
+    return this.items[0];
+  }
+  remove(predicate) {
+    const index = this.items.findIndex(predicate);
+    if (index === -1)
+      return false;
+    if (index === this.items.length - 1) {
+      this.items.pop();
+    } else {
+      this.items[index] = this.items.pop();
+      this.bubbleDown(index);
+      this.bubbleUp(index);
+    }
+    return true;
+  }
+  *values() {
+    for (const item of this.items) {
+      yield item;
+    }
+  }
+  clear() {
+    this.items = [];
+  }
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      if (this.compare(this.items[index], this.items[parentIndex]) >= 0)
+        break;
+      [this.items[index], this.items[parentIndex]] = [this.items[parentIndex], this.items[index]];
+      index = parentIndex;
+    }
+  }
+  bubbleDown(index) {
+    while (true) {
+      const leftChild = 2 * index + 1;
+      const rightChild = 2 * index + 2;
+      let smallest = index;
+      if (leftChild < this.items.length && this.compare(this.items[leftChild], this.items[smallest]) < 0) {
+        smallest = leftChild;
+      }
+      if (rightChild < this.items.length && this.compare(this.items[rightChild], this.items[smallest]) < 0) {
+        smallest = rightChild;
+      }
+      if (smallest === index)
+        break;
+      [this.items[index], this.items[smallest]] = [this.items[smallest], this.items[index]];
+      index = smallest;
+    }
+  }
+}
+
+class MemoryBackend {
+  waitingHeap = new MinHeap((a, b) => {
+    if (a.priority !== b.priority)
+      return a.priority - b.priority;
+    return a.scheduledAt - b.scheduledAt;
+  });
+  waiting = new Map;
+  active = new Map;
+  failed = new Map;
+  completed = new Map;
+  allIds = new Set;
+  progress = new Map;
+  listener = null;
+  async push(job) {
+    if (this.allIds.has(job.id)) {
+      return false;
+    }
+    this.allIds.add(job.id);
+    this.waiting.set(job.id, job);
+    this.waitingHeap.push(job);
+    this.notify();
+    return true;
+  }
+  async pushBulk(jobs) {
+    let added = 0;
+    for (const job of jobs) {
+      if (!this.allIds.has(job.id)) {
+        this.allIds.add(job.id);
+        this.waiting.set(job.id, job);
+        this.waitingHeap.push(job);
+        added++;
+      }
+    }
+    if (added > 0) {
+      this.notify();
+    }
+    return added;
+  }
+  async pop(visibilityTimeout) {
+    const now = Date.now();
+    while (this.waitingHeap.size > 0) {
+      const top = this.waitingHeap.peek();
+      if (!top)
+        break;
+      if (!this.waiting.has(top.id)) {
+        this.waitingHeap.pop();
+        continue;
+      }
+      if (top.scheduledAt > now) {
+        break;
+      }
+      this.waitingHeap.pop();
+      this.waiting.delete(top.id);
+      const activeJob = {
+        ...top,
+        startedAt: now
+      };
+      this.active.set(top.id, {
+        job: activeJob,
+        expiresAt: now + visibilityTimeout
+      });
+      return activeJob;
+    }
+    return null;
+  }
+  async ack(jobId, result) {
+    const activeJob = this.active.get(jobId);
+    this.active.delete(jobId);
+    this.progress.delete(jobId);
+    if (activeJob) {
+      this.completed.set(jobId, {
+        job: activeJob.job,
+        result,
+        completedAt: Date.now()
+      });
+    }
+  }
+  async nack(job, nextAttemptAt) {
+    this.active.delete(job.id);
+    this.progress.delete(job.id);
+    const updated = {
+      ...job,
+      scheduledAt: nextAttemptAt,
+      attempts: job.attempts + 1,
+      startedAt: undefined
+    };
+    this.waiting.set(job.id, updated);
+    this.waitingHeap.push(updated);
+    this.notify();
+  }
+  async fail(job, error) {
+    this.active.delete(job.id);
+    this.progress.delete(job.id);
+    this.failed.set(job.id, {
+      job,
+      error: error.message,
+      failedAt: Date.now()
+    });
+  }
+  async getStalled() {
+    const now = Date.now();
+    const stalled = [];
+    for (const [id, active] of this.active) {
+      if (active.expiresAt <= now) {
+        stalled.push(active.job);
+        this.active.delete(id);
+        this.progress.delete(id);
+      }
+    }
+    return stalled;
+  }
+  async updateProgress(jobId, progress) {
+    if (this.active.has(jobId)) {
+      this.progress.set(jobId, progress);
+    }
+  }
+  async getCompleted(jobId) {
+    return this.completed.get(jobId) ?? null;
+  }
+  async completedCount() {
+    return this.completed.size;
+  }
+  async getCompletedJobs(limit = 100) {
+    const result = [];
+    let count = 0;
+    const entries = [...this.completed.entries()].sort((a, b) => b[1].completedAt - a[1].completedAt);
+    for (const [, completed] of entries) {
+      if (count >= limit)
+        break;
+      result.push(completed);
+      count++;
+    }
+    return result;
+  }
+  subscribe(callback) {
+    this.listener = callback;
+  }
+  unsubscribe() {
+    this.listener = null;
+  }
+  async size() {
+    return this.waiting.size;
+  }
+  async activeCount() {
+    return this.active.size;
+  }
+  async failedCount() {
+    return this.failed.size;
+  }
+  async getFailed(limit = 100) {
+    const result = [];
+    let count = 0;
+    for (const failed of this.failed.values()) {
+      if (count >= limit)
+        break;
+      result.push(failed);
+      count++;
+    }
+    return result;
+  }
+  async retryFailed(jobId) {
+    const failed = this.failed.get(jobId);
+    if (!failed)
+      return false;
+    this.failed.delete(jobId);
+    const job = {
+      ...failed.job,
+      attempts: 0,
+      scheduledAt: Date.now(),
+      startedAt: undefined
+    };
+    this.waiting.set(jobId, job);
+    this.waitingHeap.push(job);
+    this.notify();
+    return true;
+  }
+  async remove(jobId) {
+    let existed = false;
+    if (this.waiting.delete(jobId)) {
+      this.waitingHeap.remove((j) => j.id === jobId);
+      existed = true;
+    }
+    existed = this.active.delete(jobId) || existed;
+    existed = this.failed.delete(jobId) || existed;
+    existed = this.completed.delete(jobId) || existed;
+    if (existed) {
+      this.allIds.delete(jobId);
+      this.progress.delete(jobId);
+    }
+    return existed;
+  }
+  async clear() {
+    this.waiting.clear();
+    this.waitingHeap.clear();
+    this.active.clear();
+    this.failed.clear();
+    this.completed.clear();
+    this.allIds.clear();
+    this.progress.clear();
+  }
+  async close() {
+    this.unsubscribe();
+    await this.clear();
+  }
+  notify() {
+    if (this.listener) {
+      queueMicrotask(this.listener);
+    }
+  }
+}
+// src/backends/broadcast.ts
+class BroadcastBackend {
+  waiting = new Map;
+  active = new Map;
+  failed = new Map;
+  completed = new Map;
+  allIds = new Set;
+  progress = new Map;
+  channel;
+  listener = null;
+  isLeader = false;
+  leaderTimeout = null;
+  instanceId = crypto.randomUUID();
+  pendingClaims = new Map;
+  constructor(channelName = "jobqueue") {
+    this.channel = new BroadcastChannel(channelName);
+    this.channel.onmessage = (event) => this.handleMessage(event);
+    this.electLeader();
+  }
+  electLeader() {
+    this.channel.postMessage({ type: "sync-request" });
+    this.leaderTimeout = setTimeout(() => {
+      this.isLeader = true;
+    }, 100);
+  }
+  handleMessage(event) {
+    const msg = event.data;
+    switch (msg.type) {
+      case "push":
+        if (msg.job && !this.allIds.has(msg.job.id)) {
+          this.allIds.add(msg.job.id);
+          this.waiting.set(msg.job.id, msg.job);
+          this.notify();
+        }
+        break;
+      case "ack":
+        if (msg.jobId) {
+          this.active.delete(msg.jobId);
+          this.allIds.delete(msg.jobId);
+        }
+        break;
+      case "nack":
+        if (msg.job && msg.nextAttemptAt !== undefined) {
+          this.active.delete(msg.job.id);
+          const updated = {
+            ...msg.job,
+            scheduledAt: msg.nextAttemptAt,
+            attempts: msg.job.attempts + 1,
+            startedAt: undefined
+          };
+          this.waiting.set(msg.job.id, updated);
+          this.notify();
+        }
+        break;
+      case "fail":
+        if (msg.job && msg.error !== undefined && msg.failedAt !== undefined) {
+          this.active.delete(msg.job.id);
+          this.failed.set(msg.job.id, {
+            job: msg.job,
+            error: msg.error,
+            failedAt: msg.failedAt
+          });
+        }
+        break;
+      case "claim":
+        if (msg.jobId && msg.claimId) {
+          const hasJob = this.waiting.has(msg.jobId);
+          this.channel.postMessage({
+            type: "claim-response",
+            claimId: msg.claimId,
+            claimed: hasJob,
+            jobId: msg.jobId
+          });
+        }
+        break;
+      case "claim-response":
+        if (msg.claimId && msg.claimed) {
+          const pending = this.pendingClaims.get(msg.claimId);
+          if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingClaims.delete(msg.claimId);
+            pending.resolve(false);
+          }
+        }
+        break;
+      case "sync-request":
+        if (this.isLeader) {
+          this.channel.postMessage({
+            type: "sync-response",
+            jobs: Array.from(this.waiting.values())
+          });
+        }
+        break;
+      case "sync-response":
+        if (this.leaderTimeout) {
+          clearTimeout(this.leaderTimeout);
+          this.leaderTimeout = null;
+        }
+        if (msg.jobs) {
+          for (const job of msg.jobs) {
+            if (!this.allIds.has(job.id)) {
+              this.allIds.add(job.id);
+              this.waiting.set(job.id, job);
+            }
+          }
+          this.notify();
+        }
+        break;
+      case "progress":
+        if (msg.jobId && msg.progress !== undefined) {
+          if (this.active.has(msg.jobId)) {
+            this.progress.set(msg.jobId, msg.progress);
+          }
+        }
+        break;
+    }
+  }
+  async push(job) {
+    if (this.allIds.has(job.id)) {
+      return false;
+    }
+    this.allIds.add(job.id);
+    this.waiting.set(job.id, job);
+    this.channel.postMessage({ type: "push", job });
+    this.notify();
+    return true;
+  }
+  async pushBulk(jobs) {
+    let added = 0;
+    for (const job of jobs) {
+      if (!this.allIds.has(job.id)) {
+        this.allIds.add(job.id);
+        this.waiting.set(job.id, job);
+        this.channel.postMessage({ type: "push", job });
+        added++;
+      }
+    }
+    if (added > 0) {
+      this.notify();
+    }
+    return added;
+  }
+  async pop(visibilityTimeout) {
+    const now = Date.now();
+    let best = null;
+    for (const job of this.waiting.values()) {
+      if (job.scheduledAt > now)
+        continue;
+      if (!best || job.priority < best.priority || job.priority === best.priority && job.scheduledAt < best.scheduledAt) {
+        best = job;
+      }
+    }
+    if (!best) {
+      return null;
+    }
+    const claimId = `${this.instanceId}-${best.id}-${now}`;
+    const claimed = await this.tryClaim(best.id, claimId);
+    if (!claimed) {
+      return null;
+    }
+    this.waiting.delete(best.id);
+    const activeJob = {
+      ...best,
+      startedAt: now
+    };
+    this.active.set(best.id, {
+      job: activeJob,
+      expiresAt: now + visibilityTimeout
+    });
+    return activeJob;
+  }
+  tryClaim(jobId, claimId) {
+    return new Promise((resolve) => {
+      this.channel.postMessage({
+        type: "claim",
+        jobId,
+        claimId
+      });
+      const timeout = setTimeout(() => {
+        this.pendingClaims.delete(claimId);
+        resolve(true);
+      }, 50);
+      this.pendingClaims.set(claimId, { resolve, timeout });
+    });
+  }
+  async ack(jobId, result) {
+    const activeJob = this.active.get(jobId);
+    this.active.delete(jobId);
+    this.progress.delete(jobId);
+    if (activeJob) {
+      const completedAt = Date.now();
+      this.completed.set(jobId, {
+        job: activeJob.job,
+        result,
+        completedAt
+      });
+    }
+    this.channel.postMessage({ type: "ack", jobId });
+  }
+  async nack(job, nextAttemptAt) {
+    this.active.delete(job.id);
+    this.progress.delete(job.id);
+    const updated = {
+      ...job,
+      scheduledAt: nextAttemptAt,
+      attempts: job.attempts + 1,
+      startedAt: undefined
+    };
+    this.waiting.set(job.id, updated);
+    this.channel.postMessage({
+      type: "nack",
+      job,
+      nextAttemptAt
+    });
+    this.notify();
+  }
+  async fail(job, error) {
+    this.active.delete(job.id);
+    this.progress.delete(job.id);
+    const failedAt = Date.now();
+    this.failed.set(job.id, {
+      job,
+      error: error.message,
+      failedAt
+    });
+    this.channel.postMessage({
+      type: "fail",
+      job,
+      error: error.message,
+      failedAt
+    });
+  }
+  async getStalled() {
+    const now = Date.now();
+    const stalled = [];
+    for (const [id, active] of this.active) {
+      if (active.expiresAt <= now) {
+        stalled.push(active.job);
+        this.active.delete(id);
+        this.progress.delete(id);
+      }
+    }
+    return stalled;
+  }
+  async updateProgress(jobId, progress) {
+    if (this.active.has(jobId)) {
+      this.progress.set(jobId, progress);
+      this.channel.postMessage({
+        type: "progress",
+        jobId,
+        progress
+      });
+    }
+  }
+  async getCompleted(jobId) {
+    return this.completed.get(jobId) ?? null;
+  }
+  async completedCount() {
+    return this.completed.size;
+  }
+  async getCompletedJobs(limit = 100) {
+    const result = [];
+    let count = 0;
+    const entries = [...this.completed.entries()].sort((a, b) => b[1].completedAt - a[1].completedAt);
+    for (const [, completed] of entries) {
+      if (count >= limit)
+        break;
+      result.push(completed);
+      count++;
+    }
+    return result;
+  }
+  subscribe(callback) {
+    this.listener = callback;
+  }
+  unsubscribe() {
+    this.listener = null;
+  }
+  async size() {
+    return this.waiting.size;
+  }
+  async activeCount() {
+    return this.active.size;
+  }
+  async failedCount() {
+    return this.failed.size;
+  }
+  async getFailed(limit = 100) {
+    const result = [];
+    let count = 0;
+    for (const failed of this.failed.values()) {
+      if (count >= limit)
+        break;
+      result.push(failed);
+      count++;
+    }
+    return result;
+  }
+  async retryFailed(jobId) {
+    const failed = this.failed.get(jobId);
+    if (!failed)
+      return false;
+    this.failed.delete(jobId);
+    const job = {
+      ...failed.job,
+      attempts: 0,
+      scheduledAt: Date.now(),
+      startedAt: undefined
+    };
+    this.waiting.set(jobId, job);
+    this.channel.postMessage({ type: "push", job });
+    this.notify();
+    return true;
+  }
+  async remove(jobId) {
+    let existed = false;
+    existed = this.waiting.delete(jobId) || existed;
+    existed = this.active.delete(jobId) || existed;
+    existed = this.failed.delete(jobId) || existed;
+    existed = this.completed.delete(jobId) || existed;
+    if (existed) {
+      this.allIds.delete(jobId);
+      this.progress.delete(jobId);
+      this.channel.postMessage({ type: "ack", jobId });
+    }
+    return existed;
+  }
+  async clear() {
+    this.waiting.clear();
+    this.active.clear();
+    this.failed.clear();
+    this.completed.clear();
+    this.allIds.clear();
+    this.progress.clear();
+  }
+  async close() {
+    this.channel.close();
+    if (this.leaderTimeout) {
+      clearTimeout(this.leaderTimeout);
+    }
+    for (const [, pending] of this.pendingClaims) {
+      clearTimeout(pending.timeout);
+    }
+    this.pendingClaims.clear();
+  }
+  notify() {
+    if (this.listener) {
+      queueMicrotask(this.listener);
+    }
+  }
+}
+// src/backends/redis.ts
+var POP_SCRIPT = `
+-- Get the first job by score (lowest priority, then earliest scheduledAt)
+local jobs = redis.call('ZRANGE', KEYS[1], 0, 0, 'WITHSCORES')
+if #jobs == 0 then
+  return nil
+end
+
+local jobId = jobs[1]
+local score = tonumber(jobs[2])
+
+-- Extract scheduledAt from score: scheduledAt = score % 1e15
+local scheduledAt = score % 1000000000000000
+
+-- Check if job is ready (scheduledAt <= now)
+if scheduledAt > tonumber(ARGV[1]) then
+  return nil
+end
+
+-- Atomically remove from waiting
+local removed = redis.call('ZREM', KEYS[1], jobId)
+if removed == 0 then
+  return nil
+end
+
+-- Get job data
+local jobData = redis.call('HGET', KEYS[3], jobId)
+if not jobData then
+  return nil
+end
+
+-- Add to active with expiry timestamp
+local expiresAt = tonumber(ARGV[1]) + tonumber(ARGV[2])
+redis.call('HSET', KEYS[2], jobId, tostring(expiresAt))
+
+return jobData
+`;
+var STALLED_SCRIPT = `
+local stalled = {}
+local active = redis.call('HGETALL', KEYS[1])
+
+for i = 1, #active, 2 do
+  local jobId = active[i]
+  local expiresAt = tonumber(active[i + 1])
+
+  if expiresAt <= tonumber(ARGV[1]) then
+    local jobData = redis.call('HGET', KEYS[2], jobId)
+    if jobData then
+      table.insert(stalled, jobData)
+    end
+    redis.call('HDEL', KEYS[1], jobId)
+  end
+end
+
+return stalled
+`;
+
+class RedisBackend {
+  client;
+  subscriber = null;
+  prefix;
+  listener = null;
+  ownsSubscriber = false;
+  url;
+  constructor(url, options = {}) {
+    this.url = url;
+    this.client = new Bun.RedisClient(url);
+    this.prefix = options.prefix ?? "qwerk";
+    if (options.subscriber) {
+      this.subscriber = options.subscriber;
+    }
+  }
+  key(name) {
+    return `${this.prefix}:${name}`;
+  }
+  evalScript(script, keys, args) {
+    return this.client.send("EVAL", [script, String(keys.length), ...keys, ...args.map(String)]);
+  }
+  async push(job) {
+    const jobKey = this.key("jobs");
+    const waitingKey = this.key("waiting");
+    const existing = await this.client.hget(jobKey, job.id);
+    if (existing) {
+      return false;
+    }
+    await this.client.hset(jobKey, job.id, JSON.stringify(job));
+    const score = job.priority * 1000000000000000 + job.scheduledAt;
+    await this.client.zadd(waitingKey, score, job.id);
+    await this.client.publish(this.key("notify"), "push");
+    return true;
+  }
+  async pushBulk(jobs) {
+    const jobKey = this.key("jobs");
+    const waitingKey = this.key("waiting");
+    let added = 0;
+    for (const job of jobs) {
+      const existing = await this.client.hget(jobKey, job.id);
+      if (existing)
+        continue;
+      await this.client.hset(jobKey, job.id, JSON.stringify(job));
+      const score = job.priority * 1000000000000000 + job.scheduledAt;
+      await this.client.zadd(waitingKey, score, job.id);
+      added++;
+    }
+    if (added > 0) {
+      await this.client.publish(this.key("notify"), "push");
+    }
+    return added;
+  }
+  async pop(visibilityTimeout) {
+    const now = Date.now();
+    const result = await this.evalScript(POP_SCRIPT, [this.key("waiting"), this.key("active"), this.key("jobs")], [now, visibilityTimeout]);
+    if (!result) {
+      return null;
+    }
+    const job = JSON.parse(result);
+    return { ...job, startedAt: now };
+  }
+  async ack(jobId, result) {
+    const jobData = await this.client.hget(this.key("jobs"), jobId);
+    await this.client.hdel(this.key("active"), jobId);
+    await this.client.hdel(this.key("progress"), jobId);
+    if (jobData) {
+      const job = JSON.parse(jobData);
+      const completedData = JSON.stringify({
+        job,
+        result,
+        completedAt: Date.now()
+      });
+      await this.client.hset(this.key("completed"), jobId, completedData);
+    }
+    await this.client.hdel(this.key("jobs"), jobId);
+  }
+  async nack(job, nextAttemptAt) {
+    const updated = {
+      ...job,
+      scheduledAt: nextAttemptAt,
+      attempts: job.attempts + 1,
+      startedAt: undefined
+    };
+    await this.client.hdel(this.key("active"), job.id);
+    await this.client.hdel(this.key("progress"), job.id);
+    await this.client.hset(this.key("jobs"), job.id, JSON.stringify(updated));
+    const score = updated.priority * 1000000000000000 + nextAttemptAt;
+    await this.client.zadd(this.key("waiting"), score, job.id);
+    await this.client.publish(this.key("notify"), "nack");
+  }
+  async fail(job, error) {
+    await this.client.hdel(this.key("active"), job.id);
+    await this.client.hdel(this.key("progress"), job.id);
+    const failedData = JSON.stringify({
+      job,
+      error: error.message,
+      failedAt: Date.now()
+    });
+    await this.client.hset(this.key("failed"), job.id, failedData);
+  }
+  async getStalled() {
+    const now = Date.now();
+    const results = await this.evalScript(STALLED_SCRIPT, [this.key("active"), this.key("jobs")], [now]);
+    if (!results || results.length === 0) {
+      return [];
+    }
+    return results.map((data) => JSON.parse(data));
+  }
+  async updateProgress(jobId, progress) {
+    const isActive = await this.client.hget(this.key("active"), jobId);
+    if (isActive) {
+      await this.client.hset(this.key("progress"), jobId, String(progress));
+    }
+  }
+  async getCompleted(jobId) {
+    const data = await this.client.hget(this.key("completed"), jobId);
+    if (!data)
+      return null;
+    return JSON.parse(data);
+  }
+  async completedCount() {
+    return await this.client.hlen(this.key("completed"));
+  }
+  async getCompletedJobs(limit = 100) {
+    const all = await this.client.hgetall(this.key("completed"));
+    const result = [];
+    const entries = Object.values(all).map((v) => JSON.parse(v)).sort((a, b) => b.completedAt - a.completedAt);
+    for (const entry of entries) {
+      if (result.length >= limit)
+        break;
+      result.push(entry);
+    }
+    return result;
+  }
+  subscribe(callback) {
+    this.listener = callback;
+    if (!this.subscriber) {
+      this.subscriber = new Bun.RedisClient(this.url);
+      this.ownsSubscriber = true;
+    }
+    this.subscriber.subscribe(this.key("notify"), () => {
+      if (this.listener) {
+        this.listener();
+      }
+    }).catch(() => {});
+  }
+  unsubscribe() {
+    this.listener = null;
+    if (this.subscriber && this.ownsSubscriber) {
+      this.subscriber.close();
+      this.subscriber = null;
+    }
+  }
+  async size() {
+    return await this.client.zcard(this.key("waiting"));
+  }
+  async activeCount() {
+    return await this.client.hlen(this.key("active"));
+  }
+  async failedCount() {
+    return await this.client.hlen(this.key("failed"));
+  }
+  async getFailed(limit = 100) {
+    const all = await this.client.hgetall(this.key("failed"));
+    const result = [];
+    let count = 0;
+    for (const value of Object.values(all)) {
+      if (count >= limit)
+        break;
+      result.push(JSON.parse(value));
+      count++;
+    }
+    return result;
+  }
+  async retryFailed(jobId) {
+    const failedData = await this.client.hget(this.key("failed"), jobId);
+    if (!failedData)
+      return false;
+    const { job } = JSON.parse(failedData);
+    await this.client.hdel(this.key("failed"), jobId);
+    const resetJob = {
+      ...job,
+      attempts: 0,
+      scheduledAt: Date.now(),
+      startedAt: undefined
+    };
+    await this.client.hset(this.key("jobs"), jobId, JSON.stringify(resetJob));
+    const score = resetJob.priority * 1000000000000000 + resetJob.scheduledAt;
+    await this.client.zadd(this.key("waiting"), score, jobId);
+    await this.client.publish(this.key("notify"), "push");
+    return true;
+  }
+  async remove(jobId) {
+    const removed = await this.client.zrem(this.key("waiting"), jobId) > 0 || await this.client.hdel(this.key("active"), jobId) > 0 || await this.client.hdel(this.key("failed"), jobId) > 0 || await this.client.hdel(this.key("completed"), jobId) > 0;
+    if (removed) {
+      await this.client.hdel(this.key("jobs"), jobId);
+      await this.client.hdel(this.key("progress"), jobId);
+    }
+    return removed;
+  }
+  async clear() {
+    const waiting = await this.client.zrange(this.key("waiting"), 0, -1);
+    const active = await this.client.hgetall(this.key("active"));
+    const failed = await this.client.hgetall(this.key("failed"));
+    const completed = await this.client.hgetall(this.key("completed"));
+    const allIds = [
+      ...waiting,
+      ...Object.keys(active),
+      ...Object.keys(failed),
+      ...Object.keys(completed)
+    ];
+    if (allIds.length > 0) {
+      await this.client.hdel(this.key("jobs"), ...allIds);
+    }
+    await this.client.del(this.key("waiting"));
+    await this.client.del(this.key("active"));
+    await this.client.del(this.key("failed"));
+    await this.client.del(this.key("completed"));
+    await this.client.del(this.key("progress"));
+  }
+  async close() {
+    this.unsubscribe();
+    this.client.close();
+  }
+}
+export {
+  silentLogger,
+  consoleLogger,
+  RedisBackend,
+  Queue,
+  MemoryBackend,
+  JobHandle,
+  BroadcastBackend
+};