@workglow/job-queue 0.0.57 → 0.0.59

package/dist/node.js

@@ -1,11 +1,6 @@
-// src/job/IJobQueue.ts
+// src/job/Job.ts
 import { JobStatus } from "@workglow/storage";
-var QueueMode;
-((QueueMode2) => {
-  QueueMode2["CLIENT"] = "CLIENT";
-  QueueMode2["SERVER"] = "SERVER";
-  QueueMode2["BOTH"] = "BOTH";
-})(QueueMode ||= {});
+
 // src/job/JobError.ts
 import { BaseError } from "@workglow/util";
 
@@ -75,7 +70,6 @@ class Job {
   progress = 0;
   progressMessage = "";
   progressDetails = null;
-  queue;
   constructor({
     queueName,
     input,
@@ -128,7 +122,6 @@ class Job {
     for (const listener of this.progressListeners) {
       listener(progress, message, details);
     }
-    await this.queue?.updateProgress(this.id, progress, message, details);
   }
   onJobProgress(listener) {
     this.progressListeners.add(listener);
@@ -137,78 +130,81 @@ class Job {
     };
   }
 }
-// src/job/JobQueue.ts
-import {
-  InMemoryQueueStorage,
-  QUEUE_STORAGE
-} from "@workglow/storage";
-import { EventEmitter, globalServiceRegistry, sleep } from "@workglow/util";
-
-// src/limiter/ILimiter.ts
-import { createServiceToken } from "@workglow/util";
-var JOB_LIMITER = createServiceToken("jobqueue.limiter");
-
-// src/limiter/NullLimiter.ts
-import { createServiceToken as createServiceToken2 } from "@workglow/util";
-var NULL_JOB_LIMITER = createServiceToken2("jobqueue.limiter.null");
-
-class NullLimiter {
-  async canProceed() {
-    return true;
+// src/job/JobQueueClient.ts
+import { JobStatus as JobStatus2 } from "@workglow/storage";
+import { EventEmitter } from "@workglow/util";
+class JobQueueClient {
+  queueName;
+  storage;
+  events = new EventEmitter;
+  server = null;
+  storageUnsubscribe = null;
+  activeJobPromises = new Map;
+  jobProgressListeners = new Map;
+  lastKnownProgress = new Map;
+  constructor(options) {
+    this.queueName = options.queueName;
+    this.storage = options.storage;
   }
-  async recordJobStart() {}
-  async recordJobCompletion() {}
-  async getNextAvailableTime() {
-    return new Date;
+  attach(server) {
+    if (this.server) {
+      this.detach();
+    }
+    this.server = server;
+    server.addClient(this);
+    if (this.storageUnsubscribe) {
+      this.storageUnsubscribe();
+      this.storageUnsubscribe = null;
+    }
   }
-  async setNextAvailableTime(date) {}
-  async clear() {}
-}
-
-// src/job/JobQueue.ts
-class JobQueue {
-  queueName;
-  jobClass;
-  options;
-  constructor(queueName, jobClass, options) {
-    this.queueName = queueName;
-    this.jobClass = jobClass;
-    const { limiter, storage, ...rest } = options;
-    this.options = {
-      waitDurationInMilliseconds: 100,
-      ...rest
-    };
-    if (limiter) {
-      this.limiter = limiter;
-    } else {
-      try {
-        this.limiter = globalServiceRegistry.get(JOB_LIMITER);
-      } catch (err) {
-        console.warn("Warning: did not find job limiter in global DI", err);
-        this.limiter = new NullLimiter;
-      }
+  detach() {
+    if (this.server) {
+      this.server.removeClient(this);
+      this.server = null;
     }
-    if (storage) {
-      this.storage = storage;
-    } else {
-      try {
-        this.storage = globalServiceRegistry.get(QUEUE_STORAGE);
-      } catch (err) {
-        console.warn("Warning: did not find queue storage in global DI", err);
-        this.storage = new InMemoryQueueStorage(queueName);
-      }
+  }
+  connect() {
+    if (this.server) {
+      return;
+    }
+    if (this.storageUnsubscribe) {
+      return;
     }
-    this.stats = {
-      totalJobs: 0,
-      completedJobs: 0,
-      failedJobs: 0,
-      abortedJobs: 0,
-      retriedJobs: 0,
-      disabledJobs: 0,
-      lastUpdateTime: new Date
+    this.storageUnsubscribe = this.storage.subscribeToChanges((change) => {
+      this.handleStorageChange(change);
+    });
+  }
+  disconnect() {
+    if (this.storageUnsubscribe) {
+      this.storageUnsubscribe();
+      this.storageUnsubscribe = null;
+    }
+    this.detach();
+  }
+  async submit(input, options) {
+    const job = {
+      queue: this.queueName,
+      input,
+      job_run_id: options?.jobRunId,
+      fingerprint: options?.fingerprint,
+      max_retries: options?.maxRetries ?? 10,
+      run_after: options?.runAfter?.toISOString() ?? new Date().toISOString(),
+      deadline_at: options?.deadlineAt?.toISOString() ?? null,
+      completed_at: null,
+      status: JobStatus2.PENDING
     };
+    const id = await this.storage.add(job);
+    return this.createJobHandle(id);
+  }
+  async submitBatch(inputs, options) {
+    const handles = [];
+    for (const input of inputs) {
+      const handle = await this.submit(input, options);
+      handles.push(handle);
+    }
+    return handles;
   }
-  async get(id) {
+  async getJob(id) {
     if (!id)
       throw new JobNotFoundError("Cannot get undefined job");
     const job = await this.storage.get(id);
@@ -216,15 +212,11 @@ class JobQueue {
       return;
     return this.storageToClass(job);
   }
-  async add(job) {
-    const jobId = await this.storage.add(this.classToStorage(job));
-    return jobId;
-  }
-  async next() {
-    const job = await this.storage.next();
-    if (!job)
-      return;
-    return this.storageToClass(job);
+  async getJobsByRunId(runId) {
+    if (!runId)
+      throw new JobNotFoundError("Cannot get jobs by undefined runId");
+    const jobs = await this.storage.getByRunId(runId);
+    return jobs.map((job) => this.storageToClass(job));
   }
   async peek(status, num) {
     const jobs = await this.storage.peek(status, num);
@@ -233,86 +225,48 @@ class JobQueue {
   async size(status) {
     return this.storage.size(status);
   }
-  async delete(id) {
-    if (!id)
-      throw new JobNotFoundError("Cannot delete undefined job");
-    await this.storage.delete(id);
-  }
-  async disable(id) {
-    if (!id)
-      throw new JobNotFoundError("Cannot disable undefined job");
-    const job = await this.get(id);
-    if (!job)
-      throw new JobNotFoundError(`Job ${id} not found`);
-    await this.disableJob(job);
-  }
-  getStats() {
-    return { ...this.stats };
-  }
   async outputForInput(input) {
     if (!input)
       throw new JobNotFoundError("Cannot get output for undefined input");
     return this.storage.outputForInput(input);
   }
-  async executeJob(job, signal) {
-    if (!job)
-      throw new JobNotFoundError("Cannot execute null or undefined job");
-    return await job.execute(job.input, {
-      signal,
-      updateProgress: this.updateProgress.bind(this, job.id)
-    });
-  }
   async waitFor(jobId) {
     if (!jobId)
       throw new JobNotFoundError("Cannot wait for undefined job");
-    const { promise, resolve, reject } = Promise.withResolvers();
-    promise.catch(() => {});
-    const promises = this.activeJobPromises.get(jobId) || [];
-    promises.push({ resolve, reject });
-    this.activeJobPromises.set(jobId, promises);
-    const job = await this.get(jobId);
+    const job = await this.getJob(jobId);
     if (!job)
       throw new JobNotFoundError(`Job ${jobId} not found`);
-    if (job.status === JobStatus.COMPLETED) {
+    if (job.status === JobStatus2.COMPLETED) {
       return job.output;
     }
-    if (job.status === JobStatus.DISABLED) {
-      return;
+    if (job.status === JobStatus2.DISABLED) {
+      throw new JobDisabledError(`Job ${jobId} was disabled`);
     }
-    if (job.status === JobStatus.FAILED) {
+    if (job.status === JobStatus2.FAILED) {
       throw this.buildErrorFromJob(job);
     }
+    const { promise, resolve, reject } = Promise.withResolvers();
+    promise.catch(() => {});
+    const promises = this.activeJobPromises.get(jobId) || [];
+    promises.push({ resolve, reject });
+    this.activeJobPromises.set(jobId, promises);
     return promise;
   }
-  buildErrorFromJob(job) {
-    const errorMessage = job.error || "Job failed";
-    if (job.errorCode === "PermanentJobError") {
-      return new PermanentJobError(errorMessage);
-    }
-    if (job.errorCode === "RetryableJobError") {
-      return new RetryableJobError(errorMessage);
-    }
-    if (job.errorCode === "AbortSignalJobError") {
-      return new AbortSignalJobError(errorMessage);
-    }
-    if (job.errorCode === "JobDisabledError") {
-      return new JobDisabledError(errorMessage);
-    }
-    return new JobError(errorMessage);
+  async abort(jobId) {
+    if (!jobId)
+      throw new JobNotFoundError("Cannot abort undefined job");
+    await this.storage.abort(jobId);
+    this.events.emit("job_aborting", this.queueName, jobId);
   }
-  async updateProgress(jobId, progress, message = "", details = null) {
-    const job = await this.get(jobId);
-    if (!job)
-      throw new JobNotFoundError(`Job ${jobId} not found`);
-    if ([JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.ABORTING, JobStatus.DISABLED].includes(job.status)) {
-      return;
-    }
-    progress = Math.max(0, Math.min(100, progress));
-    job.progress = progress;
-    job.progressMessage = message;
-    job.progressDetails = details;
-    await this.saveProgress(jobId, progress, message, details ?? null);
-    this.announceProgress(jobId, progress, message, details ?? null);
+  async abortJobRun(jobRunId) {
+    if (!jobRunId)
+      throw new JobNotFoundError("Cannot abort job run with undefined jobRunId");
+    const jobs = await this.getJobsByRunId(jobRunId);
+    await Promise.allSettled(jobs.map((job) => {
+      if ([JobStatus2.PROCESSING, JobStatus2.PENDING].includes(job.status)) {
+        return this.abort(job.id);
+      }
+    }));
   }
   onJobProgress(jobId, listener) {
     if (!this.jobProgressListeners.has(jobId)) {
@@ -330,78 +284,6 @@ class JobQueue {
       }
     };
   }
-  async start(mode = "BOTH" /* BOTH */) {
-    if (this.running) {
-      return this;
-    }
-    this.mode = mode;
-    this.running = true;
-    this.events.emit("queue_start", this.queueName);
-    if (this.mode === "SERVER" /* SERVER */ || this.mode === "BOTH" /* BOTH */) {
-      await this.fixupJobs();
-      await this.processJobs();
-    }
-    if (this.mode === "CLIENT" /* CLIENT */ || this.mode === "BOTH" /* BOTH */) {
-      await this.monitorJobs();
-    }
-    return this;
-  }
-  async stop() {
-    if (!this.running)
-      return this;
-    this.running = false;
-    const size = await this.size(JobStatus.PROCESSING);
-    const sleepTime = Math.max(100, size * 2);
-    await sleep(sleepTime);
-    for (const [jobId] of this.activeJobAbortControllers.entries()) {
-      this.abort(jobId);
-    }
-    this.activeJobPromises.forEach((promises) => promises.forEach(({ reject }) => reject(new PermanentJobError("Queue Stopped"))));
-    await sleep(sleepTime);
-    this.events.emit("queue_stop", this.queueName);
-    return this;
-  }
-  async clear() {
-    await this.storage.deleteAll();
-    this.activeJobAbortControllers.clear();
-    this.activeJobPromises.clear();
-    this.processingTimes.clear();
-    this.lastKnownProgress.clear();
-    this.jobProgressListeners.clear();
-    this.stats = {
-      totalJobs: 0,
-      completedJobs: 0,
-      failedJobs: 0,
-      abortedJobs: 0,
-      retriedJobs: 0,
-      disabledJobs: 0,
-      lastUpdateTime: new Date
-    };
-    this.emitStatsUpdate();
-    return this;
-  }
-  async restart() {
-    await this.stop();
-    await this.clear();
-    await this.start();
-    return this;
-  }
-  async abortJobRun(jobRunId) {
-    if (!jobRunId)
-      throw new JobNotFoundError("Cannot abort job run with undefined jobRunId");
-    const jobs = await this.getJobsByRunId(jobRunId);
-    await Promise.allSettled(jobs.map((job) => {
-      if ([JobStatus.PROCESSING, JobStatus.PENDING].includes(job.status)) {
-        this.abort(job.id);
-      }
-    }));
-  }
-  async getJobsByRunId(runId) {
-    if (!runId)
-      throw new JobNotFoundError("Cannot get jobs by undefined runId");
-    const jobs = await this.storage.getByRunId(runId);
-    return jobs.map((job) => this.storageToClass(job));
-  }
   on(event, listener) {
     this.events.on(event, listener);
   }
@@ -414,83 +296,44 @@ class JobQueue {
   waitOn(event) {
     return this.events.waitOn(event);
   }
-  limiter;
-  storage;
-  running = false;
-  stats = {
-    totalJobs: 0,
-    completedJobs: 0,
-    failedJobs: 0,
-    abortedJobs: 0,
-    retriedJobs: 0,
-    disabledJobs: 0,
-    lastUpdateTime: new Date
-  };
-  events = new EventEmitter;
-  activeJobAbortControllers = new Map;
-  activeJobPromises = new Map;
-  processingTimes = new Map;
-  mode = "BOTH" /* BOTH */;
-  jobProgressListeners = new Map;
-  lastKnownProgress = new Map;
-  async saveProgress(id, progress, message, details) {
-    if (!id)
-      throw new JobNotFoundError("Cannot save progress for undefined job");
-    await this.storage.saveProgress(id, progress, message, details);
-  }
-  createAbortController(jobId) {
-    if (!jobId)
-      throw new JobNotFoundError("Cannot create abort controller for undefined job");
-    if (this.activeJobAbortControllers.has(jobId)) {
-      return this.activeJobAbortControllers.get(jobId);
-    }
-    const abortController = new AbortController;
-    abortController.signal.addEventListener("abort", () => this.handleAbort(jobId));
-    this.activeJobAbortControllers.set(jobId, abortController);
-    return abortController;
+  handleJobStart(jobId) {
+    this.lastKnownProgress.set(jobId, {
+      progress: 0,
+      message: "",
+      details: null
+    });
+    this.events.emit("job_start", this.queueName, jobId);
   }
-  async validateJobState(job) {
-    if (job.status === JobStatus.COMPLETED) {
-      throw new PermanentJobError(`Job ${job.id} is already completed`);
-    }
-    if (job.status === JobStatus.FAILED) {
-      throw new PermanentJobError(`Job ${job.id} has failed`);
-    }
-    if (job.status === JobStatus.ABORTING || this.activeJobAbortControllers.get(job.id)?.signal.aborted) {
-      throw new AbortSignalJobError(`Job ${job.id} is being aborted`);
-    }
-    if (job.deadlineAt && job.deadlineAt < new Date) {
-      throw new PermanentJobError(`Job ${job.id} has exceeded its deadline`);
-    }
-    if (job.status === JobStatus.DISABLED) {
-      throw new JobDisabledError(`Job ${job.id} has been disabled`);
+  handleJobComplete(jobId, output) {
+    this.events.emit("job_complete", this.queueName, jobId, output);
+    const promises = this.activeJobPromises.get(jobId);
+    if (promises) {
+      promises.forEach(({ resolve }) => resolve(output));
     }
+    this.cleanupJob(jobId);
   }
-  normalizeError(err) {
-    if (err instanceof JobError) {
-      return err;
-    }
-    if (err instanceof Error) {
-      return err;
+  handleJobError(jobId, error, errorCode) {
+    this.events.emit("job_error", this.queueName, jobId, error);
+    const promises = this.activeJobPromises.get(jobId);
+    if (promises) {
+      const jobError = this.buildErrorFromCode(error, errorCode);
+      promises.forEach(({ reject }) => reject(jobError));
     }
-    return new PermanentJobError(String(err));
+    this.cleanupJob(jobId);
   }
-  updateAverageProcessingTime() {
-    const times = Array.from(this.processingTimes.values());
-    if (times.length > 0) {
-      this.stats.averageProcessingTime = times.reduce((a, b) => a + b, 0) / times.length;
+  handleJobDisabled(jobId) {
+    this.events.emit("job_disabled", this.queueName, jobId);
+    const promises = this.activeJobPromises.get(jobId);
+    if (promises) {
+      promises.forEach(({ reject }) => reject(new JobDisabledError("Job was disabled")));
     }
+    this.cleanupJob(jobId);
   }
-  emitStatsUpdate() {
-    this.stats.lastUpdateTime = new Date;
-    this.events.emit("queue_stats_update", this.queueName, { ...this.stats });
+  handleJobRetry(jobId, runAfter) {
+    this.events.emit("job_retry", this.queueName, jobId, runAfter);
   }
-  announceProgress(jobId, progress, message, details) {
-    this.lastKnownProgress.set(jobId, {
-      progress,
-      message,
-      details
-    });
+  handleJobProgress(jobId, progress, message, details) {
+    this.lastKnownProgress.set(jobId, { progress, message, details });
     this.events.emit("job_progress", this.queueName, jobId, progress, message, details);
     const listeners = this.jobProgressListeners.get(jobId);
     if (listeners) {
@@ -499,6 +342,48 @@ class JobQueue {
       }
     }
   }
+  createJobHandle(id) {
+    return {
+      id,
+      waitFor: () => this.waitFor(id),
+      abort: () => this.abort(id),
+      onProgress: (callback) => this.onJobProgress(id, callback)
+    };
+  }
+  cleanupJob(jobId) {
+    this.activeJobPromises.delete(jobId);
+    this.lastKnownProgress.delete(jobId);
+    this.jobProgressListeners.delete(jobId);
+  }
+  handleStorageChange(change) {
+    if (!change.new && !change.old)
+      return;
+    const jobId = change.new?.id ?? change.old?.id;
+    if (!jobId)
+      return;
+    const queueName = change.new?.queue ?? change.old?.queue;
+    if (queueName !== this.queueName)
+      return;
+    if (change.type === "UPDATE" && change.new) {
+      const newStatus = change.new.status;
+      const oldStatus = change.old?.status;
+      if (newStatus === JobStatus2.PROCESSING && oldStatus === JobStatus2.PENDING) {
+        this.handleJobStart(jobId);
+      } else if (newStatus === JobStatus2.COMPLETED) {
+        this.handleJobComplete(jobId, change.new.output);
+      } else if (newStatus === JobStatus2.FAILED) {
+        this.handleJobError(jobId, change.new.error ?? "Job failed", change.new.error_code ?? undefined);
+      } else if (newStatus === JobStatus2.DISABLED) {
+        this.handleJobDisabled(jobId);
+      } else if (newStatus === JobStatus2.PENDING && oldStatus === JobStatus2.PROCESSING) {
+        const runAfter = change.new.run_after ? new Date(change.new.run_after) : new Date;
+        this.handleJobRetry(jobId, runAfter);
+      }
+      if (change.new.progress !== change.old?.progress || change.new.progress_message !== change.old?.progress_message) {
+        this.handleJobProgress(jobId, change.new.progress ?? 0, change.new.progress_message ?? "", change.new.progress_details ?? null);
+      }
+    }
+  }
   storageToClass(details) {
     const toDate = (date) => {
       if (!date)
@@ -506,7 +391,7 @@ class JobQueue {
       const d = new Date(date);
       return isNaN(d.getTime()) ? null : d;
     };
-    const job = new this.jobClass({
+    return new Job({
       id: details.id,
       jobRunId: details.job_run_id,
       queueName: details.queue,
@@ -527,173 +412,172 @@ class JobQueue {
       runAttempts: details.run_attempts ?? 0,
       maxRetries: details.max_retries ?? 10
     });
-    job.queue = this;
-    return job;
   }
-  classToStorage(job) {
-    const dateToISOString = (date) => {
-      if (!date)
-        return null;
-      return isNaN(date.getTime()) ? null : date.toISOString();
-    };
-    const now = new Date().toISOString();
-    return {
-      id: job.id,
-      job_run_id: job.jobRunId,
-      queue: job.queueName || this.queueName,
-      fingerprint: job.fingerprint,
-      input: job.input,
-      status: job.status,
-      output: job.output ?? null,
-      error: job.error === null ? null : String(job.error),
-      error_code: job.errorCode || null,
-      run_attempts: job.runAttempts ?? 0,
-      max_retries: job.maxRetries ?? 10,
-      run_after: dateToISOString(job.runAfter) ?? now,
-      created_at: dateToISOString(job.createdAt) ?? now,
-      deadline_at: dateToISOString(job.deadlineAt),
-      last_ran_at: dateToISOString(job.lastRanAt),
-      completed_at: dateToISOString(job.completedAt),
-      progress: job.progress ?? 0,
-      progress_message: job.progressMessage ?? "",
-      progress_details: job.progressDetails ?? null
-    };
+  buildErrorFromJob(job) {
+    return this.buildErrorFromCode(job.error || "Job failed", job.errorCode ?? undefined);
   }
-  async rescheduleJob(job, retryDate) {
-    try {
-      job.status = JobStatus.PENDING;
-      const nextAvailableTime = await this.limiter.getNextAvailableTime();
-      job.runAfter = retryDate instanceof Date ? retryDate : nextAvailableTime;
-      job.progress = 0;
-      job.progressMessage = "";
-      job.progressDetails = null;
-      await this.storage.complete(this.classToStorage(job));
-      this.stats.retriedJobs++;
-      this.events.emit("job_retry", this.queueName, job.id, job.runAfter);
-    } catch (err) {
-      console.error("rescheduleJob", err);
+  buildErrorFromCode(message, errorCode) {
+    if (errorCode === "PermanentJobError") {
+      return new PermanentJobError(message);
     }
-  }
-  async disableJob(job) {
-    try {
-      job.status = JobStatus.DISABLED;
-      job.progress = 100;
-      job.completedAt = new Date;
-      job.progressMessage = "";
-      job.progressDetails = null;
-      await this.storage.complete(this.classToStorage(job));
-      if (this.options.deleteAfterDisabledMs === 0) {
-        await this.delete(job.id);
-      }
-      this.stats.disabledJobs++;
-      this.events.emit("job_disabled", this.queueName, job.id);
-      const promises = this.activeJobPromises.get(job.id) || [];
-      promises.forEach(({ resolve }) => resolve(undefined));
-      this.activeJobPromises.delete(job.id);
-    } catch (err) {
-      console.error("disableJob", err);
+    if (errorCode === "RetryableJobError") {
+      return new RetryableJobError(message);
+    }
+    if (errorCode === "AbortSignalJobError") {
+      return new AbortSignalJobError(message);
     }
+    if (errorCode === "JobDisabledError") {
+      return new JobDisabledError(message);
+    }
+    return new JobError(message);
   }
-  async failJob(job, error) {
-    try {
-      job.status = JobStatus.FAILED;
-      job.progress = 100;
-      job.completedAt = new Date;
-      job.progressMessage = "";
-      job.progressDetails = null;
-      job.error = error.message;
-      job.errorCode = error?.constructor?.name ?? null;
-      await this.storage.complete(this.classToStorage(job));
-      if (this.options.deleteAfterFailureMs === 0) {
-        await this.delete(job.id);
-      }
-      this.stats.failedJobs++;
-      this.events.emit("job_error", this.queueName, job.id, `${error.name}: ${error.message}`);
-      const promises = this.activeJobPromises.get(job.id) || [];
-      promises.forEach(({ reject }) => reject(error));
-      this.activeJobPromises.delete(job.id);
-    } catch (err) {
-      console.error("failJob errored out?", err);
+}
+// src/job/JobQueueServer.ts
+import { JobStatus as JobStatus4 } from "@workglow/storage";
+import { EventEmitter as EventEmitter3 } from "@workglow/util";
+
+// src/limiter/NullLimiter.ts
+import { createServiceToken } from "@workglow/util";
+var NULL_JOB_LIMITER = createServiceToken("jobqueue.limiter.null");
+
+class NullLimiter {
+  async canProceed() {
+    return true;
+  }
+  async recordJobStart() {}
+  async recordJobCompletion() {}
+  async getNextAvailableTime() {
+    return new Date;
+  }
+  async setNextAvailableTime(date) {}
+  async clear() {}
+}
+
+// src/job/JobQueueWorker.ts
+import { JobStatus as JobStatus3 } from "@workglow/storage";
+import { EventEmitter as EventEmitter2, sleep, uuid4 } from "@workglow/util";
+class JobQueueWorker {
+  queueName;
+  workerId;
+  storage;
+  jobClass;
+  limiter;
+  pollIntervalMs;
+  events = new EventEmitter2;
+  running = false;
+  activeJobAbortControllers = new Map;
+  processingTimes = new Map;
+  constructor(jobClass, options) {
+    this.queueName = options.queueName;
+    this.workerId = uuid4();
+    this.storage = options.storage;
+    this.jobClass = jobClass;
+    this.limiter = options.limiter ?? new NullLimiter;
+    this.pollIntervalMs = options.pollIntervalMs ?? 100;
+  }
+  async start() {
+    if (this.running) {
+      return this;
     }
-    this.activeJobAbortControllers.delete(job.id);
-    this.lastKnownProgress.delete(job.id);
-    this.jobProgressListeners.delete(job.id);
-    this.activeJobPromises.delete(job.id);
+    this.running = true;
+    this.events.emit("worker_start");
+    this.processJobs();
+    return this;
   }
-  async completeJob(job, output) {
-    try {
-      job.status = JobStatus.COMPLETED;
-      job.progress = 100;
-      job.progressMessage = "";
-      job.progressDetails = null;
-      job.completedAt = new Date;
-      job.output = output ?? null;
-      job.error = null;
-      job.errorCode = null;
-      await this.storage.complete(this.classToStorage(job));
-      if (job && this.options.deleteAfterCompletionMs === 0) {
-        await this.delete(job.id);
-      }
-      this.stats.completedJobs++;
-      this.events.emit("job_complete", this.queueName, job.id, output);
-      const promises = this.activeJobPromises.get(job.id);
-      if (promises) {
-        promises.forEach(({ resolve }) => resolve(output));
+  async stop() {
+    if (!this.running) {
+      return this;
+    }
+    this.running = false;
+    const size = await this.storage.size(JobStatus3.PROCESSING);
+    const sleepTime = Math.max(100, size * 2);
+    await sleep(sleepTime);
+    for (const controller of this.activeJobAbortControllers.values()) {
+      if (!controller.signal.aborted) {
+        controller.abort();
       }
-      this.activeJobPromises.delete(job.id);
-    } catch (err) {
-      console.error("completeJob errored out?", err);
     }
-    this.activeJobAbortControllers.delete(job.id);
-    this.lastKnownProgress.delete(job.id);
-    this.jobProgressListeners.delete(job.id);
-    this.activeJobPromises.delete(job.id);
+    await sleep(sleepTime);
+    this.events.emit("worker_stop");
+    return this;
   }
-  async abort(jobId) {
-    if (!jobId)
-      throw new JobNotFoundError("Cannot abort undefined job");
-    await this.storage.abort(jobId);
-    let controller = this.activeJobAbortControllers.get(jobId);
-    if (!controller) {
-      controller = this.createAbortController(jobId);
+  async processNext() {
+    const canProceed = await this.limiter.canProceed();
+    if (!canProceed) {
+      return false;
     }
-    if (!controller.signal.aborted) {
-      controller.abort();
+    const job = await this.next();
+    if (!job) {
+      return false;
     }
-    this.events.emit("job_aborting", this.queueName, jobId);
+    await this.processSingleJob(job);
+    return true;
   }
-  async handleAbort(jobId) {
-    const promises = this.activeJobPromises.get(jobId);
-    if (promises) {
-      const job = await this.get(jobId);
-      if (!job) {
-        console.error("handleAbort: job not found", jobId);
-        return;
+  isRunning() {
+    return this.running;
+  }
+  getActiveJobCount() {
+    return this.activeJobAbortControllers.size;
+  }
+  getAverageProcessingTime() {
+    const times = Array.from(this.processingTimes.values());
+    if (times.length === 0)
+      return;
+    return times.reduce((a, b) => a + b, 0) / times.length;
+  }
+  on(event, listener) {
+    this.events.on(event, listener);
+  }
+  off(event, listener) {
+    this.events.off(event, listener);
+  }
+  async next() {
+    const job = await this.storage.next(this.workerId);
+    if (!job)
+      return;
+    return this.storageToClass(job);
+  }
+  async processJobs() {
+    if (!this.running) {
+      return;
+    }
+    try {
+      await this.checkForAbortingJobs();
+      const canProceed = await this.limiter.canProceed();
+      if (canProceed) {
+        const job = await this.next();
+        if (job) {
+          this.processSingleJob(job);
+        }
+      }
+    } finally {
+      if (this.running) {
+        setTimeout(() => this.processJobs(), this.pollIntervalMs);
+      }
+    }
+  }
+  async checkForAbortingJobs() {
+    const abortingJobs = await this.storage.peek(JobStatus3.ABORTING);
+    for (const jobData of abortingJobs) {
+      const controller = this.activeJobAbortControllers.get(jobData.id);
+      if (controller && !controller.signal.aborted) {
+        controller.abort();
       }
-      const error = new AbortSignalJobError("Job Aborted");
-      this.failJob(job, error);
     }
-    this.stats.abortedJobs++;
   }
   async processSingleJob(job) {
-    if (!job || !job.id)
+    if (!job || !job.id) {
       throw new JobNotFoundError("Invalid job provided for processing");
+    }
     const startTime = Date.now();
     try {
       await this.validateJobState(job);
       await this.limiter.recordJobStart();
-      this.emitStatsUpdate();
       const abortController = this.createAbortController(job.id);
-      this.lastKnownProgress.set(job.id, {
-        progress: 0,
-        message: "",
-        details: null
-      });
-      this.events.emit("job_start", this.queueName, job.id);
+      this.events.emit("job_start", job.id);
       const output = await this.executeJob(job, abortController.signal);
       await this.completeJob(job, output);
       this.processingTimes.set(job.id, Date.now() - startTime);
-      this.updateAverageProcessingTime();
     } catch (err) {
       const error = this.normalizeError(err);
       if (error instanceof RetryableJobError) {
@@ -707,85 +591,485 @@ class JobQueue {
       }
     } finally {
       await this.limiter.recordJobCompletion();
-      this.emitStatsUpdate();
     }
   }
-  async processJobs() {
-    if (!this.running) {
-      return;
+  async executeJob(job, signal) {
+    if (!job)
+      throw new JobNotFoundError("Cannot execute null or undefined job");
+    return await job.execute(job.input, {
+      signal,
+      updateProgress: this.updateProgress.bind(this, job.id)
+    });
+  }
+  async updateProgress(jobId, progress, message = "", details = null) {
+    progress = Math.max(0, Math.min(100, progress));
+    await this.storage.saveProgress(jobId, progress, message, details);
+    this.events.emit("job_progress", jobId, progress, message, details);
+  }
+  async completeJob(job, output) {
+    try {
+      job.status = JobStatus3.COMPLETED;
+      job.progress = 100;
+      job.progressMessage = "";
+      job.progressDetails = null;
+      job.completedAt = new Date;
+      job.output = output ?? null;
+      job.error = null;
+      job.errorCode = null;
+      await this.storage.complete(this.classToStorage(job));
+      this.events.emit("job_complete", job.id, output);
+    } catch (err) {
+      console.error("completeJob errored:", err);
+    } finally {
+      this.cleanupJob(job.id);
     }
+  }
+  async failJob(job, error) {
     try {
-      await this.cleanUpJobs();
-      const canProceed = await this.limiter.canProceed();
-      if (canProceed) {
-        const job = await this.next();
-        if (job) {
-          this.processSingleJob(job);
+      job.status = JobStatus3.FAILED;
+      job.progress = 100;
+      job.completedAt = new Date;
+      job.progressMessage = "";
+      job.progressDetails = null;
+      job.error = error.message;
+      job.errorCode = error?.constructor?.name ?? null;
+      await this.storage.complete(this.classToStorage(job));
+      this.events.emit("job_error", job.id, error.message, error.constructor.name);
+    } catch (err) {
+      console.error("failJob errored:", err);
+    } finally {
+      this.cleanupJob(job.id);
+    }
+  }
+  async disableJob(job) {
+    try {
+      job.status = JobStatus3.DISABLED;
+      job.progress = 100;
+      job.completedAt = new Date;
+      job.progressMessage = "";
+      job.progressDetails = null;
+      await this.storage.complete(this.classToStorage(job));
+      this.events.emit("job_disabled", job.id);
+    } catch (err) {
+      console.error("disableJob errored:", err);
+    } finally {
+      this.cleanupJob(job.id);
+    }
+  }
+  async rescheduleJob(job, retryDate) {
+    try {
+      job.status = JobStatus3.PENDING;
+      const nextAvailableTime = await this.limiter.getNextAvailableTime();
+      job.runAfter = retryDate instanceof Date ? retryDate : nextAvailableTime;
+      job.progress = 0;
+      job.progressMessage = "";
+      job.progressDetails = null;
+      await this.storage.complete(this.classToStorage(job));
+      this.events.emit("job_retry", job.id, job.runAfter);
+    } catch (err) {
+      console.error("rescheduleJob errored:", err);
+    }
+  }
+  createAbortController(jobId) {
+    if (!jobId)
+      throw new JobNotFoundError("Cannot create abort controller for undefined job");
+    if (this.activeJobAbortControllers.has(jobId)) {
+      return this.activeJobAbortControllers.get(jobId);
+    }
+    const abortController = new AbortController;
+    abortController.signal.addEventListener("abort", () => this.handleAbort(jobId));
+    this.activeJobAbortControllers.set(jobId, abortController);
+    return abortController;
+  }
+  async handleAbort(jobId) {
+    const job = await this.getJob(jobId);
+    if (!job) {
+      console.error("handleAbort: job not found", jobId);
+      return;
+    }
+    const error = new AbortSignalJobError("Job Aborted");
+    await this.failJob(job, error);
+  }
+  async getJob(id) {
+    const job = await this.storage.get(id);
+    if (!job)
+      return;
+    return this.storageToClass(job);
+  }
+  async validateJobState(job) {
+    if (job.status === JobStatus3.COMPLETED) {
+      throw new PermanentJobError(`Job ${job.id} is already completed`);
+    }
+    if (job.status === JobStatus3.FAILED) {
+      throw new PermanentJobError(`Job ${job.id} has failed`);
+    }
+    if (job.status === JobStatus3.ABORTING || this.activeJobAbortControllers.get(job.id)?.signal.aborted) {
+      throw new AbortSignalJobError(`Job ${job.id} is being aborted`);
+    }
+    if (job.deadlineAt && job.deadlineAt < new Date) {
+      throw new PermanentJobError(`Job ${job.id} has exceeded its deadline`);
+    }
+    if (job.status === JobStatus3.DISABLED) {
+      throw new JobDisabledError(`Job ${job.id} has been disabled`);
+    }
+  }
+  normalizeError(err) {
+    if (err instanceof JobError) {
+      return err;
+    }
+    if (err instanceof Error) {
+      return new PermanentJobError(err.message);
+    }
+    return new PermanentJobError(String(err));
+  }
+  cleanupJob(jobId) {
+    this.activeJobAbortControllers.delete(jobId);
+  }
+  storageToClass(details) {
+    const toDate = (date) => {
+      if (!date)
+        return null;
+      const d = new Date(date);
+      return isNaN(d.getTime()) ? null : d;
+    };
+    return new this.jobClass({
+      id: details.id,
+      jobRunId: details.job_run_id,
+      queueName: details.queue,
+      fingerprint: details.fingerprint,
+      input: details.input,
+      output: details.output,
+      runAfter: toDate(details.run_after),
+      createdAt: toDate(details.created_at),
+      deadlineAt: toDate(details.deadline_at),
+      lastRanAt: toDate(details.last_ran_at),
+      completedAt: toDate(details.completed_at),
+      progress: details.progress || 0,
+      progressMessage: details.progress_message || "",
+      progressDetails: details.progress_details ?? null,
+      status: details.status,
+      error: details.error ?? null,
+      errorCode: details.error_code ?? null,
+      runAttempts: details.run_attempts ?? 0,
+      maxRetries: details.max_retries ?? 10
+    });
+  }
+  classToStorage(job) {
+    const dateToISOString = (date) => {
+      if (!date)
+        return null;
+      return isNaN(date.getTime()) ? null : date.toISOString();
+    };
+    const now = new Date().toISOString();
+    return {
+      id: job.id,
+      job_run_id: job.jobRunId,
+      queue: job.queueName || this.queueName,
+      fingerprint: job.fingerprint,
+      input: job.input,
+      status: job.status,
+      output: job.output ?? null,
+      error: job.error === null ? null : String(job.error),
+      error_code: job.errorCode || null,
+      run_attempts: job.runAttempts ?? 0,
+      max_retries: job.maxRetries ?? 10,
+      run_after: dateToISOString(job.runAfter) ?? now,
+      created_at: dateToISOString(job.createdAt) ?? now,
+      deadline_at: dateToISOString(job.deadlineAt),
+      last_ran_at: dateToISOString(job.lastRanAt),
+      completed_at: dateToISOString(job.completedAt),
+      progress: job.progress ?? 0,
+      progress_message: job.progressMessage ?? "",
+      progress_details: job.progressDetails ?? null
+    };
+  }
+}
+
+// src/job/JobQueueServer.ts
+class JobQueueServer {
+  queueName;
+  storage;
+  jobClass;
+  limiter;
+  workerCount;
+  pollIntervalMs;
+  deleteAfterCompletionMs;
+  deleteAfterFailureMs;
+  deleteAfterDisabledMs;
+  cleanupIntervalMs;
+  events = new EventEmitter3;
+  workers = [];
+  clients = new Set;
+  running = false;
+  cleanupTimer = null;
+  stats = {
+    totalJobs: 0,
+    completedJobs: 0,
+    failedJobs: 0,
+    abortedJobs: 0,
+    retriedJobs: 0,
+    disabledJobs: 0,
+    lastUpdateTime: new Date
+  };
+  constructor(jobClass, options) {
+    this.queueName = options.queueName;
+    this.storage = options.storage;
+    this.jobClass = jobClass;
+    this.limiter = options.limiter ?? new NullLimiter;
+    this.workerCount = options.workerCount ?? 1;
+    this.pollIntervalMs = options.pollIntervalMs ?? 100;
+    this.deleteAfterCompletionMs = options.deleteAfterCompletionMs;
+    this.deleteAfterFailureMs = options.deleteAfterFailureMs;
+    this.deleteAfterDisabledMs = options.deleteAfterDisabledMs;
+    this.cleanupIntervalMs = options.cleanupIntervalMs ?? 1e4;
+    this.initializeWorkers();
+  }
+  async start() {
+    if (this.running) {
+      return this;
+    }
+    this.running = true;
+    this.events.emit("server_start", this.queueName);
+    await this.fixupJobs();
+    await Promise.all(this.workers.map((worker) => worker.start()));
+    this.startCleanupLoop();
+    return this;
+  }
+  async stop() {
+    if (!this.running) {
+      return this;
+    }
+    this.running = false;
+    if (this.cleanupTimer) {
+      clearTimeout(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    await Promise.all(this.workers.map((worker) => worker.stop()));
+    this.events.emit("server_stop", this.queueName);
+    return this;
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  getStorage() {
+    return this.storage;
+  }
+  async scaleWorkers(count) {
+    if (count < 1) {
+      throw new Error("Worker count must be at least 1");
+    }
+    const currentCount = this.workers.length;
+    if (count > currentCount) {
+      for (let i = currentCount;i < count; i++) {
+        const worker = this.createWorker();
+        this.workers.push(worker);
+        if (this.running) {
+          await worker.start();
         }
       }
-    } finally {
-      setTimeout(() => this.processJobs(), this.options.waitDurationInMilliseconds);
-    }
+    } else if (count < currentCount) {
+      const toRemove = this.workers.splice(count);
+      await Promise.all(toRemove.map((worker) => worker.stop()));
+    }
+  }
+  isRunning() {
+    return this.running;
+  }
+  getWorkerCount() {
+    return this.workers.length;
+  }
+  addClient(client) {
+    this.clients.add(client);
+  }
+  removeClient(client) {
+    this.clients.delete(client);
+  }
+  on(event, listener) {
+    this.events.on(event, listener);
+  }
+  off(event, listener) {
+    this.events.off(event, listener);
+  }
+  initializeWorkers() {
+    for (let i = 0;i < this.workerCount; i++) {
+      const worker = this.createWorker();
+      this.workers.push(worker);
+    }
+  }
+  createWorker() {
+    const worker = new JobQueueWorker(this.jobClass, {
+      storage: this.storage,
+      queueName: this.queueName,
+      limiter: this.limiter,
+      pollIntervalMs: this.pollIntervalMs
+    });
+    worker.on("job_start", (jobId) => {
+      this.stats = { ...this.stats, totalJobs: this.stats.totalJobs + 1 };
+      this.events.emit("job_start", this.queueName, jobId);
+      this.forwardToClients("handleJobStart", jobId);
+    });
+    worker.on("job_complete", async (jobId, output) => {
+      this.stats = { ...this.stats, completedJobs: this.stats.completedJobs + 1 };
+      this.updateAverageProcessingTime();
+      this.events.emit("job_complete", this.queueName, jobId, output);
+      this.forwardToClients("handleJobComplete", jobId, output);
+      if (this.deleteAfterCompletionMs === 0) {
+        await this.storage.delete(jobId);
+      }
+    });
+    worker.on("job_error", async (jobId, error, errorCode) => {
+      this.stats = { ...this.stats, failedJobs: this.stats.failedJobs + 1 };
+      this.events.emit("job_error", this.queueName, jobId, error);
+      this.forwardToClients("handleJobError", jobId, error, errorCode);
+      if (this.deleteAfterFailureMs === 0) {
+        await this.storage.delete(jobId);
+      }
+    });
+    worker.on("job_disabled", async (jobId) => {
+      this.stats = { ...this.stats, disabledJobs: this.stats.disabledJobs + 1 };
+      this.events.emit("job_disabled", this.queueName, jobId);
+      this.forwardToClients("handleJobDisabled", jobId);
+      if (this.deleteAfterDisabledMs === 0) {
+        await this.storage.delete(jobId);
+      }
+    });
+    worker.on("job_retry", (jobId, runAfter) => {
+      this.stats = { ...this.stats, retriedJobs: this.stats.retriedJobs + 1 };
+      this.events.emit("job_retry", this.queueName, jobId, runAfter);
+      this.forwardToClients("handleJobRetry", jobId, runAfter);
+    });
+    worker.on("job_progress", (jobId, progress, message, details) => {
+      this.events.emit("job_progress", this.queueName, jobId, progress, message, details);
+      this.forwardToClients("handleJobProgress", jobId, progress, message, details);
+    });
+    return worker;
   }
-  async cleanUpJobs() {
-    const abortingJobs = await this.peek(JobStatus.ABORTING);
-    for (const job of abortingJobs) {
-      await this.handleAbort(job.id);
+  forwardToClients(method, ...args) {
+    for (const client of this.clients) {
+      const fn = client[method];
+      if (typeof fn === "function") {
+        fn.apply(client, args);
+      }
     }
-    if (this.options.deleteAfterCompletionMs) {
-      await this.storage.deleteJobsByStatusAndAge(JobStatus.COMPLETED, this.options.deleteAfterCompletionMs);
+  }
+  updateAverageProcessingTime() {
+    const times = [];
+    for (const worker of this.workers) {
+      const avgTime = worker.getAverageProcessingTime();
+      if (avgTime !== undefined) {
+        times.push(avgTime);
+      }
     }
-    if (this.options.deleteAfterFailureMs) {
-      await this.storage.deleteJobsByStatusAndAge(JobStatus.FAILED, this.options.deleteAfterFailureMs);
+    if (times.length > 0) {
+      const avg = times.reduce((a, b) => a + b, 0) / times.length;
+      this.stats = {
+        ...this.stats,
+        averageProcessingTime: avg,
+        lastUpdateTime: new Date
+      };
     }
   }
-  async monitorJobs() {
-    if (!this.running) {
+  startCleanupLoop() {
+    if (!this.running)
       return;
-    }
+    this.cleanupJobs().finally(() => {
+      if (this.running) {
+        this.cleanupTimer = setTimeout(() => this.startCleanupLoop(), this.cleanupIntervalMs);
+      }
+    });
+  }
+  async cleanupJobs() {
     try {
-      const jobIds = Array.from(this.jobProgressListeners.keys());
-      for (const jobId of jobIds) {
-        const job = await this.get(jobId);
-        if (job) {
-          const currentProgress = {
-            progress: job.progress,
-            message: job.progressMessage,
-            details: job.progressDetails || null
-          };
-          const lastProgress = this.lastKnownProgress.get(jobId);
-          const hasChanged = !lastProgress || lastProgress.progress !== currentProgress.progress || lastProgress.message !== currentProgress.message;
-          if (hasChanged && currentProgress.progress !== 0 && currentProgress.message !== "") {
-            this.announceProgress(jobId, currentProgress.progress, currentProgress.message, currentProgress.details);
-          }
-        }
+      if (this.deleteAfterCompletionMs !== undefined && this.deleteAfterCompletionMs > 0) {
+        await this.storage.deleteJobsByStatusAndAge(JobStatus4.COMPLETED, this.deleteAfterCompletionMs);
       }
-      for (const jobId of this.lastKnownProgress.keys()) {
-        const job = await this.get(jobId);
-        if (!job || job.status === JobStatus.COMPLETED || job.status === JobStatus.FAILED) {
-          this.lastKnownProgress.delete(jobId);
-        }
+      if (this.deleteAfterFailureMs !== undefined && this.deleteAfterFailureMs > 0) {
+        await this.storage.deleteJobsByStatusAndAge(JobStatus4.FAILED, this.deleteAfterFailureMs);
+      }
+      if (this.deleteAfterDisabledMs !== undefined && this.deleteAfterDisabledMs > 0) {
+        await this.storage.deleteJobsByStatusAndAge(JobStatus4.DISABLED, this.deleteAfterDisabledMs);
       }
     } catch (error) {
-      console.error(`Error in monitorJobs: ${error}`);
+      console.error("Error in cleanup:", error);
     }
-    setTimeout(() => this.monitorJobs(), this.options.waitDurationInMilliseconds);
   }
   async fixupJobs() {
-    const stuckProcessingJobs = await this.peek(JobStatus.PROCESSING);
-    const stuckAbortingJobs = await this.peek(JobStatus.ABORTING);
-    const stuckJobs = [...stuckProcessingJobs, ...stuckAbortingJobs];
-    for (const job of stuckJobs) {
-      job.status = JobStatus.PENDING;
-      job.runAfter = job.lastRanAt || new Date;
-      job.progress = 0;
-      job.progressMessage = "";
-      job.progressDetails = null;
-      job.error = "Restarting server";
-      await this.storage.complete(this.classToStorage(job));
-      await this.rescheduleJob(job, job.lastRanAt);
+    try {
+      const stuckProcessingJobs = await this.storage.peek(JobStatus4.PROCESSING);
+      const stuckAbortingJobs = await this.storage.peek(JobStatus4.ABORTING);
+      const stuckJobs = [...stuckProcessingJobs, ...stuckAbortingJobs];
+      for (const jobData of stuckJobs) {
+        const job = this.storageToClass(jobData);
+        job.status = JobStatus4.PENDING;
+        job.runAfter = job.lastRanAt || new Date;
+        job.progress = 0;
+        job.progressMessage = "";
+        job.progressDetails = null;
+        job.error = "Server restarted";
+        await this.storage.complete(this.classToStorage(job));
+      }
+    } catch (error) {
+      console.error("Error in fixupJobs:", error);
     }
   }
+  storageToClass(details) {
+    const toDate = (date) => {
+      if (!date)
+        return null;
+      const d = new Date(date);
+      return isNaN(d.getTime()) ? null : d;
+    };
+    return new this.jobClass({
+      id: details.id,
+      jobRunId: details.job_run_id,
+      queueName: details.queue,
+      fingerprint: details.fingerprint,
+      input: details.input,
+      output: details.output,
+      runAfter: toDate(details.run_after),
+      createdAt: toDate(details.created_at),
+      deadlineAt: toDate(details.deadline_at),
+      lastRanAt: toDate(details.last_ran_at),
+      completedAt: toDate(details.completed_at),
+      progress: details.progress || 0,
+      progressMessage: details.progress_message || "",
+      progressDetails: details.progress_details ?? null,
+      status: details.status,
+      error: details.error ?? null,
+      errorCode: details.error_code ?? null,
+      runAttempts: details.run_attempts ?? 0,
+      maxRetries: details.max_retries ?? 10
+    });
+  }
+  classToStorage(job) {
+    const dateToISOString = (date) => {
+      if (!date)
+        return null;
+      return isNaN(date.getTime()) ? null : date.toISOString();
+    };
+    const now = new Date().toISOString();
+    return {
+      id: job.id,
+      job_run_id: job.jobRunId,
+      queue: job.queueName || this.queueName,
+      fingerprint: job.fingerprint,
+      input: job.input,
+      status: job.status,
+      output: job.output ?? null,
+      error: job.error === null ? null : String(job.error),
+      error_code: job.errorCode || null,
+      run_attempts: job.runAttempts ?? 0,
+      max_retries: job.maxRetries ?? 10,
+      run_after: dateToISOString(job.runAfter) ?? now,
+      created_at: dateToISOString(job.createdAt) ?? now,
+      deadline_at: dateToISOString(job.deadlineAt),
+      last_ran_at: dateToISOString(job.lastRanAt),
+      completed_at: dateToISOString(job.completedAt),
+      progress: job.progress ?? 0,
+      progress_message: job.progressMessage ?? "",
+      progress_details: job.progressDetails ?? null
+    };
+  }
 }
 // src/limiter/CompositeLimiter.ts
 class CompositeLimiter {
@@ -830,8 +1114,8 @@ class CompositeLimiter {
   }
 }
 // src/limiter/ConcurrencyLimiter.ts
-import { createServiceToken as createServiceToken3 } from "@workglow/util";
-var CONCURRENT_JOB_LIMITER = createServiceToken3("jobqueue.limiter.concurrent");
+import { createServiceToken as createServiceToken2 } from "@workglow/util";
+var CONCURRENT_JOB_LIMITER = createServiceToken2("jobqueue.limiter.concurrent");
 
 class ConcurrencyLimiter {
   currentRunningJobs = 0;
@@ -894,8 +1178,8 @@ class DelayLimiter {
   }
 }
 // src/limiter/EvenlySpacedRateLimiter.ts
-import { createServiceToken as createServiceToken4 } from "@workglow/util";
-var EVENLY_SPACED_JOB_RATE_LIMITER = createServiceToken4("jobqueue.limiter.rate.evenlyspaced");
+import { createServiceToken as createServiceToken3 } from "@workglow/util";
+var EVENLY_SPACED_JOB_RATE_LIMITER = createServiceToken3("jobqueue.limiter.rate.evenlyspaced");
 
 class EvenlySpacedRateLimiter {
   maxExecutions;
@@ -954,117 +1238,27 @@ class EvenlySpacedRateLimiter {
     this.lastStartTime = 0;
   }
 }
-// src/limiter/InMemoryRateLimiter.ts
-import { createServiceToken as createServiceToken5 } from "@workglow/util";
-var MEMORY_JOB_RATE_LIMITER = createServiceToken5("jobqueue.limiter.rate.memory");
-
-class InMemoryRateLimiter {
-  requests = [];
-  nextAvailableTime = new Date;
+// src/limiter/ILimiter.ts
+import { createServiceToken as createServiceToken4 } from "@workglow/util";
+var JOB_LIMITER = createServiceToken4("jobqueue.limiter");
+// src/limiter/RateLimiter.ts
+class RateLimiter {
+  storage;
+  queueName;
+  windowSizeInMilliseconds;
   currentBackoffDelay;
   maxExecutions;
-  windowSizeInMilliseconds;
   initialBackoffDelay;
   backoffMultiplier;
   maxBackoffDelay;
-  constructor({
-    maxExecutions,
-    windowSizeInSeconds,
-    initialBackoffDelay = 1000,
-    backoffMultiplier = 2,
-    maxBackoffDelay = 600000
-  }) {
-    if (maxExecutions <= 0) {
-      throw new Error("maxExecutions must be greater than 0");
-    }
-    if (windowSizeInSeconds <= 0) {
-      throw new Error("windowSizeInSeconds must be greater than 0");
-    }
-    if (initialBackoffDelay <= 0) {
-      throw new Error("initialBackoffDelay must be greater than 0");
-    }
-    if (backoffMultiplier <= 1) {
-      throw new Error("backoffMultiplier must be greater than 1");
-    }
-    if (maxBackoffDelay <= initialBackoffDelay) {
-      throw new Error("maxBackoffDelay must be greater than initialBackoffDelay");
-    }
-    this.maxExecutions = maxExecutions;
-    this.windowSizeInMilliseconds = windowSizeInSeconds * 1000;
-    this.initialBackoffDelay = initialBackoffDelay;
-    this.backoffMultiplier = backoffMultiplier;
-    this.maxBackoffDelay = maxBackoffDelay;
-    this.currentBackoffDelay = initialBackoffDelay;
-  }
-  removeOldRequests() {
-    const now = Date.now();
-    const cutoff = now - this.windowSizeInMilliseconds;
-    this.requests = this.requests.filter((d) => d.getTime() > cutoff);
-    if (this.nextAvailableTime.getTime() < now) {
-      this.nextAvailableTime = new Date(now);
-    }
-  }
-  increaseBackoff() {
-    this.currentBackoffDelay = Math.min(this.currentBackoffDelay * this.backoffMultiplier, this.maxBackoffDelay);
-  }
-  addJitter(base) {
-    return base + Math.random() * base;
-  }
-  async canProceed() {
-    this.removeOldRequests();
-    const now = Date.now();
-    const okRequestCount = this.requests.length < this.maxExecutions;
-    const okTime = now >= this.nextAvailableTime.getTime();
-    const canProceedNow = okRequestCount && okTime;
-    if (!canProceedNow) {
-      this.increaseBackoff();
-    } else {
-      this.currentBackoffDelay = this.initialBackoffDelay;
-    }
-    return canProceedNow;
-  }
-  async recordJobStart() {
-    this.requests.push(new Date);
-    if (this.requests.length >= this.maxExecutions) {
-      const earliest = this.requests[0].getTime();
-      const windowExpires = earliest + this.windowSizeInMilliseconds;
-      const backoffExpires = Date.now() + this.addJitter(this.currentBackoffDelay);
-      this.nextAvailableTime = new Date(Math.max(windowExpires, backoffExpires));
-    }
-  }
-  async recordJobCompletion() {}
-  async getNextAvailableTime() {
-    this.removeOldRequests();
-    return new Date(Math.max(Date.now(), this.nextAvailableTime.getTime()));
-  }
-  async setNextAvailableTime(date) {
-    if (date.getTime() > this.nextAvailableTime.getTime()) {
-      this.nextAvailableTime = date;
-    }
-  }
-  async clear() {
-    this.requests = [];
-    this.nextAvailableTime = new Date;
-    this.currentBackoffDelay = this.initialBackoffDelay;
-  }
-}
-// src/limiter/PostgresRateLimiter.ts
-import { createServiceToken as createServiceToken6 } from "@workglow/util";
-var POSTGRES_JOB_RATE_LIMITER = createServiceToken6("jobqueue.limiter.rate.postgres");
-
-class PostgresRateLimiter {
-  db;
-  queueName;
-  windowSizeInMilliseconds;
-  currentBackoffDelay;
-  constructor(db, queueName, {
+  constructor(storage, queueName, {
     maxExecutions,
     windowSizeInSeconds,
     initialBackoffDelay = 1000,
     backoffMultiplier = 2,
     maxBackoffDelay = 600000
   }) {
-    this.db = db;
+    this.storage = storage;
     this.queueName = queueName;
     if (maxExecutions <= 0) {
       throw new Error("maxExecutions must be greater than 0");
@@ -1087,281 +1281,87 @@ class PostgresRateLimiter {
     this.backoffMultiplier = backoffMultiplier;
     this.maxBackoffDelay = maxBackoffDelay;
     this.currentBackoffDelay = initialBackoffDelay;
-    this.dbPromise = this.ensureTableExists();
   }
-  maxExecutions;
-  initialBackoffDelay;
-  backoffMultiplier;
-  maxBackoffDelay;
-  dbPromise;
   addJitter(base) {
     return base + Math.random() * base;
   }
   increaseBackoff() {
     this.currentBackoffDelay = Math.min(this.currentBackoffDelay * this.backoffMultiplier, this.maxBackoffDelay);
   }
-  async ensureTableExists() {
-    await this.db.query(`
-      CREATE TABLE IF NOT EXISTS job_queue_execution_tracking (
-        id SERIAL PRIMARY KEY,
-        queue_name TEXT NOT NULL,
-        executed_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      )
-    `);
-    await this.db.query(`
-      CREATE TABLE IF NOT EXISTS job_queue_next_available (
-        queue_name TEXT PRIMARY KEY,
-        next_available_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-      )
-    `);
-  }
-  async clear() {
-    await this.dbPromise;
-    await this.db.query(`DELETE FROM job_queue_execution_tracking WHERE queue_name = $1`, [
-      this.queueName
-    ]);
-    await this.db.query(`DELETE FROM job_queue_next_available WHERE queue_name = $1`, [
-      this.queueName
-    ]);
-  }
   async canProceed() {
-    await this.dbPromise;
-    const nextAvailableResult = await this.db.query(`
-      SELECT next_available_at
-      FROM job_queue_next_available
-      WHERE queue_name = $1
-    `, [this.queueName]);
-    const nextAvailableTime = nextAvailableResult.rows[0]?.next_available_at;
-    if (nextAvailableTime && new Date(nextAvailableTime).getTime() > Date.now()) {
-      this.increaseBackoff();
-      return false;
-    }
-    const result = await this.db.query(`
-      SELECT 
-        COUNT(*) AS attempt_count
-      FROM job_queue_execution_tracking
-      WHERE 
-        queue_name = $1
-        AND executed_at > $2
-    `, [this.queueName, new Date(Date.now() - this.windowSizeInMilliseconds).toISOString()]);
-    const attemptCount = result.rows[0]?.attempt_count;
+    const windowStartTime = new Date(Date.now() - this.windowSizeInMilliseconds).toISOString();
+    const attemptCount = await this.storage.getExecutionCount(this.queueName, windowStartTime);
     const canProceedNow = attemptCount < this.maxExecutions;
-    if (!canProceedNow) {
-      this.increaseBackoff();
-    } else {
+    if (canProceedNow) {
+      const nextAvailableTime2 = await this.storage.getNextAvailableTime(this.queueName);
+      if (nextAvailableTime2 && new Date(nextAvailableTime2).getTime() > Date.now()) {
+        const pastTime = new Date(Date.now() - 1000);
+        await this.storage.setNextAvailableTime(this.queueName, pastTime.toISOString());
+      }
       this.currentBackoffDelay = this.initialBackoffDelay;
+      return true;
     }
-    return canProceedNow;
-  }
-  async recordJobStart() {
-    await this.dbPromise;
-    await this.db.query(`
-      INSERT INTO job_queue_execution_tracking (queue_name)
-      VALUES ($1)
-    `, [this.queueName]);
-    const result = await this.db.query(`
-      SELECT COUNT(*) AS attempt_count
-      FROM job_queue_execution_tracking
-      WHERE queue_name = $1
-    `, [this.queueName]);
-    if (result.rows[0].attempt_count >= this.maxExecutions) {
-      const backoffExpires = new Date(Date.now() + this.addJitter(this.currentBackoffDelay));
-      await this.setNextAvailableTime(backoffExpires);
-    }
-  }
-  async recordJobCompletion() {}
-  async getNextAvailableTime() {
-    await this.dbPromise;
-    const result = await this.db.query(`
-      SELECT executed_at
-      FROM job_queue_execution_tracking
-      WHERE queue_name = $1
-      ORDER BY executed_at ASC
-      LIMIT 1 OFFSET $2
-    `, [this.queueName, this.maxExecutions - 1]);
-    const oldestExecution = result.rows[0];
-    let rateLimitedTime = new Date;
-    if (oldestExecution) {
-      rateLimitedTime = new Date(oldestExecution.executed_at);
-      rateLimitedTime.setSeconds(rateLimitedTime.getSeconds() + this.windowSizeInMilliseconds / 1000);
-    }
-    const nextAvailableResult = await this.db.query(`
-      SELECT next_available_at
-      FROM job_queue_next_available
-      WHERE queue_name = $1
-    `, [this.queueName]);
-    let nextAvailableTime = new Date;
-    if (nextAvailableResult?.rows[0]?.next_available_at) {
-      nextAvailableTime = new Date(nextAvailableResult.rows[0].next_available_at);
-    }
-    return nextAvailableTime > rateLimitedTime ? nextAvailableTime : rateLimitedTime;
-  }
-  async setNextAvailableTime(date) {
-    await this.dbPromise;
-    await this.db.query(`
-      INSERT INTO job_queue_next_available (queue_name, next_available_at)
-      VALUES ($1, $2)
-      ON CONFLICT (queue_name)
-      DO UPDATE SET next_available_at = EXCLUDED.next_available_at;
-    `, [this.queueName, date.toISOString()]);
-  }
-}
-// src/limiter/SqliteRateLimiter.ts
-import { createServiceToken as createServiceToken7, toSQLiteTimestamp } from "@workglow/util";
-var SQLITE_JOB_RATE_LIMITER = createServiceToken7("jobqueue.limiter.rate.sqlite");
-
-class SqliteRateLimiter {
-  db;
-  queueName;
-  windowSizeInMilliseconds;
-  currentBackoffDelay;
-  constructor(db, queueName, {
-    maxExecutions,
-    windowSizeInSeconds,
-    initialBackoffDelay = 1000,
-    backoffMultiplier = 2,
-    maxBackoffDelay = 600000
-  }) {
-    if (maxExecutions <= 0) {
-      throw new Error("maxExecutions must be greater than 0");
-    }
-    if (windowSizeInSeconds <= 0) {
-      throw new Error("windowSizeInSeconds must be greater than 0");
-    }
-    if (initialBackoffDelay <= 0) {
-      throw new Error("initialBackoffDelay must be greater than 0");
-    }
-    if (backoffMultiplier <= 1) {
-      throw new Error("backoffMultiplier must be greater than 1");
-    }
-    if (maxBackoffDelay <= initialBackoffDelay) {
-      throw new Error("maxBackoffDelay must be greater than initialBackoffDelay");
-    }
-    this.db = db;
-    this.queueName = queueName;
-    this.windowSizeInMilliseconds = windowSizeInSeconds * 1000;
-    this.maxExecutions = maxExecutions;
-    this.initialBackoffDelay = initialBackoffDelay;
-    this.backoffMultiplier = backoffMultiplier;
-    this.maxBackoffDelay = maxBackoffDelay;
-    this.currentBackoffDelay = initialBackoffDelay;
-    this.ensureTableExists();
-  }
-  maxExecutions;
-  initialBackoffDelay;
-  backoffMultiplier;
-  maxBackoffDelay;
-  addJitter(base) {
-    return base + Math.random() * base;
-  }
-  increaseBackoff() {
-    this.currentBackoffDelay = Math.min(this.currentBackoffDelay * this.backoffMultiplier, this.maxBackoffDelay);
-  }
-  ensureTableExists() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS job_queue_execution_tracking (
-        id INTEGER PRIMARY KEY,
-        queue_name TEXT NOT NULL,
-        executed_at TEXT DEFAULT CURRENT_TIMESTAMP
-      )
-    `);
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS job_queue_next_available (
-        queue_name TEXT PRIMARY KEY,
-        next_available_at TEXT
-      )
-    `);
-    return this;
-  }
-  async clear() {
-    this.db.prepare("DELETE FROM job_queue_execution_tracking WHERE queue_name = ?").run(this.queueName);
-    this.db.prepare("DELETE FROM job_queue_next_available WHERE queue_name = ?").run(this.queueName);
-  }
-  async canProceed() {
-    const nextAvailableTimeStmt = this.db.prepare(`
-      SELECT next_available_at
-      FROM job_queue_next_available
-      WHERE queue_name = ?`);
-    const nextAvailableResult = nextAvailableTimeStmt.get(this.queueName);
-    if (nextAvailableResult && new Date(nextAvailableResult.next_available_at + "Z").getTime() > Date.now()) {
+    const nextAvailableTime = await this.storage.getNextAvailableTime(this.queueName);
+    if (nextAvailableTime && new Date(nextAvailableTime).getTime() > Date.now()) {
       this.increaseBackoff();
       return false;
     }
-    const thresholdTime = toSQLiteTimestamp(new Date(Date.now() - this.windowSizeInMilliseconds));
-    const result = this.db.prepare(`SELECT COUNT(*) AS attempt_count
-          FROM job_queue_execution_tracking
-          WHERE queue_name = ? AND executed_at > ?`).get(this.queueName, thresholdTime);
-    const canProceedNow = result.attempt_count < this.maxExecutions;
-    if (!canProceedNow) {
-      this.increaseBackoff();
-    } else {
-      this.currentBackoffDelay = this.initialBackoffDelay;
-    }
-    return canProceedNow;
+    this.increaseBackoff();
+    return false;
   }
   async recordJobStart() {
-    const stmt = this.db.prepare(`INSERT INTO job_queue_execution_tracking (queue_name)
-          VALUES (?)`).run(this.queueName);
-    const result = this.db.prepare(`SELECT COUNT(*) AS attempt_count
-          FROM job_queue_execution_tracking
-          WHERE queue_name = ?`).get(this.queueName);
-    if (result.attempt_count >= this.maxExecutions) {
+    await this.storage.recordExecution(this.queueName);
+    const windowStartTime = new Date(Date.now() - this.windowSizeInMilliseconds).toISOString();
+    const attemptCount = await this.storage.getExecutionCount(this.queueName, windowStartTime);
+    if (attemptCount >= this.maxExecutions) {
       const backoffExpires = new Date(Date.now() + this.addJitter(this.currentBackoffDelay));
       await this.setNextAvailableTime(backoffExpires);
+    } else {
+      const nextAvailableTime = await this.storage.getNextAvailableTime(this.queueName);
+      if (nextAvailableTime && new Date(nextAvailableTime).getTime() > Date.now()) {
+        const pastTime = new Date(Date.now() - 1000);
+        await this.storage.setNextAvailableTime(this.queueName, pastTime.toISOString());
+      }
     }
   }
   async recordJobCompletion() {}
   async getNextAvailableTime() {
-    const rateLimitedTimeStmt = this.db.prepare(`
-      SELECT executed_at
-      FROM job_queue_execution_tracking
-      WHERE queue_name = ?
-      ORDER BY executed_at ASC
-      LIMIT 1 OFFSET ?`);
-    const oldestExecution = rateLimitedTimeStmt.get(this.queueName, this.maxExecutions - 1);
+    const oldestExecution = await this.storage.getOldestExecutionAtOffset(this.queueName, this.maxExecutions - 1);
     let rateLimitedTime = new Date;
     if (oldestExecution) {
-      rateLimitedTime = new Date(oldestExecution.executed_at + "Z");
+      rateLimitedTime = new Date(oldestExecution);
       rateLimitedTime.setSeconds(rateLimitedTime.getSeconds() + this.windowSizeInMilliseconds / 1000);
     }
-    const nextAvailableStmt = this.db.prepare(`
-      SELECT next_available_at
-      FROM job_queue_next_available
-      WHERE queue_name = ?`);
-    const nextAvailableResult = nextAvailableStmt.get(this.queueName);
+    const nextAvailableStr = await this.storage.getNextAvailableTime(this.queueName);
     let nextAvailableTime = new Date;
-    if (nextAvailableResult?.next_available_at) {
-      nextAvailableTime = new Date(nextAvailableResult.next_available_at + "Z");
+    if (nextAvailableStr) {
+      nextAvailableTime = new Date(nextAvailableStr);
     }
     return nextAvailableTime > rateLimitedTime ? nextAvailableTime : rateLimitedTime;
   }
   async setNextAvailableTime(date) {
-    const nextAvailableAt = date.toISOString();
-    this.db.prepare(`
-        INSERT INTO job_queue_next_available (queue_name, next_available_at)
-        VALUES (?, ?)
-        ON CONFLICT(queue_name) DO UPDATE SET next_available_at = excluded.next_available_at`).run(this.queueName, nextAvailableAt);
+    await this.storage.setNextAvailableTime(this.queueName, date.toISOString());
+  }
+  async clear() {
+    await this.storage.clear(this.queueName);
+    this.currentBackoffDelay = this.initialBackoffDelay;
   }
 }
 export {
-  SqliteRateLimiter,
-  SQLITE_JOB_RATE_LIMITER,
   RetryableJobError,
-  QueueMode,
-  PostgresRateLimiter,
+  RateLimiter,
   PermanentJobError,
-  POSTGRES_JOB_RATE_LIMITER,
   NullLimiter,
   NULL_JOB_LIMITER,
-  MEMORY_JOB_RATE_LIMITER,
   JobStatus,
-  JobQueue,
+  JobQueueWorker,
+  JobQueueServer,
+  JobQueueClient,
   JobNotFoundError,
   JobError,
   JobDisabledError,
   Job,
   JOB_LIMITER,
-  InMemoryRateLimiter,
   EvenlySpacedRateLimiter,
   EVENLY_SPACED_JOB_RATE_LIMITER,
   DelayLimiter,
@@ -1371,4 +1371,4 @@ export {
   AbortSignalJobError
 };
 
-//# debugId=07DD6CB9BADC5C7264756E2164756E21
+//# debugId=FA4EC42EC92F7AF264756E2164756E21