@igniter-js/jobs 0.1.0 → 0.1.12

package/dist/adapters/index.js

@@ -1,870 +1,1488 @@
 'use strict';
 
-var core = require('@igniter-js/core');
+var adapterBullmq = require('@igniter-js/adapter-bullmq');
+var common = require('@igniter-js/common');
 
-// src/errors/igniter-jobs.error.ts
-var IgniterJobsError = class _IgniterJobsError extends core.IgniterError {
-  constructor(options) {
-    super({
-      code: options.code,
-      message: options.message,
-      statusCode: options.statusCode ?? 500,
-      causer: "@igniter-js/jobs",
-      cause: options.cause,
-      details: options.details,
-      logger: options.logger
-    });
-    this.code = options.code;
-    this.details = options.details;
-    this.name = "IgniterJobsError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _IgniterJobsError);
-    }
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/prefix.ts
+var _IgniterJobsPrefix = class _IgniterJobsPrefix {
+  /**
+   * Builds a normalized queue name using the global prefix and queue id.
+   *
+   * @example
+   * ```typescript
+   * const name = IgniterJobsPrefix.buildQueueName('email')
+   * // -> igniter:jobs:email
+   * ```
+   */
+  static buildQueueName(queue) {
+    return `${_IgniterJobsPrefix.BASE_PREFIX}:${queue}`;
   }
   /**
-   * Convert error to a plain object for serialization.
+   * Builds the event channel used for pub/sub.
+   *
+   * Unscoped events are published to a global channel per service/environment.
+   * Scoped events are also published to an additional channel for that scope.
    */
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      statusCode: this.statusCode,
-      details: this.details,
-      stack: this.stack
-    };
+  static buildEventsChannel(params) {
+    const base = `${_IgniterJobsPrefix.BASE_PREFIX}:events:${params.environment}:${params.service}`;
+    if (!params.scope) return base;
+    return `${base}:scope:${params.scope.type}:${params.scope.id}`;
+  }
+};
+_IgniterJobsPrefix.BASE_PREFIX = "igniter:jobs";
+var IgniterJobsPrefix = _IgniterJobsPrefix;
+var IgniterJobsError = class extends common.IgniterError {
+  constructor(options) {
+    super(options);
   }
 };
 
 // src/adapters/bullmq.adapter.ts
-var BullMQAdapter = class _BullMQAdapter {
+function toDateArray(values) {
+  if (!values) return void 0;
+  return values.map((v) => v instanceof Date ? v : new Date(v));
+}
+var IgniterJobsBullMQAdapter = class _IgniterJobsBullMQAdapter {
   constructor(options) {
-    this.queues = /* @__PURE__ */ new Map();
-    this.workers = /* @__PURE__ */ new Map();
-    this.queueEvents = /* @__PURE__ */ new Map();
-    this.BullMQ = null;
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.coreAdapter = null;
+    this.coreExecutor = null;
+    this.executorDirty = true;
+    this.jobsByQueue = /* @__PURE__ */ new Map();
+    this.cronsByQueue = /* @__PURE__ */ new Map();
     this.redis = options.redis;
+    this.publisher = this.redis;
+    this.subscriber = this.redis.duplicate();
+    this.client = { redis: this.redis };
+    this.subscriber.on("message", (channel, message) => {
+      const set = this.subscribers.get(channel);
+      if (!set || set.size === 0) return;
+      let payload = message;
+      try {
+        payload = JSON.parse(message);
+      } catch {
+      }
+      for (const handler of set) handler(payload);
+    });
+    this.queues = {
+      list: async () => this.listQueues(),
+      get: async (name) => this.getQueueInfo(name),
+      getJobCounts: async (name) => this.getQueueJobCounts(name),
+      getJobs: async (name, filter) => {
+        const full = this.toCoreQueueName(name);
+        return this.core().queues.getJobs(full, filter);
+      },
+      pause: async (name) => this.pauseQueue(name),
+      resume: async (name) => this.resumeQueue(name),
+      isPaused: async (name) => {
+        const full = this.toCoreQueueName(name);
+        return this.core().queues.isPaused(full);
+      },
+      drain: async (name) => this.drainQueue(name),
+      clean: async (name, options2) => this.cleanQueue(name, options2),
+      obliterate: async (name, options2) => this.obliterateQueue(name, options2)
+    };
   }
-  /**
-   * Create a new BullMQ adapter.
-   *
-   * @param options - Adapter options with Redis connection
-   * @returns A new BullMQAdapter instance
-   */
   static create(options) {
-    return new _BullMQAdapter(options);
-  }
-  /**
-   * Get the underlying Redis client.
-   */
-  get client() {
-    return this.redis;
-  }
-  /**
-   * Lazily load BullMQ module.
-   */
-  async getBullMQ() {
-    if (!this.BullMQ) {
-      this.BullMQ = await import('bullmq');
-    }
-    return this.BullMQ;
+    return new _IgniterJobsBullMQAdapter(options);
   }
-  /**
-   * Get or create a queue instance.
-   */
-  async getOrCreateQueue(name) {
-    if (!this.queues.has(name)) {
-      const { Queue } = await this.getBullMQ();
-      const queue = new Queue(name, {
-        connection: this.redis
+  registerJob(queueName, jobName, definition) {
+    const map = this.jobsByQueue.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (map.has(jobName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_DUPLICATE_JOB",
+        message: `Job "${jobName}" is already registered in queue "${queueName}".`
       });
-      this.queues.set(name, queue);
     }
-    return this.queues.get(name);
+    map.set(jobName, definition);
+    this.jobsByQueue.set(queueName, map);
+    this.executorDirty = true;
   }
-  /**
-   * Get or create queue events instance.
-   */
-  async getQueueEvents(name) {
-    if (!this.queueEvents.has(name)) {
-      const { QueueEvents } = await this.getBullMQ();
-      const events = new QueueEvents(name, {
-        connection: this.redis
+  registerCron(queueName, cronName, definition) {
+    const map = this.cronsByQueue.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (map.has(cronName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" is already registered in queue "${queueName}".`
       });
-      this.queueEvents.set(name, events);
     }
-    return this.queueEvents.get(name);
-  }
-  /**
-   * Convert BullMQ job state to IgniterJobStatus.
-   */
-  mapJobState(state) {
-    const stateMap = {
-      waiting: "waiting",
-      active: "active",
-      completed: "completed",
-      failed: "failed",
-      delayed: "delayed",
-      paused: "paused",
-      "waiting-children": "waiting"
-    };
-    return stateMap[state] || "waiting";
-  }
-  /**
-   * Convert BullMQ job to IgniterJobInfo.
-   */
-  async mapJobToInfo(job) {
-    const data = job.data;
-    const state = await job.getState();
-    return {
-      id: job.id,
-      name: job.name,
-      queue: job.queueName,
-      state: this.mapJobState(state || "waiting"),
-      data: data.input ?? data,
-      result: job.returnvalue,
-      error: job.failedReason,
-      progress: typeof job.progress === "number" ? job.progress : 0,
-      attempts: job.attemptsMade,
-      timestamp: job.timestamp,
-      processedOn: job.processedOn,
-      finishedOn: job.finishedOn,
-      delay: job.delay,
-      priority: job.opts?.priority,
-      scope: data.scope,
-      actor: data.actor,
-      metadata: data.metadata
-    };
+    map.set(cronName, definition);
+    this.cronsByQueue.set(queueName, map);
+    this.executorDirty = true;
   }
-  // ==========================================
-  // JOB OPERATIONS
-  // ==========================================
   async dispatch(params) {
-    const queue = await this.getOrCreateQueue(params.queue);
-    const jobOptions = {
+    const executor = await this.executor();
+    const namespace = executor[params.queue];
+    if (!namespace) {
+      throw new IgniterJobsError({
+        code: "JOBS_QUEUE_NOT_FOUND",
+        message: `Queue "${params.queue}" is not registered in the adapter.`
+      });
+    }
+    return namespace.enqueue({
+      task: params.jobName,
+      input: params.input,
       jobId: params.jobId,
       delay: params.delay,
       priority: params.priority,
-      attempts: params.attempts ?? 3,
-      backoff: params.backoff ? {
-        type: params.backoff.type === "custom" ? "fixed" : params.backoff.type,
-        delay: params.backoff.type === "custom" ? params.backoff.delays[0] : params.backoff.delay
-      } : void 0,
+      attempts: params.attempts,
+      metadata: params.metadata,
       removeOnComplete: params.removeOnComplete,
-      removeOnFail: params.removeOnFail
-    };
-    const jobData = {
-      input: params.data,
-      scope: params.scope,
-      actor: params.actor
-    };
-    const job = await queue.add(params.name, jobData, jobOptions);
-    return job.id;
+      removeOnFail: params.removeOnFail,
+      limiter: params.limiter
+    });
   }
   async schedule(params) {
-    const queue = await this.getOrCreateQueue(params.queue);
-    const jobOptions = {
+    const executor = await this.executor();
+    const namespace = executor[params.queue];
+    if (!namespace) {
+      throw new IgniterJobsError({
+        code: "JOBS_QUEUE_NOT_FOUND",
+        message: `Queue "${params.queue}" is not registered in the adapter.`
+      });
+    }
+    const schedule = {
       jobId: params.jobId,
-      delay: params.at ? params.at.getTime() - Date.now() : params.delay,
+      delay: params.delay,
       priority: params.priority,
-      attempts: params.attempts ?? 3,
-      backoff: params.backoff ? {
-        type: params.backoff.type === "custom" ? "fixed" : params.backoff.type,
-        delay: params.backoff.type === "custom" ? params.backoff.delays[0] : params.backoff.delay
-      } : void 0,
+      attempts: params.attempts,
+      metadata: params.metadata,
       removeOnComplete: params.removeOnComplete,
       removeOnFail: params.removeOnFail,
-      repeat: params.cron ? {
-        pattern: params.cron,
-        tz: params.timezone
-      } : params.every ? {
-        every: params.every
+      limiter: params.limiter,
+      at: params.at,
+      repeat: params.cron || params.every || params.maxExecutions || params.skipWeekends || params.onlyBusinessHours || params.businessHours || params.onlyWeekdays || params.skipDates ? {
+        cron: params.cron,
+        every: params.every,
+        times: params.maxExecutions,
+        skipWeekends: params.skipWeekends,
+        onlyBusinessHours: params.onlyBusinessHours,
+        businessHours: params.businessHours,
+        onlyWeekdays: params.onlyWeekdays,
+        skipDates: toDateArray(params.skipDates)
       } : void 0
     };
-    const jobData = {
-      input: params.data,
-      scope: params.scope,
-      actor: params.actor
-    };
-    const job = await queue.add(params.name, jobData, jobOptions);
-    return job.id;
+    return namespace.schedule({
+      task: params.jobName,
+      input: params.input,
+      ...schedule
+    });
   }
-  async getJob(queue, jobId) {
-    const q = await this.getOrCreateQueue(queue);
-    const job = await q.getJob(jobId);
-    if (!job) return null;
-    return await this.mapJobToInfo(job);
+  async getJob(jobId, queue) {
+    const result = await this.core().job.get(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+    return result ? this.mapJob(result, queue) : null;
   }
-  async getJobState(queue, jobId) {
-    const q = await this.getOrCreateQueue(queue);
-    const job = await q.getJob(jobId);
-    if (!job) return null;
-    const state = await job.getState();
-    return this.mapJobState(state);
+  async getJobState(jobId, queue) {
+    const state = await this.core().job.getState(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+    return state;
   }
-  async getJobProgress(queue, jobId) {
-    const q = await this.getOrCreateQueue(queue);
-    const job = await q.getJob(jobId);
-    if (!job) return 0;
-    return typeof job.progress === "number" ? job.progress : 0;
+  async getJobLogs(jobId, queue) {
+    const logs = await this.core().job.getLogs(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+    return logs;
   }
-  async getJobLogs(queue, jobId) {
-    const q = await this.getOrCreateQueue(queue);
-    const job = await q.getJob(jobId);
-    if (!job) return [];
-    const { logs } = await q.getJobLogs(jobId);
-    return logs.map((log, index) => ({
-      timestamp: /* @__PURE__ */ new Date(),
-      message: log,
-      level: "info"
-    }));
+  async getJobProgress(jobId, queue) {
+    return this.core().job.getProgress(jobId, queue ? this.toCoreQueueName(queue) : void 0);
   }
-  async retryJob(queue, jobId) {
-    const q = await this.getOrCreateQueue(queue);
-    const job = await q.getJob(jobId);
-    if (!job) {
-      throw new IgniterJobsError({
-        code: "JOBS_JOB_NOT_FOUND",
-        message: `Job "${jobId}" not found in queue "${queue}"`,
-        statusCode: 404
-      });
-    }
-    await job.retry();
+  async retryJob(jobId, queue) {
+    await this.core().job.retry(jobId, queue ? this.toCoreQueueName(queue) : void 0);
   }
-  async removeJob(queue, jobId) {
-    const q = await this.getOrCreateQueue(queue);
-    const job = await q.getJob(jobId);
-    if (!job) return;
-    await job.remove();
+  async removeJob(jobId, queue) {
+    await this.core().job.remove(jobId, queue ? this.toCoreQueueName(queue) : void 0);
   }
-  async promoteJob(queue, jobId) {
-    const q = await this.getOrCreateQueue(queue);
-    const job = await q.getJob(jobId);
-    if (!job) {
-      throw new IgniterJobsError({
-        code: "JOBS_JOB_NOT_FOUND",
-        message: `Job "${jobId}" not found in queue "${queue}"`,
-        statusCode: 404
-      });
-    }
-    await job.promote();
+  async promoteJob(jobId, queue) {
+    await this.core().job.promote(jobId, queue ? this.toCoreQueueName(queue) : void 0);
   }
-  async moveJob(queue, jobId, state, reason) {
-    const q = await this.getOrCreateQueue(queue);
-    const job = await q.getJob(jobId);
-    if (!job) {
-      throw new IgniterJobsError({
-        code: "JOBS_JOB_NOT_FOUND",
-        message: `Job "${jobId}" not found in queue "${queue}"`,
-        statusCode: 404
-      });
-    }
-    if (state === "failed") {
-      await job.moveToFailed(new Error(reason || "Manually moved to failed"), "manual");
-    } else {
-      await job.moveToCompleted(reason || "Manually completed", "manual");
-    }
+  async moveJobToFailed(jobId, reason, queue) {
+    await this.core().job.moveToFailed(jobId, reason, queue ? this.toCoreQueueName(queue) : void 0);
   }
-  async retryJobs(queue, jobIds) {
-    const q = await this.getOrCreateQueue(queue);
-    await Promise.all(
-      jobIds.map(async (jobId) => {
-        const job = await q.getJob(jobId);
-        if (job) await job.retry();
-      })
-    );
+  async retryManyJobs(jobIds, queue) {
+    await this.core().job.retryMany(jobIds, queue ? this.toCoreQueueName(queue) : void 0);
   }
-  async removeJobs(queue, jobIds) {
-    const q = await this.getOrCreateQueue(queue);
-    await Promise.all(
-      jobIds.map(async (jobId) => {
-        const job = await q.getJob(jobId);
-        if (job) await job.remove();
-      })
-    );
+  async removeManyJobs(jobIds, queue) {
+    await this.core().job.removeMany(jobIds, queue ? this.toCoreQueueName(queue) : void 0);
   }
-  // ==========================================
-  // QUEUE OPERATIONS
-  // ==========================================
-  async getQueue(queue) {
-    const q = await this.getOrCreateQueue(queue);
-    const isPaused = await q.isPaused();
-    const counts = await q.getJobCounts();
-    return {
-      name: queue,
-      isPaused,
-      jobCounts: {
-        waiting: counts.waiting || 0,
-        active: counts.active || 0,
-        completed: counts.completed || 0,
-        failed: counts.failed || 0,
-        delayed: counts.delayed || 0,
-        paused: counts.paused || 0
-      }
-    };
+  async getQueueInfo(queue) {
+    const info = await this.core().queues.get(this.toCoreQueueName(queue));
+    if (!info) return null;
+    return this.mapQueueInfo(info);
+  }
+  async getQueueJobCounts(queue) {
+    const counts = await this.core().queues.getJobCounts(this.toCoreQueueName(queue));
+    return counts;
+  }
+  async listQueues() {
+    const list = await this.core().queues.list();
+    return list.map((q) => this.mapQueueInfo(q));
   }
   async pauseQueue(queue) {
-    const q = await this.getOrCreateQueue(queue);
-    await q.pause();
+    await this.core().queues.pause(this.toCoreQueueName(queue));
   }
   async resumeQueue(queue) {
-    const q = await this.getOrCreateQueue(queue);
-    await q.resume();
+    await this.core().queues.resume(this.toCoreQueueName(queue));
   }
   async drainQueue(queue) {
-    const q = await this.getOrCreateQueue(queue);
-    await q.drain();
-    return 0;
+    return this.core().queues.drain(this.toCoreQueueName(queue));
   }
   async cleanQueue(queue, options) {
-    const q = await this.getOrCreateQueue(queue);
-    const statuses = Array.isArray(options.status) ? options.status : [options.status];
-    let total = 0;
-    for (const status of statuses) {
-      const cleaned = await q.clean(
-        options.olderThan ?? 0,
-        options.limit ?? 1e3,
-        status
-      );
-      total += cleaned.length;
-    }
-    return total;
+    return this.core().queues.clean(this.toCoreQueueName(queue), options);
   }
   async obliterateQueue(queue, options) {
-    const q = await this.getOrCreateQueue(queue);
-    await q.obliterate({ force: options?.force });
-  }
-  async retryAllFailed(queue) {
-    const q = await this.getOrCreateQueue(queue);
-    const failed = await q.getFailed();
-    await Promise.all(failed.map((job) => job.retry()));
-    return failed.length;
-  }
-  async getJobCounts(queue) {
-    const q = await this.getOrCreateQueue(queue);
-    const counts = await q.getJobCounts();
-    return {
-      waiting: counts.waiting || 0,
-      active: counts.active || 0,
-      completed: counts.completed || 0,
-      failed: counts.failed || 0,
-      delayed: counts.delayed || 0,
-      paused: counts.paused || 0
-    };
+    await this.core().queues.obliterate(this.toCoreQueueName(queue), options);
   }
-  async listJobs(queue, options) {
-    const q = await this.getOrCreateQueue(queue);
-    const statuses = options?.status || ["waiting", "active", "completed", "failed", "delayed"];
-    const jobs = [];
-    for (const status of statuses) {
-      const statusJobs = await q.getJobs([status], options?.start, options?.end);
-      jobs.push(...statusJobs);
-    }
-    return Promise.all(jobs.map(async (job) => {
-      const data = job.data;
-      const state = await job.getState();
-      return {
-        id: job.id,
-        name: job.name,
-        queue: job.queueName,
-        state: this.mapJobState(state || "waiting"),
-        data: data.input ?? data,
-        result: job.returnvalue,
-        error: job.failedReason,
-        progress: typeof job.progress === "number" ? job.progress : 0,
-        attempts: job.attemptsMade,
-        timestamp: job.timestamp,
-        processedOn: job.processedOn,
-        finishedOn: job.finishedOn,
-        scope: data.scope,
-        actor: data.actor
-      };
-    }));
+  async retryAllInQueue(queue) {
+    const jobs = await this.core().queues.getJobs(this.toCoreQueueName(queue), { status: ["failed"], limit: 1e3 });
+    await Promise.all(jobs.map((j) => this.core().job.retry(j.id, this.toCoreQueueName(queue))));
+    return jobs.length;
   }
-  // ==========================================
-  // PAUSE/RESUME JOB TYPES
-  // ==========================================
   async pauseJobType(queue, jobName) {
-    this.config?.logger?.warn?.(`pauseJobType is not fully supported in BullMQ adapter`);
+    throw new IgniterJobsError({
+      code: "JOBS_QUEUE_OPERATION_FAILED",
+      message: "BullMQ backend does not support pausing a single job type; pause the queue or adjust worker filters."
+    });
   }
   async resumeJobType(queue, jobName) {
-    this.config?.logger?.warn?.(`resumeJobType is not fully supported in BullMQ adapter`);
-  }
-  // ==========================================
-  // EVENTS
-  // ==========================================
-  async subscribe(pattern, handler) {
-    const subscriptions = [];
-    for (const [queueName] of this.queues) {
-      const events = await this.getQueueEvents(queueName);
-      const completedHandler = async (args) => {
-        if (this.matchesPattern(pattern, `${queueName}:${args.jobId}:completed`)) {
-          await handler({
-            type: "completed",
-            data: args,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-      };
-      const failedHandler = async (args) => {
-        if (this.matchesPattern(pattern, `${queueName}:${args.jobId}:failed`)) {
-          await handler({
-            type: "failed",
-            data: args,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-      };
-      events.on("completed", completedHandler);
-      events.on("failed", failedHandler);
-      subscriptions.push(async () => {
-        events.off("completed", completedHandler);
-        events.off("failed", failedHandler);
-      });
+    throw new IgniterJobsError({
+      code: "JOBS_QUEUE_OPERATION_FAILED",
+      message: "BullMQ backend does not support resuming a single job type; resume the queue or adjust worker filters."
+    });
+  }
+  async searchJobs(filter) {
+    const queue = filter?.queue;
+    const status = filter?.status;
+    const limit = filter?.limit ?? 100;
+    const offset = filter?.offset ?? 0;
+    if (queue) {
+      const jobs = await this.core().queues.getJobs(this.toCoreQueueName(queue), { status, limit, offset });
+      return jobs.map((j) => this.mapJob(j, queue));
+    }
+    const queues = await this.listQueues();
+    const results = [];
+    for (const q of queues) {
+      const jobs = await this.core().queues.getJobs(this.toCoreQueueName(q.name), { status, limit, offset });
+      results.push(...jobs.map((j) => this.mapJob(j, q.name)));
+      if (results.length >= limit) break;
+    }
+    return results.slice(0, limit);
+  }
+  async searchQueues(filter) {
+    const all = await this.listQueues();
+    const name = filter?.name;
+    const isPaused = filter?.isPaused;
+    return all.filter((q) => name ? q.name.includes(name) : true).filter((q) => typeof isPaused === "boolean" ? q.isPaused === isPaused : true);
+  }
+  async searchWorkers(filter) {
+    const queue = filter?.queue;
+    const isRunning = filter?.isRunning;
+    const all = Array.from(this.core().getWorkers().values());
+    return all.filter((w) => {
+      if (!queue) return true;
+      const coreQueue = this.toCoreQueueName(queue);
+      const queues = w.config?.queues ?? [w.queueName];
+      return Array.isArray(queues) ? queues.includes(coreQueue) : false;
+    }).filter((w) => typeof isRunning === "boolean" ? isRunning ? w.isRunning() : !w.isRunning() : true).map((w) => this.mapWorker(w));
+  }
+  async createWorker(config) {
+    await this.executor();
+    const queuesSource = config.queues?.length ? config.queues : Array.from(/* @__PURE__ */ new Set([...this.jobsByQueue.keys(), ...this.cronsByQueue.keys()]));
+    const queues = queuesSource.map((q) => this.toCoreQueueName(q));
+    const coreConfig = {
+      queues,
+      concurrency: config.concurrency ?? 1,
+      limiter: config.limiter,
+      onActive: config.handlers?.onActive,
+      onSuccess: config.handlers?.onSuccess,
+      onFailure: config.handlers?.onFailure,
+      onIdle: config.handlers?.onIdle
+    };
+    const handle = await this.core().worker(coreConfig);
+    return this.mapWorker(handle);
+  }
+  getWorkers() {
+    const out = /* @__PURE__ */ new Map();
+    for (const [id, handle] of this.core().getWorkers()) out.set(id, this.mapWorker(handle));
+    return out;
+  }
+  async publishEvent(channel, payload) {
+    await this.publisher.publish(channel, JSON.stringify(payload));
+  }
+  async subscribeEvent(channel, handler) {
+    const set = this.subscribers.get(channel) ?? /* @__PURE__ */ new Set();
+    const wrapped = (payload) => void handler(payload);
+    set.add(wrapped);
+    this.subscribers.set(channel, set);
+    if (set.size === 1) {
+      await this.subscriber.subscribe(channel);
     }
     return async () => {
-      await Promise.all(subscriptions.map((unsub) => unsub()));
+      const current = this.subscribers.get(channel);
+      if (!current) return;
+      current.delete(wrapped);
+      if (current.size === 0) {
+        this.subscribers.delete(channel);
+        await this.subscriber.unsubscribe(channel);
+      }
     };
   }
-  matchesPattern(pattern, eventType) {
-    if (pattern === "*") return true;
-    const regex = new RegExp(
-      "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
-    );
-    return regex.test(eventType);
-  }
-  // ==========================================
-  // WORKERS
-  // ==========================================
-  async createWorker(config, handler) {
-    const { Worker } = await this.getBullMQ();
-    const workerId = `worker-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    const workers = [];
-    for (const queueName of config.queues) {
-      const workerOptions = {
-        connection: this.redis,
-        concurrency: config.concurrency,
-        lockDuration: config.lockDuration,
-        limiter: config.limiter
-      };
-      const worker = new Worker(
-        queueName,
-        async (job) => {
-          const data = job.data;
-          return handler({
-            id: job.id,
-            name: job.name,
-            queue: job.queueName,
-            data: data.input ?? data,
-            attempt: job.attemptsMade + 1,
-            timestamp: job.timestamp,
-            scope: data.scope,
-            actor: data.actor,
-            log: async (level, message) => {
-              await job.log(`[${level.toUpperCase()}] ${message}`);
-            },
-            updateProgress: async (progress) => {
-              await job.updateProgress(progress);
-            }
-          });
-        },
-        workerOptions
-      );
-      if (config.onIdle) {
-        worker.on("drained", config.onIdle);
-      }
-      workers.push(worker);
-      this.workers.set(`${workerId}-${queueName}`, worker);
-    }
-    let isPaused = false;
-    const startTime = Date.now();
-    let processed = 0;
-    let failed = 0;
-    let completed = 0;
-    for (const worker of workers) {
-      worker.on("completed", () => {
-        processed++;
-        completed++;
-      });
-      worker.on("failed", () => {
-        processed++;
-        failed++;
+  async shutdown() {
+    await this.subscriber.quit();
+  }
+  core() {
+    if (!this.coreAdapter) {
+      this.coreAdapter = adapterBullmq.createBullMQAdapter({
+        store: { client: this.redis }
       });
     }
-    return {
-      id: workerId,
-      pause: async () => {
-        await Promise.all(workers.map((w) => w.pause()));
-        isPaused = true;
-      },
-      resume: async () => {
-        await Promise.all(workers.map((w) => w.resume()));
-        isPaused = false;
-      },
-      close: async () => {
-        await Promise.all(workers.map((w) => w.close()));
-        for (const worker of workers) {
-          const key = Array.from(this.workers.entries()).find(
-            ([_, w]) => w === worker
-          )?.[0];
-          if (key) this.workers.delete(key);
+    return this.coreAdapter;
+  }
+  async executor() {
+    if (!this.executorDirty && this.coreExecutor) return this.coreExecutor;
+    const routers = {};
+    const flattened = {};
+    const allQueues = /* @__PURE__ */ new Set([...this.jobsByQueue.keys(), ...this.cronsByQueue.keys()]);
+    for (const queueName of allQueues) {
+      const coreJobs = {};
+      const jobs = this.jobsByQueue.get(queueName);
+      if (jobs) {
+        for (const [jobName, def] of jobs.entries()) {
+          const queue = def.queue ? `${queueName}.${def.queue}` : queueName;
+          const fullQueue = IgniterJobsPrefix.buildQueueName(queue);
+          coreJobs[jobName] = this.toCoreJobDefinition(queueName, jobName, def, fullQueue);
         }
-      },
-      isRunning: () => !isPaused && workers.every((w) => w.isRunning()),
-      isPaused: () => isPaused,
-      getMetrics: async () => ({
-        processed,
-        failed,
-        completed,
-        active: workers.reduce((sum, w) => sum + (w.isRunning() ? 1 : 0), 0),
-        uptime: Date.now() - startTime
-      })
-    };
-  }
-  // ==========================================
-  // SEARCH
-  // ==========================================
-  async searchJobs(filter) {
-    const results = [];
-    const queuesToSearch = filter.queue ? [filter.queue] : Array.from(this.queues.keys());
-    for (const queueName of queuesToSearch) {
-      const jobs = await this.listJobs(queueName, {
-        status: filter.status,
-        start: filter.offset,
-        end: filter.limit ? (filter.offset || 0) + filter.limit : void 0
+      }
+      const crons = this.cronsByQueue.get(queueName);
+      if (crons) {
+        for (const [cronName, def] of crons.entries()) {
+          const fullQueue = IgniterJobsPrefix.buildQueueName(queueName);
+          coreJobs[cronName] = this.toCoreCronJobDefinition(queueName, cronName, def, fullQueue);
+        }
+      }
+      if (Object.keys(coreJobs).length === 0) continue;
+      routers[queueName] = this.core().router({
+        jobs: coreJobs,
+        namespace: queueName
       });
-      for (const job of jobs) {
-        if (filter.jobName && job.name !== filter.jobName) continue;
-        if (filter.scopeId && job.scope?.id !== filter.scopeId) continue;
-        if (filter.actorId && job.actor?.id !== filter.actorId) continue;
-        if (filter.dateRange?.from && job.timestamp < filter.dateRange.from.getTime()) continue;
-        if (filter.dateRange?.to && job.timestamp > filter.dateRange.to.getTime()) continue;
-        results.push(job);
+      for (const [jobName, def] of Object.entries(coreJobs)) {
+        flattened[`${queueName}.${jobName}`] = def;
       }
     }
-    if (filter.orderBy) {
-      const [field, direction] = filter.orderBy.split(":");
-      results.sort((a, b) => {
-        const aVal = field === "createdAt" ? a.timestamp : a[field];
-        const bVal = field === "createdAt" ? b.timestamp : b[field];
-        return direction === "asc" ? aVal - bVal : bVal - aVal;
+    await this.core().bulkRegister(flattened);
+    this.coreExecutor = this.core().merge(routers);
+    this.executorDirty = false;
+    return this.coreExecutor;
+  }
+  toCoreQueueName(queueName) {
+    return IgniterJobsPrefix.buildQueueName(queueName);
+  }
+  mapQueueInfo(info) {
+    return {
+      name: this.fromCoreQueueName(info.name),
+      isPaused: info.isPaused,
+      jobCounts: info.jobCounts
+    };
+  }
+  fromCoreQueueName(full) {
+    const prefix = `${IgniterJobsPrefix.BASE_PREFIX}:`;
+    return full.startsWith(prefix) ? full.slice(prefix.length) : full;
+  }
+  mapJob(job, queue) {
+    const q = queue ?? this.fromCoreQueueName(job.metadata?.queue ?? job.queueName ?? "");
+    const scope = job.metadata?.__igniter_jobs_scope;
+    return {
+      id: job.id,
+      name: job.name,
+      queue: q,
+      status: job.status,
+      input: job.payload,
+      result: job.result,
+      error: job.error,
+      progress: 0,
+      attemptsMade: job.attemptsMade ?? 0,
+      priority: job.priority ?? 0,
+      createdAt: job.createdAt,
+      startedAt: job.processedAt,
+      completedAt: job.completedAt,
+      metadata: job.metadata,
+      scope
+    };
+  }
+  mapWorker(handle) {
+    const queues = handle.config?.queues ?? [handle.queueName];
+    return {
+      id: handle.id,
+      queues: queues.map((q) => this.fromCoreQueueName(q)),
+      pause: () => handle.pause(),
+      resume: () => handle.resume(),
+      close: () => handle.close(),
+      isRunning: () => handle.isRunning(),
+      isPaused: () => handle.isPaused(),
+      isClosed: () => handle.isClosed(),
+      getMetrics: async () => handle.getMetrics()
+    };
+  }
+  toCoreJobDefinition(queueName, jobName, def, fullQueueName) {
+    const handler = async (ctx) => {
+      return def.handler({
+        input: ctx.input,
+        context: ctx.context,
+        job: {
+          id: ctx.job.id,
+          name: jobName,
+          queue: queueName,
+          attemptsMade: ctx.job.attemptsMade,
+          createdAt: ctx.job.createdAt,
+          metadata: ctx.job.metadata
+        },
+        scope: ctx.job.metadata?.__igniter_jobs_scope
       });
-    }
-    return results.slice(0, filter.limit || 100);
+    };
+    return {
+      name: jobName,
+      input: def.input,
+      handler,
+      queue: { name: fullQueueName },
+      attempts: def.attempts,
+      priority: def.priority,
+      delay: def.delay,
+      removeOnComplete: def.removeOnComplete,
+      removeOnFail: def.removeOnFail,
+      metadata: def.metadata,
+      limiter: def.limiter,
+      onStart: def.onStart,
+      onSuccess: def.onSuccess,
+      onFailure: def.onFailure,
+      onProgress: def.onProgress
+    };
   }
-  async searchQueues(filter) {
-    const results = [];
-    for (const [queueName, queue] of this.queues) {
-      if (filter.name && !queueName.includes(filter.name)) continue;
-      const isPaused = await queue.isPaused();
-      if (filter.isPaused !== void 0 && isPaused !== filter.isPaused) continue;
-      const counts = await queue.getJobCounts();
-      results.push({
-        name: queueName,
-        isPaused,
-        jobCounts: {
-          waiting: counts.waiting || 0,
-          active: counts.active || 0,
-          completed: counts.completed || 0,
-          failed: counts.failed || 0,
-          delayed: counts.delayed || 0,
-          paused: counts.paused || 0
-        }
+  toCoreCronJobDefinition(queueName, cronName, def, fullQueueName) {
+    const handler = async (ctx) => {
+      return def.handler({
+        context: ctx.context,
+        job: {
+          id: ctx.job.id,
+          name: cronName,
+          queue: queueName,
+          attemptsMade: ctx.job.attemptsMade,
+          createdAt: ctx.job.createdAt,
+          metadata: ctx.job.metadata
+        },
+        scope: ctx.job.metadata?.__igniter_jobs_scope
       });
-    }
-    return results;
+    };
+    return {
+      name: cronName,
+      handler,
+      queue: { name: fullQueueName },
+      repeat: {
+        cron: def.cron,
+        tz: def.tz,
+        limit: def.maxExecutions,
+        startDate: def.startDate,
+        endDate: def.endDate
+      },
+      metadata: def.onlyBusinessHours || def.skipWeekends || def.businessHours || def.onlyWeekdays || def.skipDates || def.startDate && def.endDate ? {
+        advancedScheduling: {
+          onlyBusinessHours: def.onlyBusinessHours,
+          skipWeekends: def.skipWeekends,
+          businessHours: def.businessHours,
+          skipDates: toDateArray(def.skipDates),
+          onlyWeekdays: def.onlyWeekdays,
+          between: def.startDate && def.endDate ? [def.startDate, def.endDate] : void 0
+        }
+      } : void 0
+    };
   }
-  // ==========================================
-  // LIFECYCLE
-  // ==========================================
-  async shutdown() {
-    for (const [_, worker] of this.workers) {
-      await worker.close();
-    }
-    this.workers.clear();
-    for (const [_, events] of this.queueEvents) {
-      await events.close();
-    }
-    this.queueEvents.clear();
-    for (const [_, queue] of this.queues) {
-      await queue.close();
-    }
-    this.queues.clear();
+};
+
+// src/utils/id-generator.ts
+var IgniterJobsIdGenerator = class {
+  /**
+   * Generates a unique identifier with a prefix.
+   *
+   * @example
+   * ```typescript
+   * const jobId = IgniterJobsIdGenerator.generate('job')
+   * ```
+   */
+  static generate(prefix) {
+    const now = Date.now().toString(36);
+    const random = Math.random().toString(36).slice(2, 8);
+    return `${prefix}_${now}_${random}`;
   }
 };
 
 // src/adapters/memory.adapter.ts
-var MemoryAdapter = class _MemoryAdapter {
+var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
   constructor() {
-    this.queues = /* @__PURE__ */ new Map();
-    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.client = {
+      type: "memory"
+    };
+    this.jobsById = /* @__PURE__ */ new Map();
+    this.jobsByQueue = /* @__PURE__ */ new Map();
+    this.registeredJobs = /* @__PURE__ */ new Map();
+    this.registeredCrons = /* @__PURE__ */ new Map();
     this.workers = /* @__PURE__ */ new Map();
-    this.processingInterval = null;
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.queues = {
+      list: async () => this.listQueues(),
+      get: async (name) => this.getQueueInfo(name),
+      getJobCounts: async (name) => this.getQueueJobCounts(name),
+      getJobs: async (name, filter) => {
+        const statuses = filter?.status;
+        const limit = filter?.limit ?? 100;
+        const offset = filter?.offset ?? 0;
+        const results = await this.searchJobs({
+          queue: name,
+          status: statuses,
+          limit,
+          offset
+        });
+        return results;
+      },
+      pause: async (name) => this.pauseQueue(name),
+      resume: async (name) => this.resumeQueue(name),
+      isPaused: async (name) => {
+        const info = await this.getQueueInfo(name);
+        return info?.isPaused ?? false;
+      },
+      drain: async (name) => this.drainQueue(name),
+      clean: async (name, options) => this.cleanQueue(name, options),
+      obliterate: async (name, options) => this.obliterateQueue(name, options)
+    };
+    this.pausedQueues = /* @__PURE__ */ new Set();
   }
-  /**
-   * Create a new memory adapter.
-   */
   static create() {
-    return new _MemoryAdapter();
-  }
-  /**
-   * Get the underlying client (null for memory adapter).
-   */
-  get client() {
-    return null;
+    return new _IgniterJobsMemoryAdapter();
   }
-  /**
-   * Get or create a queue.
-   */
-  getOrCreateQueue(name) {
-    if (!this.queues.has(name)) {
-      this.queues.set(name, {
-        name,
-        isPaused: false,
-        jobs: /* @__PURE__ */ new Map(),
-        pausedJobTypes: /* @__PURE__ */ new Set()
+  registerJob(queueName, jobName, definition) {
+    const queueJobs = this.registeredJobs.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (queueJobs.has(jobName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_DUPLICATE_JOB",
+        message: `Job "${jobName}" already registered for queue "${queueName}".`
       });
     }
-    return this.queues.get(name);
+    queueJobs.set(jobName, definition);
+    this.registeredJobs.set(queueName, queueJobs);
   }
-  /**
-   * Generate a unique job ID.
-   */
-  generateJobId() {
-    return `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-  }
-  /**
-   * Emit an event to subscribers.
-   */
-  async emitEvent(type, data) {
-    for (const [pattern, handlers] of this.eventHandlers) {
-      if (this.matchesPattern(pattern, type)) {
-        for (const handler of handlers) {
-          try {
-            await handler({
-              type,
-              data,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          } catch {
-          }
-        }
-      }
+  registerCron(queueName, cronName, definition) {
+    const queueCrons = this.registeredCrons.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (queueCrons.has(cronName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" already registered for queue "${queueName}".`
+      });
     }
+    queueCrons.set(cronName, definition);
+    this.registeredCrons.set(queueName, queueCrons);
   }
-  /**
-   * Check if a pattern matches an event type.
-   */
-  matchesPattern(pattern, eventType) {
-    if (pattern === "*") return true;
-    const regex = new RegExp(
-      "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
-    );
-    return regex.test(eventType);
-  }
-  // ==========================================
-  // JOB OPERATIONS
-  // ==========================================
   async dispatch(params) {
-    const queue = this.getOrCreateQueue(params.queue);
-    const jobId = params.jobId || this.generateJobId();
+    const jobId = params.jobId ?? IgniterJobsIdGenerator.generate("job");
+    const maxAttempts = params.attempts ?? 1;
+    const metadata = params.metadata ?? {};
     const job = {
       id: jobId,
-      name: params.name,
+      name: params.jobName,
       queue: params.queue,
-      data: params.data,
-      state: params.delay ? "delayed" : "waiting",
+      input: params.input,
+      status: this.pausedQueues.has(params.queue) ? "paused" : params.delay && params.delay > 0 ? "delayed" : "waiting",
       progress: 0,
-      attempts: 0,
-      maxAttempts: params.attempts ?? 3,
-      timestamp: Date.now(),
-      delay: params.delay,
+      attemptsMade: 0,
+      maxAttempts,
       priority: params.priority ?? 0,
+      createdAt: /* @__PURE__ */ new Date(),
+      metadata,
       scope: params.scope,
-      actor: params.actor,
-      logs: [],
-      scheduledAt: params.delay ? Date.now() + params.delay : void 0
+      logs: []
     };
-    queue.jobs.set(jobId, job);
-    await this.emitEvent(`${params.queue}:${params.name}:enqueued`, {
-      jobId,
-      name: params.name,
-      queue: params.queue
-    });
-    this.startProcessing();
+    this.jobsById.set(jobId, job);
+    const queueList = this.jobsByQueue.get(params.queue) ?? [];
+    queueList.push(jobId);
+    this.jobsByQueue.set(params.queue, queueList);
+    if (params.delay && params.delay > 0) {
+      setTimeout(() => {
+        const stored = this.jobsById.get(jobId);
+        if (!stored) return;
+        if (!this.pausedQueues.has(params.queue)) stored.status = "waiting";
+        void this.kickWorkers(params.queue);
+      }, params.delay);
+      return jobId;
+    }
+    void this.kickWorkers(params.queue);
     return jobId;
   }
   async schedule(params) {
-    const delay = params.at ? params.at.getTime() - Date.now() : params.delay ?? 0;
-    return this.dispatch({
-      ...params,
-      delay
-    });
+    if (params.at) {
+      const delay = params.at.getTime() - Date.now();
+      if (delay <= 0) {
+        throw new IgniterJobsError({
+          code: "JOBS_INVALID_SCHEDULE",
+          message: "Scheduled time must be in the future."
+        });
+      }
+      return this.dispatch({ ...params, delay });
+    }
+    if (params.cron || params.every) {
+      return this.dispatch({ ...params, delay: params.delay ?? 0 });
+    }
+    return this.dispatch(params);
   }
-  async getJob(queue, jobId) {
-    const q = this.getOrCreateQueue(queue);
-    const job = q.jobs.get(jobId);
+  async getJob(jobId, queue) {
+    const job = this.jobsById.get(jobId);
     if (!job) return null;
-    return {
-      id: job.id,
-      name: job.name,
-      queue: job.queue,
-      state: job.state,
-      data: job.data,
-      result: job.result,
-      error: job.error,
-      progress: job.progress,
-      attempts: job.attempts,
-      timestamp: job.timestamp,
-      processedOn: job.processedOn,
-      finishedOn: job.finishedOn,
-      delay: job.delay,
-      priority: job.priority,
-      scope: job.scope,
-      actor: job.actor
-    };
+    if (queue && job.queue !== queue) return null;
+    return this.toSearchResult(job);
   }
-  async getJobState(queue, jobId) {
-    const q = this.getOrCreateQueue(queue);
-    const job = q.jobs.get(jobId);
-    return job?.state ?? null;
+  async getJobState(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return null;
+    if (queue && job.queue !== queue) return null;
+    return job.status;
   }
-  async getJobProgress(queue, jobId) {
-    const q = this.getOrCreateQueue(queue);
-    const job = q.jobs.get(jobId);
-    return job?.progress ?? 0;
+  async getJobLogs(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return [];
+    if (queue && job.queue !== queue) return [];
+    return job.logs;
   }
-  async getJobLogs(queue, jobId) {
-    const q = this.getOrCreateQueue(queue);
-    const job = q.jobs.get(jobId);
-    return job?.logs ?? [];
+  async getJobProgress(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return 0;
+    if (queue && job.queue !== queue) return 0;
+    return job.progress;
   }
-  async retryJob(queue, jobId) {
-    const q = this.getOrCreateQueue(queue);
-    const job = q.jobs.get(jobId);
+  async retryJob(jobId, queue) {
+    const job = this.jobsById.get(jobId);
     if (!job) {
       throw new IgniterJobsError({
-        code: "JOBS_JOB_NOT_FOUND",
-        message: `Job "${jobId}" not found`,
-        statusCode: 404
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found.`
+      });
+    }
+    if (queue && job.queue !== queue) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found in queue "${queue}".`
       });
     }
-    job.state = "waiting";
+    job.status = "waiting";
     job.error = void 0;
-    job.attempts = 0;
+    job.completedAt = void 0;
+    job.progress = 0;
+    void this.kickWorkers(job.queue);
   }
-  async removeJob(queue, jobId) {
-    const q = this.getOrCreateQueue(queue);
-    q.jobs.delete(jobId);
+  async removeJob(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return;
+    if (queue && job.queue !== queue) return;
+    this.jobsById.delete(jobId);
+    const list = this.jobsByQueue.get(job.queue);
+    if (list)
+      this.jobsByQueue.set(
+        job.queue,
+        list.filter((id) => id !== jobId)
+      );
   }
-  async promoteJob(queue, jobId) {
-    const q = this.getOrCreateQueue(queue);
-    const job = q.jobs.get(jobId);
+  async promoteJob(jobId, queue) {
+    const job = this.jobsById.get(jobId);
     if (!job) {
       throw new IgniterJobsError({
-        code: "JOBS_JOB_NOT_FOUND",
-        message: `Job "${jobId}" not found`,
-        statusCode: 404
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found.`
       });
     }
-    if (job.state === "delayed") {
-      job.state = "waiting";
-      job.scheduledAt = void 0;
-      job.delay = void 0;
+    if (queue && job.queue !== queue) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found in queue "${queue}".`
+      });
+    }
+    if (job.status === "delayed" || job.status === "paused") {
+      job.status = this.pausedQueues.has(job.queue) ? "paused" : "waiting";
+      void this.kickWorkers(job.queue);
     }
   }
-  async moveJob(queue, jobId, state, reason) {
-    const q = this.getOrCreateQueue(queue);
-    const job = q.jobs.get(jobId);
+  async moveJobToFailed(jobId, reason, queue) {
+    const job = this.jobsById.get(jobId);
     if (!job) {
       throw new IgniterJobsError({
-        code: "JOBS_JOB_NOT_FOUND",
-        message: `Job "${jobId}" not found`,
-        statusCode: 404
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found.`
       });
     }
-    job.state = state;
-    job.finishedOn = Date.now();
-    if (state === "failed") {
-      job.error = reason;
-    } else {
-      job.result = reason;
+    if (queue && job.queue !== queue) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found in queue "${queue}".`
+      });
     }
+    job.status = "failed";
+    job.error = reason;
+    job.completedAt = /* @__PURE__ */ new Date();
   }
-  async retryJobs(queue, jobIds) {
-    await Promise.all(jobIds.map((id) => this.retryJob(queue, id)));
+  async retryManyJobs(jobIds, queue) {
+    await Promise.all(jobIds.map((id) => this.retryJob(id, queue)));
   }
-  async removeJobs(queue, jobIds) {
-    await Promise.all(jobIds.map((id) => this.removeJob(queue, id)));
+  async removeManyJobs(jobIds, queue) {
+    await Promise.all(jobIds.map((id) => this.removeJob(id, queue)));
   }
-  // ==========================================
-  // QUEUE OPERATIONS
-  // ==========================================
-  async getQueue(queue) {
-    const q = this.getOrCreateQueue(queue);
-    const counts = await this.getJobCounts(queue);
+  async getQueueInfo(queue) {
+    const counts = await this.getQueueJobCounts(queue);
     return {
       name: queue,
-      isPaused: q.isPaused,
+      isPaused: this.pausedQueues.has(queue),
       jobCounts: counts
     };
   }
-  async pauseQueue(queue) {
-    const q = this.getOrCreateQueue(queue);
-    q.isPaused = true;
-  }
-  async resumeQueue(queue) {
-    const q = this.getOrCreateQueue(queue);
-    q.isPaused = false;
-  }
-  async drainQueue(queue) {
-    const q = this.getOrCreateQueue(queue);
-    let count = 0;
-    for (const [id, job] of q.jobs) {
-      if (job.state === "waiting" || job.state === "delayed") {
-        q.jobs.delete(id);
-        count++;
+  async getQueueJobCounts(queue) {
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    const counts = {
+      waiting: 0,
+      active: 0,
+      completed: 0,
+      failed: 0,
+      delayed: 0,
+      paused: 0
+    };
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.status in counts) {
+        counts[job.status]++;
       }
     }
-    return count;
+    return counts;
   }
-  async cleanQueue(queue, options) {
-    const q = this.getOrCreateQueue(queue);
+  async listQueues() {
+    const queues = Array.from(
+      /* @__PURE__ */ new Set([
+        ...this.jobsByQueue.keys(),
+        ...this.registeredJobs.keys(),
+        ...this.registeredCrons.keys()
+      ])
+    );
+    const result = [];
+    for (const q of queues) {
+      result.push(await this.getQueueInfo(q));
+    }
+    return result;
+  }
+  async pauseQueue(queue) {
+    this.pausedQueues.add(queue);
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.status === "waiting") job.status = "paused";
+    }
+  }
+  async resumeQueue(queue) {
+    this.pausedQueues.delete(queue);
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.status === "paused") job.status = "waiting";
+    }
+    void this.kickWorkers(queue);
+  }
+  async drainQueue(queue) {
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    let removed = 0;
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.status === "waiting" || job.status === "paused") {
+        this.jobsById.delete(id);
+        removed++;
+      }
+    }
+    this.jobsByQueue.set(
+      queue,
+      jobIds.filter((id) => this.jobsById.has(id))
+    );
+    return removed;
+  }
+  async cleanQueue(queue, options) {
     const statuses = Array.isArray(options.status) ? options.status : [options.status];
+    const olderThan = options.olderThan ?? 0;
+    const limit = options.limit ?? Number.POSITIVE_INFINITY;
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
     const now = Date.now();
-    let count = 0;
-    let removed = 0;
-    for (const [id, job] of q.jobs) {
-      if (options.limit && removed >= options.limit) break;
-      if (statuses.includes(job.state)) {
-        const age = now - job.timestamp;
-        if (!options.olderThan || age >= options.olderThan) {
-          q.jobs.delete(id);
-          removed++;
-          count++;
+    let cleaned = 0;
+    for (const id of [...jobIds]) {
+      if (cleaned >= limit) break;
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (!statuses.includes(job.status)) continue;
+      const ageMs = now - job.createdAt.getTime();
+      if (ageMs < olderThan) continue;
+      this.jobsById.delete(id);
+      cleaned++;
+    }
+    this.jobsByQueue.set(
+      queue,
+      jobIds.filter((id) => this.jobsById.has(id))
+    );
+    return cleaned;
+  }
+  async obliterateQueue(queue, options) {
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    for (const id of jobIds) this.jobsById.delete(id);
+    this.jobsByQueue.delete(queue);
+    this.registeredJobs.delete(queue);
+    this.registeredCrons.delete(queue);
+    this.pausedQueues.delete(queue);
+  }
+  async retryAllInQueue(queue) {
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    let retried = 0;
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.status === "failed") {
+        await this.retryJob(id, queue);
+        retried++;
+      }
+    }
+    return retried;
+  }
+  async pauseJobType(queue, jobName) {
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.name === jobName && job.status === "waiting")
+        job.status = "paused";
+    }
+  }
+  async resumeJobType(queue, jobName) {
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.name === jobName && job.status === "paused")
+        job.status = "waiting";
+    }
+    void this.kickWorkers(queue);
+  }
+  async searchJobs(filter) {
+    const queue = filter?.queue;
+    const statuses = filter?.status;
+    const limit = filter?.limit ?? 100;
+    const offset = filter?.offset ?? 0;
+    const all = Array.from(this.jobsById.values()).filter((j) => queue ? j.queue === queue : true).filter((j) => statuses ? statuses.includes(j.status) : true).sort(
+      (a, b) => b.priority - a.priority || a.createdAt.getTime() - b.createdAt.getTime()
+    );
+    return all.slice(offset, offset + limit).map((j) => this.toSearchResult(j));
+  }
+  async searchQueues(filter) {
+    const name = filter?.name;
+    const isPaused = filter?.isPaused;
+    const all = await this.listQueues();
+    return all.filter((q) => name ? q.name.includes(name) : true).filter(
+      (q) => typeof isPaused === "boolean" ? q.isPaused === isPaused : true
+    );
+  }
+  async searchWorkers(filter) {
+    const queue = filter?.queue;
+    const isRunning = filter?.isRunning;
+    return Array.from(this.workers.values()).filter((w) => queue ? w.queues.includes(queue) : true).filter(
+      (w) => typeof isRunning === "boolean" ? isRunning ? !w.closed : w.closed : true
+    ).map((w) => this.toWorkerHandle(w));
+  }
+  async createWorker(config) {
+    const workerId = IgniterJobsIdGenerator.generate("worker");
+    const state = {
+      id: workerId,
+      queues: config.queues ?? [],
+      concurrency: config.concurrency ?? 1,
+      paused: false,
+      closed: false,
+      startedAt: /* @__PURE__ */ new Date(),
+      metrics: { processed: 0, failed: 0, totalDuration: 0 },
+      handlers: config.handlers
+    };
+    this.workers.set(workerId, state);
+    for (const q of state.queues) void this.kickWorkers(q);
+    return this.toWorkerHandle(state);
+  }
+  getWorkers() {
+    const out = /* @__PURE__ */ new Map();
+    for (const [id, state] of this.workers)
+      out.set(id, this.toWorkerHandle(state));
+    return out;
+  }
+  async publishEvent(channel, payload) {
+    const handlers = this.subscribers.get(channel);
+    if (!handlers) return;
+    await Promise.all(Array.from(handlers).map(async (h) => h(payload)));
+  }
+  async subscribeEvent(channel, handler) {
+    const set = this.subscribers.get(channel) ?? /* @__PURE__ */ new Set();
+    set.add(handler);
+    this.subscribers.set(channel, set);
+    return async () => {
+      const current = this.subscribers.get(channel);
+      if (!current) return;
+      current.delete(handler);
+      if (current.size === 0) this.subscribers.delete(channel);
+    };
+  }
+  async shutdown() {
+    this.workers.clear();
+    this.subscribers.clear();
+  }
+  toSearchResult(job) {
+    return {
+      id: job.id,
+      name: job.name,
+      queue: job.queue,
+      status: job.status,
+      input: job.input,
+      result: job.result,
+      error: job.error,
+      progress: job.progress,
+      attemptsMade: job.attemptsMade,
+      priority: job.priority,
+      createdAt: job.createdAt,
+      startedAt: job.startedAt,
+      completedAt: job.completedAt,
+      metadata: job.metadata,
+      scope: job.scope
+    };
+  }
+  toWorkerHandle(worker) {
+    return {
+      id: worker.id,
+      queues: worker.queues,
+      pause: async () => {
+        worker.paused = true;
+      },
+      resume: async () => {
+        worker.paused = false;
+        for (const q of worker.queues) void this.kickWorkers(q);
+      },
+      close: async () => {
+        worker.closed = true;
+      },
+      isRunning: () => !worker.closed && !worker.paused,
+      isPaused: () => worker.paused,
+      isClosed: () => worker.closed,
+      getMetrics: async () => this.toWorkerMetrics(worker)
+    };
+  }
+  toWorkerMetrics(worker) {
+    const uptime = Date.now() - worker.startedAt.getTime();
+    const processed = worker.metrics.processed;
+    return {
+      processed,
+      failed: worker.metrics.failed,
+      avgDuration: processed > 0 ? worker.metrics.totalDuration / processed : 0,
+      concurrency: worker.concurrency,
+      uptime
+    };
+  }
+  async kickWorkers(queue) {
+    if (this.pausedQueues.has(queue)) return;
+    const relevant = Array.from(this.workers.values()).filter(
+      (w) => !w.closed && !w.paused && (w.queues.length === 0 || w.queues.includes(queue))
+    );
+    if (relevant.length === 0) return;
+    for (const w of relevant) {
+      void this.processLoop(w, queue);
+    }
+  }
+  async processLoop(worker, queue) {
+    if (worker.closed || worker.paused) return;
+    const concurrency = Math.max(1, worker.concurrency);
+    const running = worker.__running;
+    const currentRunning = running ?? 0;
+    if (currentRunning >= concurrency) return;
+    worker.__running = currentRunning + 1;
+    try {
+      const next = this.nextJob(queue);
+      if (!next) return;
+      await this.processJob(worker, next);
+    } finally {
+      worker.__running = worker.__running - 1;
+      if (this.nextJob(queue)) void this.processLoop(worker, queue);
+      else if (worker.handlers?.onIdle) await worker.handlers.onIdle();
+    }
+  }
+  nextJob(queue) {
+    const ids = this.jobsByQueue.get(queue) ?? [];
+    const candidates = ids.map((id) => this.jobsById.get(id)).filter((j) => Boolean(j)).filter((j) => j.status === "waiting").sort(
+      (a, b) => b.priority - a.priority || a.createdAt.getTime() - b.createdAt.getTime()
+    );
+    return candidates[0] ?? null;
+  }
+  async processJob(worker, job) {
+    if (this.pausedQueues.has(job.queue)) {
+      job.status = "paused";
+      return;
+    }
+    job.status = "active";
+    job.startedAt = /* @__PURE__ */ new Date();
+    job.attemptsMade += 1;
+    job.logs.push({
+      timestamp: /* @__PURE__ */ new Date(),
+      level: "info",
+      message: "Job started"
+    });
+    if (worker.handlers?.onActive)
+      await worker.handlers.onActive({ job: this.toSearchResult(job) });
+    const start = Date.now();
+    try {
+      const definition = this.registeredJobs.get(job.queue)?.get(job.name);
+      if (!definition) {
+        throw new IgniterJobsError({
+          code: "JOBS_NOT_REGISTERED",
+          message: `Job "${job.name}" is not registered for queue "${job.queue}".`
+        });
+      }
+      if (definition.onStart) {
+        await definition.onStart({
+          input: job.input,
+          context: {},
+          job: {
+            id: job.id,
+            name: job.name,
+            queue: job.queue,
+            attemptsMade: job.attemptsMade,
+            metadata: job.metadata
+          },
+          scope: job.scope,
+          startedAt: job.startedAt
+        });
+      }
+      const result = await definition.handler({
+        input: job.input,
+        context: {},
+        job: {
+          id: job.id,
+          name: job.name,
+          queue: job.queue,
+          attemptsMade: job.attemptsMade,
+          metadata: job.metadata
+        },
+        scope: job.scope
+      });
+      const duration = Date.now() - start;
+      job.status = "completed";
+      job.completedAt = /* @__PURE__ */ new Date();
+      job.result = result;
+      job.progress = 100;
+      job.logs.push({
+        timestamp: /* @__PURE__ */ new Date(),
+        level: "info",
+        message: `Job completed in ${duration}ms`
+      });
+      worker.metrics.processed += 1;
+      worker.metrics.totalDuration += duration;
+      if (definition.onSuccess) {
+        await definition.onSuccess({
+          input: job.input,
+          context: {},
+          job: {
+            id: job.id,
+            name: job.name,
+            queue: job.queue,
+            attemptsMade: job.attemptsMade,
+            metadata: job.metadata
+          },
+          scope: job.scope,
+          result,
+          duration
+        });
+      }
+      if (worker.handlers?.onSuccess)
+        await worker.handlers.onSuccess({
+          job: this.toSearchResult(job),
+          result
+        });
+    } catch (error) {
+      job.error = error?.message ?? String(error);
+      job.logs.push({
+        timestamp: /* @__PURE__ */ new Date(),
+        level: "error",
+        message: job.error ?? "Unknown error"
+      });
+      const isFinalAttempt = job.attemptsMade >= job.maxAttempts;
+      if (isFinalAttempt) {
+        job.status = "failed";
+        job.completedAt = /* @__PURE__ */ new Date();
+        worker.metrics.failed += 1;
+        const definition = this.registeredJobs.get(job.queue)?.get(job.name);
+        if (definition?.onFailure) {
+          await definition.onFailure({
+            input: job.input,
+            context: {},
+            job: {
+              id: job.id,
+              name: job.name,
+              queue: job.queue,
+              attemptsMade: job.attemptsMade,
+              metadata: job.metadata
+            },
+            scope: job.scope,
+            error,
+            isFinalAttempt: true
+          });
         }
+        if (worker.handlers?.onFailure)
+          await worker.handlers.onFailure({
+            job: this.toSearchResult(job),
+            error
+          });
+      } else {
+        job.status = "waiting";
+        void this.kickWorkers(job.queue);
       }
     }
-    return count;
   }
-  async obliterateQueue(queue, options) {
-    this.queues.delete(queue);
-  }
-  async retryAllFailed(queue) {
-    const q = this.getOrCreateQueue(queue);
-    let count = 0;
-    for (const job of q.jobs.values()) {
-      if (job.state === "failed") {
-        job.state = "waiting";
-        job.error = void 0;
-        job.attempts = 0;
-        count++;
+};
+
+// src/adapters/sqlite.adapter.ts
+var IgniterJobsSQLiteAdapter = class _IgniterJobsSQLiteAdapter {
+  constructor(options) {
+    this.registeredJobs = /* @__PURE__ */ new Map();
+    this.registeredCrons = /* @__PURE__ */ new Map();
+    this.workers = /* @__PURE__ */ new Map();
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.pausedQueues = /* @__PURE__ */ new Set();
+    this.queues = {
+      list: async () => this.listQueues(),
+      get: async (name) => this.getQueueInfo(name),
+      getJobCounts: async (name) => this.getQueueJobCounts(name),
+      getJobs: async (name, filter) => {
+        const statuses = filter?.status;
+        const limit = filter?.limit ?? 100;
+        const offset = filter?.offset ?? 0;
+        const results = await this.searchJobs({
+          queue: name,
+          status: statuses,
+          limit,
+          offset
+        });
+        return results;
+      },
+      pause: async (name) => this.pauseQueue(name),
+      resume: async (name) => this.resumeQueue(name),
+      isPaused: async (name) => {
+        const info = await this.getQueueInfo(name);
+        return info?.isPaused ?? false;
+      },
+      drain: async (name) => this.drainQueue(name),
+      clean: async (name, options) => this.cleanQueue(name, options),
+      obliterate: async (name, options) => this.obliterateQueue(name, options)
+    };
+    this.options = {
+      path: options.path,
+      pollingInterval: options.pollingInterval ?? 500,
+      enableWAL: options.enableWAL ?? true
+    };
+    this.client = {
+      type: "sqlite",
+      path: this.options.path
+    };
+    const Database = __require("better-sqlite3");
+    this.db = new Database(this.options.path);
+    this.initializeSchema();
+  }
+  /**
+   * Creates a new SQLite adapter instance.
+   *
+   * @param options - Configuration options
+   * @returns A new adapter instance
+   *
+   * @example
+   * ```ts
+   * // File-based database (persistent)
+   * const adapter = IgniterJobsSQLiteAdapter.create({
+   *   path: './data/jobs.sqlite'
+   * });
+   *
+   * // In-memory database (for testing)
+   * const testAdapter = IgniterJobsSQLiteAdapter.create({
+   *   path: ':memory:'
+   * });
+   * ```
+   */
+  static create(options) {
+    return new _IgniterJobsSQLiteAdapter(options);
+  }
+  initializeSchema() {
+    if (this.options.enableWAL) {
+      this.db.exec("PRAGMA journal_mode = WAL;");
+    }
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS jobs (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        queue TEXT NOT NULL,
+        input TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'waiting',
+        progress REAL NOT NULL DEFAULT 0,
+        attempts_made INTEGER NOT NULL DEFAULT 0,
+        max_attempts INTEGER NOT NULL DEFAULT 1,
+        priority INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        started_at TEXT,
+        completed_at TEXT,
+        scheduled_at TEXT,
+        result TEXT,
+        error TEXT,
+        metadata TEXT,
+        scope TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_jobs_queue_status ON jobs(queue, status);
+      CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
+      CREATE INDEX IF NOT EXISTS idx_jobs_scheduled_at ON jobs(scheduled_at);
+      CREATE INDEX IF NOT EXISTS idx_jobs_priority ON jobs(priority DESC, created_at ASC);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS job_logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        job_id TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        level TEXT NOT NULL,
+        message TEXT NOT NULL,
+        FOREIGN KEY (job_id) REFERENCES jobs(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_job_logs_job_id ON job_logs(job_id);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS paused_queues (
+        name TEXT PRIMARY KEY
+      );
+    `);
+    const pausedRows = this.db.prepare(
+      "SELECT name FROM paused_queues"
+    ).all();
+    for (const row of pausedRows) {
+      this.pausedQueues.add(row.name);
+    }
+  }
+  registerJob(queueName, jobName, definition) {
+    const queueJobs = this.registeredJobs.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (queueJobs.has(jobName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_DUPLICATE_JOB",
+        message: `Job "${jobName}" already registered for queue "${queueName}".`
+      });
+    }
+    queueJobs.set(jobName, definition);
+    this.registeredJobs.set(queueName, queueJobs);
+  }
+  registerCron(queueName, cronName, definition) {
+    const queueCrons = this.registeredCrons.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (queueCrons.has(cronName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" already registered for queue "${queueName}".`
+      });
+    }
+    queueCrons.set(cronName, definition);
+    this.registeredCrons.set(queueName, queueCrons);
+  }
+  async dispatch(params) {
+    const jobId = params.jobId ?? IgniterJobsIdGenerator.generate("job");
+    const maxAttempts = params.attempts ?? 1;
+    const now = /* @__PURE__ */ new Date();
+    let status = "waiting";
+    let scheduledAt = null;
+    if (this.pausedQueues.has(params.queue)) {
+      status = "paused";
+    } else if (params.delay && params.delay > 0) {
+      status = "delayed";
+      scheduledAt = new Date(now.getTime() + params.delay);
+    }
+    const stmt = this.db.prepare(`
+      INSERT INTO jobs (
+        id, name, queue, input, status, progress, attempts_made, max_attempts,
+        priority, created_at, scheduled_at, metadata, scope
+      ) VALUES (?, ?, ?, ?, ?, 0, 0, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      jobId,
+      params.jobName,
+      params.queue,
+      JSON.stringify(params.input ?? {}),
+      status,
+      maxAttempts,
+      params.priority ?? 0,
+      now.toISOString(),
+      scheduledAt?.toISOString() ?? null,
+      params.metadata ? JSON.stringify(params.metadata) : null,
+      params.scope ? JSON.stringify(params.scope) : null
+    );
+    if (params.delay && params.delay > 0) {
+      setTimeout(() => {
+        this.promoteDelayedJob(jobId, params.queue);
+      }, params.delay);
+    }
+    return jobId;
+  }
+  promoteDelayedJob(jobId, queue) {
+    if (this.pausedQueues.has(queue)) return;
+    const stmt = this.db.prepare(`
+      UPDATE jobs SET status = 'waiting', scheduled_at = NULL
+      WHERE id = ? AND status = 'delayed'
+    `);
+    stmt.run(jobId);
+  }
+  async schedule(params) {
+    if (params.at) {
+      const delay = params.at.getTime() - Date.now();
+      if (delay <= 0) {
+        throw new IgniterJobsError({
+          code: "JOBS_INVALID_SCHEDULE",
+          message: "Scheduled time must be in the future."
+        });
       }
+      return this.dispatch({ ...params, delay });
+    }
+    if (params.cron || params.every) {
+      return this.dispatch({ ...params, delay: params.delay ?? 0 });
+    }
+    return this.dispatch(params);
+  }
+  async getJob(jobId, queue) {
+    let sql = "SELECT * FROM jobs WHERE id = ?";
+    const params = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    if (!row) return null;
+    return this.rowToSearchResult(row);
+  }
+  async getJobState(jobId, queue) {
+    let sql = "SELECT status FROM jobs WHERE id = ?";
+    const params = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    return row?.status ?? null;
+  }
+  async getJobLogs(jobId, queue) {
+    if (queue) {
+      const job = await this.getJob(jobId, queue);
+      if (!job) return [];
+    }
+    const rows = this.db.prepare("SELECT * FROM job_logs WHERE job_id = ? ORDER BY timestamp ASC").all(jobId);
+    return rows.map((row) => ({
+      timestamp: new Date(row.timestamp),
+      level: row.level,
+      message: row.message
+    }));
+  }
+  async getJobProgress(jobId, queue) {
+    let sql = "SELECT progress FROM jobs WHERE id = ?";
+    const params = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    return row?.progress ?? 0;
+  }
+  async retryJob(jobId, queue) {
+    let sql = "SELECT id FROM jobs WHERE id = ?";
+    const checkParams = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      checkParams.push(queue);
+    }
+    const exists = this.db.prepare(sql).get(...checkParams);
+    if (!exists) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found${queue ? ` in queue "${queue}"` : ""}.`
+      });
+    }
+    let updateSql = "UPDATE jobs SET status = 'waiting', error = NULL, completed_at = NULL, progress = 0 WHERE id = ?";
+    const updateParams = [jobId];
+    if (queue) {
+      updateSql = updateSql.replace("WHERE id = ?", "WHERE id = ? AND queue = ?");
+      updateParams.push(queue);
+    }
+    this.db.prepare(updateSql).run(...updateParams);
+  }
+  async removeJob(jobId, queue) {
+    let sql = "DELETE FROM jobs WHERE id = ?";
+    const params = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
+    }
+    this.db.prepare(sql).run(...params);
+  }
+  async promoteJob(jobId, queue) {
+    let sql = "SELECT id, status, queue FROM jobs WHERE id = ?";
+    const checkParams = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      checkParams.push(queue);
+    }
+    const row = this.db.prepare(sql).get(...checkParams);
+    if (!row) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found${queue ? ` in queue "${queue}"` : ""}.`
+      });
+    }
+    if (row.status === "delayed" || row.status === "paused") {
+      const newStatus = this.pausedQueues.has(row.queue) ? "paused" : "waiting";
+      this.db.prepare("UPDATE jobs SET status = ?, scheduled_at = NULL WHERE id = ?").run(newStatus, jobId);
+    }
+  }
+  async moveJobToFailed(jobId, reason, queue) {
+    let sql = "SELECT id FROM jobs WHERE id = ?";
+    const checkParams = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      checkParams.push(queue);
+    }
+    const exists = this.db.prepare(sql).get(...checkParams);
+    if (!exists) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found${queue ? ` in queue "${queue}"` : ""}.`
+      });
     }
-    return count;
+    this.db.prepare(`
+      UPDATE jobs SET status = 'failed', error = ?, completed_at = ?
+      WHERE id = ?
+    `).run(reason, (/* @__PURE__ */ new Date()).toISOString(), jobId);
+  }
+  async retryManyJobs(jobIds, queue) {
+    await Promise.all(jobIds.map((id) => this.retryJob(id, queue)));
+  }
+  async removeManyJobs(jobIds, queue) {
+    await Promise.all(jobIds.map((id) => this.removeJob(id, queue)));
+  }
+  async getQueueInfo(queue) {
+    const counts = await this.getQueueJobCounts(queue);
+    return {
+      name: queue,
+      isPaused: this.pausedQueues.has(queue),
+      jobCounts: counts
+    };
   }
-  async getJobCounts(queue) {
-    const q = this.getOrCreateQueue(queue);
+  async getQueueJobCounts(queue) {
     const counts = {
       waiting: 0,
       active: 0,
@@ -873,257 +1491,401 @@ var MemoryAdapter = class _MemoryAdapter {
       delayed: 0,
       paused: 0
     };
-    for (const job of q.jobs.values()) {
-      counts[job.state]++;
+    const rows = this.db.prepare(
+      "SELECT status, COUNT(*) as count FROM jobs WHERE queue = ? GROUP BY status"
+    ).all(queue);
+    for (const row of rows) {
+      if (row.status in counts) {
+        counts[row.status] = row.count;
+      }
     }
     return counts;
   }
-  async listJobs(queue, options) {
-    const q = this.getOrCreateQueue(queue);
-    const results = [];
-    const statuses = options?.status || ["waiting", "active", "completed", "failed", "delayed", "paused"];
-    for (const job of q.jobs.values()) {
-      if (statuses.includes(job.state)) {
-        results.push({
-          id: job.id,
-          name: job.name,
-          queue: job.queue,
-          state: job.state,
-          data: job.data,
-          result: job.result,
-          error: job.error,
-          progress: job.progress,
-          attempts: job.attempts,
-          timestamp: job.timestamp,
-          processedOn: job.processedOn,
-          finishedOn: job.finishedOn,
-          scope: job.scope,
-          actor: job.actor
-        });
-      }
+  async listQueues() {
+    const jobQueues = this.db.prepare("SELECT DISTINCT queue FROM jobs").all().map((r) => r.queue);
+    const allQueues = /* @__PURE__ */ new Set([
+      ...jobQueues,
+      ...this.registeredJobs.keys(),
+      ...this.registeredCrons.keys()
+    ]);
+    const result = [];
+    for (const q of allQueues) {
+      const info = await this.getQueueInfo(q);
+      if (info) result.push(info);
     }
-    const start = options?.start ?? 0;
-    const end = options?.end ?? results.length;
-    return results.slice(start, end);
+    return result;
+  }
+  async pauseQueue(queue) {
+    this.pausedQueues.add(queue);
+    this.db.prepare("INSERT OR IGNORE INTO paused_queues (name) VALUES (?)").run(queue);
+    this.db.prepare(
+      "UPDATE jobs SET status = 'paused' WHERE queue = ? AND status = 'waiting'"
+    ).run(queue);
+  }
+  async resumeQueue(queue) {
+    this.pausedQueues.delete(queue);
+    this.db.prepare("DELETE FROM paused_queues WHERE name = ?").run(queue);
+    this.db.prepare(
+      "UPDATE jobs SET status = 'waiting' WHERE queue = ? AND status = 'paused'"
+    ).run(queue);
+  }
+  async drainQueue(queue) {
+    const result = this.db.prepare(
+      "DELETE FROM jobs WHERE queue = ? AND status IN ('waiting', 'paused')"
+    ).run(queue);
+    return result.changes;
+  }
+  async cleanQueue(queue, options) {
+    const statuses = Array.isArray(options.status) ? options.status : [options.status];
+    const olderThan = options.olderThan ?? 0;
+    const limit = options.limit ?? Number.POSITIVE_INFINITY;
+    const cutoffTime = new Date(Date.now() - olderThan).toISOString();
+    const statusPlaceholders = statuses.map(() => "?").join(", ");
+    let sql = `
+      DELETE FROM jobs WHERE id IN (
+        SELECT id FROM jobs
+        WHERE queue = ? AND status IN (${statusPlaceholders}) AND created_at < ?
+        ORDER BY created_at ASC
+        LIMIT ?
+      )
+    `;
+    const result = this.db.prepare(sql).run(
+      queue,
+      ...statuses,
+      cutoffTime,
+      limit === Number.POSITIVE_INFINITY ? -1 : limit
+    );
+    return result.changes;
+  }
+  async obliterateQueue(queue, _options) {
+    this.db.prepare("DELETE FROM jobs WHERE queue = ?").run(queue);
+    this.registeredJobs.delete(queue);
+    this.registeredCrons.delete(queue);
+    this.pausedQueues.delete(queue);
+    this.db.prepare("DELETE FROM paused_queues WHERE name = ?").run(queue);
+  }
+  async retryAllInQueue(queue) {
+    const result = this.db.prepare(`
+      UPDATE jobs SET status = 'waiting', error = NULL, completed_at = NULL, progress = 0
+      WHERE queue = ? AND status = 'failed'
+    `).run(queue);
+    return result.changes;
   }
-  // ==========================================
-  // PAUSE/RESUME JOB TYPES
-  // ==========================================
   async pauseJobType(queue, jobName) {
-    const q = this.getOrCreateQueue(queue);
-    q.pausedJobTypes.add(jobName);
+    this.db.prepare(
+      "UPDATE jobs SET status = 'paused' WHERE queue = ? AND name = ? AND status = 'waiting'"
+    ).run(queue, jobName);
   }
   async resumeJobType(queue, jobName) {
-    const q = this.getOrCreateQueue(queue);
-    q.pausedJobTypes.delete(jobName);
+    this.db.prepare(
+      "UPDATE jobs SET status = 'waiting' WHERE queue = ? AND name = ? AND status = 'paused'"
+    ).run(queue, jobName);
   }
-  // ==========================================
-  // EVENTS
-  // ==========================================
-  async subscribe(pattern, handler) {
-    if (!this.eventHandlers.has(pattern)) {
-      this.eventHandlers.set(pattern, /* @__PURE__ */ new Set());
+  async searchJobs(filter) {
+    const queue = filter?.queue;
+    const statuses = filter?.status;
+    const limit = filter?.limit ?? 100;
+    const offset = filter?.offset ?? 0;
+    let sql = "SELECT * FROM jobs WHERE 1=1";
+    const params = [];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
     }
-    this.eventHandlers.get(pattern).add(handler);
+    if (statuses && statuses.length > 0) {
+      const placeholders = statuses.map(() => "?").join(", ");
+      sql += ` AND status IN (${placeholders})`;
+      params.push(...statuses);
+    }
+    sql += " ORDER BY priority DESC, created_at ASC LIMIT ? OFFSET ?";
+    params.push(limit, offset);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => this.rowToSearchResult(row));
+  }
+  async searchQueues(filter) {
+    const name = filter?.name;
+    const isPaused = filter?.isPaused;
+    const all = await this.listQueues();
+    return all.filter((q) => name ? q.name.includes(name) : true).filter(
+      (q) => typeof isPaused === "boolean" ? q.isPaused === isPaused : true
+    );
+  }
+  async searchWorkers(filter) {
+    const queue = filter?.queue;
+    const isRunning = filter?.isRunning;
+    return Array.from(this.workers.values()).filter((w) => queue ? w.queues.includes(queue) : true).filter(
+      (w) => typeof isRunning === "boolean" ? isRunning ? !w.closed : w.closed : true
+    ).map((w) => this.toWorkerHandle(w));
+  }
+  async createWorker(config) {
+    const workerId = IgniterJobsIdGenerator.generate("worker");
+    const state = {
+      id: workerId,
+      queues: config.queues ?? [],
+      concurrency: config.concurrency ?? 1,
+      paused: false,
+      closed: false,
+      startedAt: /* @__PURE__ */ new Date(),
+      metrics: { processed: 0, failed: 0, totalDuration: 0 },
+      handlers: config.handlers,
+      activeJobs: 0
+    };
+    this.workers.set(workerId, state);
+    this.startPollingLoop(state);
+    return this.toWorkerHandle(state);
+  }
+  getWorkers() {
+    const out = /* @__PURE__ */ new Map();
+    for (const [id, state] of this.workers) {
+      out.set(id, this.toWorkerHandle(state));
+    }
+    return out;
+  }
+  async publishEvent(channel, payload) {
+    const handlers = this.subscribers.get(channel);
+    if (!handlers) return;
+    await Promise.all(Array.from(handlers).map(async (h) => h(payload)));
+  }
+  async subscribeEvent(channel, handler) {
+    const set = this.subscribers.get(channel) ?? /* @__PURE__ */ new Set();
+    set.add(handler);
+    this.subscribers.set(channel, set);
     return async () => {
-      this.eventHandlers.get(pattern)?.delete(handler);
+      const current = this.subscribers.get(channel);
+      if (!current) return;
+      current.delete(handler);
+      if (current.size === 0) this.subscribers.delete(channel);
     };
   }
-  // ==========================================
-  // WORKERS
-  // ==========================================
-  async createWorker(config, handler) {
-    const workerId = `worker-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    this.workers.set(workerId, {
-      handler,
-      config,
-      running: true,
-      paused: false
-    });
-    const startTime = Date.now();
-    let processed = 0;
-    let failed = 0;
-    let completed = 0;
+  async shutdown() {
+    for (const worker of this.workers.values()) {
+      worker.closed = true;
+      if (worker.pollingTimer) {
+        clearInterval(worker.pollingTimer);
+      }
+    }
+    this.workers.clear();
+    this.subscribers.clear();
+    this.db.close();
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+  rowToSearchResult(row) {
     return {
-      id: workerId,
+      id: row.id,
+      name: row.name,
+      queue: row.queue,
+      status: row.status,
+      input: JSON.parse(row.input),
+      result: row.result ? JSON.parse(row.result) : void 0,
+      error: row.error ?? void 0,
+      progress: row.progress,
+      attemptsMade: row.attempts_made,
+      priority: row.priority,
+      createdAt: new Date(row.created_at),
+      startedAt: row.started_at ? new Date(row.started_at) : void 0,
+      completedAt: row.completed_at ? new Date(row.completed_at) : void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      scope: row.scope ? JSON.parse(row.scope) : void 0
+    };
+  }
+  toWorkerHandle(worker) {
+    return {
+      id: worker.id,
+      queues: worker.queues,
       pause: async () => {
-        const worker = this.workers.get(workerId);
-        if (worker) worker.paused = true;
+        worker.paused = true;
       },
       resume: async () => {
-        const worker = this.workers.get(workerId);
-        if (worker) worker.paused = false;
+        worker.paused = false;
       },
       close: async () => {
-        this.workers.delete(workerId);
-      },
-      isRunning: () => {
-        const worker = this.workers.get(workerId);
-        return worker?.running && !worker?.paused || false;
-      },
-      isPaused: () => {
-        return this.workers.get(workerId)?.paused || false;
+        worker.closed = true;
+        if (worker.pollingTimer) {
+          clearInterval(worker.pollingTimer);
+        }
       },
-      getMetrics: async () => ({
-        processed,
-        failed,
-        completed,
-        active: 0,
-        uptime: Date.now() - startTime
-      })
+      isRunning: () => !worker.closed && !worker.paused,
+      isPaused: () => worker.paused,
+      isClosed: () => worker.closed,
+      getMetrics: async () => this.toWorkerMetrics(worker)
     };
   }
-  /**
-   * Start the internal job processing loop.
-   */
-  startProcessing() {
-    if (this.processingInterval) return;
-    this.processingInterval = setInterval(async () => {
-      await this.processJobs();
-    }, 100);
+  toWorkerMetrics(worker) {
+    const uptime = Date.now() - worker.startedAt.getTime();
+    const processed = worker.metrics.processed;
+    return {
+      processed,
+      failed: worker.metrics.failed,
+      avgDuration: processed > 0 ? worker.metrics.totalDuration / processed : 0,
+      concurrency: worker.concurrency,
+      uptime
+    };
   }
-  /**
-   * Process pending jobs.
-   */
-  async processJobs() {
-    for (const [_, worker] of this.workers) {
-      if (!worker.running || worker.paused) continue;
-      for (const queueName of worker.config.queues) {
-        const queue = this.queues.get(queueName);
-        if (!queue || queue.isPaused) continue;
-        for (const job of queue.jobs.values()) {
-          if (job.state !== "waiting") continue;
-          if (queue.pausedJobTypes.has(job.name)) continue;
-          if (job.scheduledAt && job.scheduledAt > Date.now()) continue;
-          job.state = "active";
-          job.processedOn = Date.now();
-          job.attempts++;
-          try {
-            const result = await worker.handler({
-              id: job.id,
-              name: job.name,
-              queue: job.queue,
-              data: job.data,
-              attempt: job.attempts,
-              timestamp: job.timestamp,
-              scope: job.scope,
-              actor: job.actor,
-              log: async (level, message) => {
-                job.logs.push({
-                  timestamp: /* @__PURE__ */ new Date(),
-                  message,
-                  level
-                });
-              },
-              updateProgress: async (progress) => {
-                job.progress = progress;
-              }
-            });
-            job.state = "completed";
-            job.result = result;
-            job.finishedOn = Date.now();
-            await this.emitEvent(`${job.queue}:${job.name}:completed`, {
-              jobId: job.id,
-              result
-            });
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (job.attempts < job.maxAttempts) {
-              job.state = "waiting";
-              await this.emitEvent(`${job.queue}:${job.name}:retrying`, {
-                jobId: job.id,
-                error: errorMessage,
-                attempt: job.attempts
-              });
-            } else {
-              job.state = "failed";
-              job.error = errorMessage;
-              job.finishedOn = Date.now();
-              await this.emitEvent(`${job.queue}:${job.name}:failed`, {
-                jobId: job.id,
-                error: errorMessage
-              });
-            }
-          }
+  startPollingLoop(worker) {
+    const poll = () => {
+      if (worker.closed || worker.paused) return;
+      void this.processNextJobs(worker);
+    };
+    poll();
+    worker.pollingTimer = setInterval(poll, this.options.pollingInterval);
+  }
+  async processNextJobs(worker) {
+    if (worker.closed || worker.paused) return;
+    const availableSlots = worker.concurrency - worker.activeJobs;
+    if (availableSlots <= 0) return;
+    const queueFilter = worker.queues.length > 0 ? `queue IN (${worker.queues.map(() => "?").join(", ")})` : "1=1";
+    const params = worker.queues.length > 0 ? [...worker.queues, availableSlots] : [availableSlots];
+    const rows = this.db.prepare(`
+      SELECT * FROM jobs
+      WHERE status = 'waiting' AND ${queueFilter}
+      ORDER BY priority DESC, created_at ASC
+      LIMIT ?
+    `).all(...params);
+    for (const row of rows) {
+      if (worker.closed || worker.paused) break;
+      if (worker.activeJobs >= worker.concurrency) break;
+      const claimed = this.db.prepare(`
+        UPDATE jobs SET status = 'active', started_at = ?
+        WHERE id = ? AND status = 'waiting'
+      `).run((/* @__PURE__ */ new Date()).toISOString(), row.id);
+      if (claimed.changes === 0) continue;
+      worker.activeJobs++;
+      void this.processJob(worker, row.id).finally(() => {
+        worker.activeJobs--;
+        if (worker.handlers?.onIdle && worker.activeJobs === 0) {
+          void worker.handlers.onIdle();
         }
-      }
+      });
     }
   }
-  // ==========================================
-  // SEARCH
-  // ==========================================
-  async searchJobs(filter) {
-    const results = [];
-    const queuesToSearch = filter.queue ? [filter.queue] : Array.from(this.queues.keys());
-    for (const queueName of queuesToSearch) {
-      const queue = this.queues.get(queueName);
-      if (!queue) continue;
-      for (const job of queue.jobs.values()) {
-        if (filter.status && !filter.status.includes(job.state)) continue;
-        if (filter.jobName && job.name !== filter.jobName) continue;
-        if (filter.scopeId && job.scope?.id !== filter.scopeId) continue;
-        if (filter.actorId && job.actor?.id !== filter.actorId) continue;
-        if (filter.dateRange?.from && job.timestamp < filter.dateRange.from.getTime()) continue;
-        if (filter.dateRange?.to && job.timestamp > filter.dateRange.to.getTime()) continue;
-        results.push({
+  async processJob(worker, jobId) {
+    const row = this.db.prepare("SELECT * FROM jobs WHERE id = ?").get(jobId);
+    if (!row) return;
+    const job = this.rowToSearchResult(row);
+    this.addJobLog(jobId, "info", "Job started");
+    if (worker.handlers?.onActive) {
+      await worker.handlers.onActive({ job });
+    }
+    const start = Date.now();
+    try {
+      const definition = this.registeredJobs.get(row.queue)?.get(row.name);
+      if (!definition) {
+        throw new IgniterJobsError({
+          code: "JOBS_NOT_REGISTERED",
+          message: `Job "${row.name}" is not registered for queue "${row.queue}".`
+        });
+      }
+      this.db.prepare("UPDATE jobs SET attempts_made = attempts_made + 1 WHERE id = ?").run(jobId);
+      if (definition.onStart) {
+        await definition.onStart({
+          input: job.input,
+          context: {},
+          job: {
+            id: job.id,
+            name: job.name,
+            queue: job.queue,
+            attemptsMade: job.attemptsMade + 1,
+            metadata: job.metadata
+          },
+          scope: job.scope,
+          startedAt: /* @__PURE__ */ new Date()
+        });
+      }
+      const result = await definition.handler({
+        input: job.input,
+        context: {},
+        job: {
           id: job.id,
           name: job.name,
           queue: job.queue,
-          state: job.state,
-          data: job.data,
-          result: job.result,
-          error: job.error,
-          progress: job.progress,
-          attempts: job.attempts,
-          timestamp: job.timestamp,
-          processedOn: job.processedOn,
-          finishedOn: job.finishedOn,
+          attemptsMade: job.attemptsMade + 1,
+          metadata: job.metadata
+        },
+        scope: job.scope
+      });
+      const duration = Date.now() - start;
+      this.db.prepare(`
+        UPDATE jobs SET status = 'completed', completed_at = ?, result = ?, progress = 100
+        WHERE id = ?
+      `).run((/* @__PURE__ */ new Date()).toISOString(), JSON.stringify(result), jobId);
+      this.addJobLog(jobId, "info", `Job completed in ${duration}ms`);
+      worker.metrics.processed++;
+      worker.metrics.totalDuration += duration;
+      if (definition.onSuccess) {
+        await definition.onSuccess({
+          input: job.input,
+          context: {},
+          job: {
+            id: job.id,
+            name: job.name,
+            queue: job.queue,
+            attemptsMade: job.attemptsMade + 1,
+            metadata: job.metadata
+          },
           scope: job.scope,
-          actor: job.actor
+          result,
+          duration
         });
       }
+      if (worker.handlers?.onSuccess) {
+        const updatedJob = await this.getJob(jobId);
+        if (updatedJob) {
+          await worker.handlers.onSuccess({ job: updatedJob, result });
+        }
+      }
+    } catch (error) {
+      const errorMessage = error?.message ?? String(error);
+      this.addJobLog(jobId, "error", errorMessage);
+      const current = this.db.prepare(
+        "SELECT attempts_made, max_attempts FROM jobs WHERE id = ?"
+      ).get(jobId);
+      const isFinalAttempt = (current?.attempts_made ?? 0) >= (current?.max_attempts ?? 1);
+      if (isFinalAttempt) {
+        this.db.prepare(`
+          UPDATE jobs SET status = 'failed', error = ?, completed_at = ?
+          WHERE id = ?
+        `).run(errorMessage, (/* @__PURE__ */ new Date()).toISOString(), jobId);
+        worker.metrics.failed++;
+        const definition = this.registeredJobs.get(row.queue)?.get(row.name);
+        if (definition?.onFailure) {
+          await definition.onFailure({
+            input: job.input,
+            context: {},
+            job: {
+              id: job.id,
+              name: job.name,
+              queue: job.queue,
+              attemptsMade: current?.attempts_made ?? 1,
+              metadata: job.metadata
+            },
+            scope: job.scope,
+            error,
+            isFinalAttempt: true
+          });
+        }
+        if (worker.handlers?.onFailure) {
+          const updatedJob = await this.getJob(jobId);
+          if (updatedJob) {
+            await worker.handlers.onFailure({ job: updatedJob, error });
+          }
+        }
+      } else {
+        this.db.prepare("UPDATE jobs SET status = 'waiting' WHERE id = ?").run(jobId);
+      }
     }
-    if (filter.orderBy) {
-      const [field, direction] = filter.orderBy.split(":");
-      results.sort((a, b) => {
-        const aVal = field === "createdAt" ? a.timestamp : a[field];
-        const bVal = field === "createdAt" ? b.timestamp : b[field];
-        return direction === "asc" ? aVal - bVal : bVal - aVal;
-      });
-    }
-    const offset = filter.offset ?? 0;
-    const limit = filter.limit ?? 100;
-    return results.slice(offset, offset + limit);
-  }
-  async searchQueues(filter) {
-    const results = [];
-    for (const [queueName, queue] of this.queues) {
-      if (filter.name && !queueName.includes(filter.name)) continue;
-      if (filter.isPaused !== void 0 && queue.isPaused !== filter.isPaused) continue;
-      const counts = await this.getJobCounts(queueName);
-      results.push({
-        name: queueName,
-        isPaused: queue.isPaused,
-        jobCounts: counts
-      });
-    }
-    return results;
   }
-  // ==========================================
-  // LIFECYCLE
-  // ==========================================
-  async shutdown() {
-    if (this.processingInterval) {
-      clearInterval(this.processingInterval);
-      this.processingInterval = null;
-    }
-    this.workers.clear();
-    this.queues.clear();
-    this.eventHandlers.clear();
+  addJobLog(jobId, level, message) {
+    this.db.prepare(`
+      INSERT INTO job_logs (job_id, timestamp, level, message)
+      VALUES (?, ?, ?, ?)
+    `).run(jobId, (/* @__PURE__ */ new Date()).toISOString(), level, message);
   }
 };
 
-exports.BullMQAdapter = BullMQAdapter;
-exports.MemoryAdapter = MemoryAdapter;
+exports.IgniterJobsBullMQAdapter = IgniterJobsBullMQAdapter;
+exports.IgniterJobsMemoryAdapter = IgniterJobsMemoryAdapter;
+exports.IgniterJobsSQLiteAdapter = IgniterJobsSQLiteAdapter;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map