@igniter-js/jobs 0.1.0 → 0.1.1

package/dist/adapters/index.js

@@ -1,1129 +1,1058 @@
 'use strict';
 
+var adapterBullmq = require('@igniter-js/adapter-bullmq');
 var core = require('@igniter-js/core');
 
-// 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);
-    }
+// src/adapters/bullmq.adapter.ts
+
+// 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 core.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;
+    return new _IgniterJobsBullMQAdapter(options);
   }
-  /**
-   * Lazily load BullMQ module.
-   */
-  async getBullMQ() {
-    if (!this.BullMQ) {
-      this.BullMQ = await import('bullmq');
-    }
-    return this.BullMQ;
-  }
-  /**
-   * 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);
+    map.set(cronName, definition);
+    this.cronsByQueue.set(queueName, map);
+    this.executorDirty = true;
   }
-  /**
-   * 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
-    };
-  }
-  // ==========================================
-  // 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 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 getJobProgress(jobId, queue) {
+    return this.core().job.getProgress(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 retryJob(jobId, queue) {
+    await this.core().job.retry(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 removeJob(jobId, queue) {
+    await this.core().job.remove(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 promoteJob(jobId, queue) {
+    await this.core().job.promote(jobId, 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 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();
-      })
-    );
-  }
-  // ==========================================
-  // 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 moveJobToFailed(jobId, reason, queue) {
+    await this.core().job.moveToFailed(jobId, reason, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async retryManyJobs(jobIds, queue) {
+    await this.core().job.retryMany(jobIds, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async removeManyJobs(jobIds, queue) {
+    await this.core().job.removeMany(jobIds, queue ? this.toCoreQueueName(queue) : void 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 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;
   }
-  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
-      };
-    }));
-  }
-  // ==========================================
-  // 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);
-  }
-  /**
-   * Generate a unique job ID.
-   */
-  generateJobId() {
-    return `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    queueJobs.set(jobName, definition);
+    this.registeredJobs.set(queueName, queueJobs);
   }
-  /**
-   * 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
-      });
+      throw new IgniterJobsError({ 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
-      });
+      throw new IgniterJobsError({ 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}".` });
     }
-    if (job.state === "delayed") {
-      job.state = "waiting";
-      job.scheduledAt = void 0;
-      job.delay = void 0;
+    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
-      });
+      throw new IgniterJobsError({ 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 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 counts;
+  }
+  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) {
-    const q = this.getOrCreateQueue(queue);
-    q.isPaused = true;
+    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) {
-    const q = this.getOrCreateQueue(queue);
-    q.isPaused = false;
+    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 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++;
+    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++;
       }
     }
-    return count;
+    this.jobsByQueue.set(queue, jobIds.filter((id) => this.jobsById.has(id)));
+    return removed;
   }
   async cleanQueue(queue, options) {
-    const q = this.getOrCreateQueue(queue);
     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++;
     }
-    return count;
+    this.jobsByQueue.set(queue, jobIds.filter((id) => this.jobsById.has(id)));
+    return cleaned;
   }
   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++;
+    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 count;
+    return retried;
   }
-  async getJobCounts(queue) {
-    const q = this.getOrCreateQueue(queue);
-    const counts = {
-      waiting: 0,
-      active: 0,
-      completed: 0,
-      failed: 0,
-      delayed: 0,
-      paused: 0
-    };
-    for (const job of q.jobs.values()) {
-      counts[job.state]++;
+  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";
     }
-    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 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";
     }
-    const start = options?.start ?? 0;
-    const end = options?.end ?? results.length;
-    return results.slice(start, end);
+    void this.kickWorkers(queue);
   }
-  // ==========================================
-  // PAUSE/RESUME JOB TYPES
-  // ==========================================
-  async pauseJobType(queue, jobName) {
-    const q = this.getOrCreateQueue(queue);
-    q.pausedJobTypes.add(jobName);
+  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 resumeJobType(queue, jobName) {
-    const q = this.getOrCreateQueue(queue);
-    q.pausedJobTypes.delete(jobName);
-  }
-  // ==========================================
-  // EVENTS
-  // ==========================================
-  async subscribe(pattern, handler) {
-    if (!this.eventHandlers.has(pattern)) {
-      this.eventHandlers.set(pattern, /* @__PURE__ */ new Set());
-    }
-    this.eventHandlers.get(pattern).add(handler);
+  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 () => {
-      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() {
+    this.workers.clear();
+    this.subscribers.clear();
+  }
+  toSearchResult(job) {
     return {
-      id: workerId,
+      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 () => {
-        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;
+        for (const q of worker.queues) void this.kickWorkers(q);
       },
       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;
       },
-      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
-              });
-            }
-          }
-        }
-      }
+  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);
     }
   }
-  // ==========================================
-  // 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({
-          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,
+  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,
-          actor: job.actor
+          startedAt: job.startedAt
         });
       }
-    }
-    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
+      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 results;
-  }
-  // ==========================================
-  // LIFECYCLE
-  // ==========================================
-  async shutdown() {
-    if (this.processingInterval) {
-      clearInterval(this.processingInterval);
-      this.processingInterval = null;
-    }
-    this.workers.clear();
-    this.queues.clear();
-    this.eventHandlers.clear();
   }
 };
 
-exports.BullMQAdapter = BullMQAdapter;
-exports.MemoryAdapter = MemoryAdapter;
+exports.IgniterJobsBullMQAdapter = IgniterJobsBullMQAdapter;
+exports.IgniterJobsMemoryAdapter = IgniterJobsMemoryAdapter;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map