@igniter-js/jobs 0.1.1 → 0.1.12

package/dist/index.mjs

@@ -1,7 +1,12 @@
-import { IgniterError } from '@igniter-js/core';
+import { IgniterError } from '@igniter-js/common';
 import { createBullMQAdapter } from '@igniter-js/adapter-bullmq';
 
-// src/errors/igniter-jobs.error.ts
+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');
+});
 var IGNITER_JOBS_ERROR_CODES = {
   JOBS_ADAPTER_REQUIRED: "JOBS_ADAPTER_REQUIRED",
   JOBS_SERVICE_REQUIRED: "JOBS_SERVICE_REQUIRED",
@@ -34,7 +39,7 @@ var IgniterJobsError = class extends IgniterError {
   }
 };
 
-// src/builders/igniter-worker.builder.ts
+// src/builders/worker.builder.ts
 var IgniterWorkerBuilder = class _IgniterWorkerBuilder {
   constructor(params) {
     this.adapter = params.adapter;
@@ -220,27 +225,6 @@ var IgniterJobsScopeUtils = class {
  */
 IgniterJobsScopeUtils.SCOPE_METADATA_KEY = "__igniter_jobs_scope";
 
-// src/utils/telemetry.ts
-var IgniterJobsTelemetryUtils = class {
-  /**
-   * Emits a telemetry event if telemetry is configured.
-   * This is a fire-and-forget operation - telemetry errors are silently ignored
-   * to avoid affecting job processing.
-   *
-   * @param telemetry - The telemetry instance (optional).
-   * @param eventName - The name of the event to emit.
-   * @param attributes - Attributes to attach to the event.
-   * @param level - The log level for the event (default: 'info').
-   */
-  static emitTelemetry(telemetry, eventName, attributes, level = "info") {
-    if (!telemetry) return;
-    try {
-      telemetry.emit(eventName, { attributes, level });
-    } catch {
-    }
-  }
-};
-
 // src/utils/validation.ts
 var IgniterJobsValidationUtils = class {
   /**
@@ -315,428 +299,637 @@ var IgniterJobsValidationUtils = class {
   }
 };
 
-// src/core/igniter-jobs.ts
-var IgniterJobs = class {
+// src/core/manager.ts
+var registeredAdapters = /* @__PURE__ */ new WeakSet();
+var IgniterJobsManager = class _IgniterJobsManager {
+  /**
+   * @internal
+   * Constructor is internal. Use `IgniterJobs.create()` instead.
+   */
+  constructor(config, scopeEntry) {
+    this.config = config;
+    this.adapter = config.adapter;
+    this.telemetry = config.telemetry;
+    this.scopeEntry = scopeEntry;
+  }
+  // ---------------------------------------------------------------------------
+  // Public Methods
+  // ---------------------------------------------------------------------------
   /**
-   * Starts the fluent builder API for jobs.
+   * Creates a scoped jobs instance.
+   *
+   * Scopes provide multi-tenant isolation by adding scope metadata to all jobs.
+   * Jobs dispatched from a scoped instance will include scope information in their metadata.
+   *
+   * @param type - The scope type (e.g., 'organization', 'workspace')
+   * @param id - The scope identifier (e.g., 'org_123')
+   * @param tags - Optional additional tags for the scope
+   * @returns A new scoped IgniterJobsManager instance
    *
    * @example
    * ```typescript
-   * const jobs = IgniterJobs.create<AppContext>()
-   *   .withAdapter(IgniterJobsMemoryAdapter.create())
-   *   .withService('my-api')
-   *   .withEnvironment('test')
-   *   .withContext(async () => ({ db }))
-   *   .addQueue(emailQueue)
-   *   .build()
+   * const orgJobs = jobs.scope('organization', 'org_123')
+   * await orgJobs.email.sendWelcome.dispatch({ input: { to: 'user@example.com' } })
    * ```
    */
-  static create() {
-    return IgniterJobsBuilder.create();
+  scope(type, id, tags) {
+    const entry = { type, id: String(id), tags };
+    return new _IgniterJobsManager(this.config, entry);
   }
   /**
-   * Creates a runtime instance from a validated configuration.
+   * Subscribes to all job events from this jobs instance.
+   *
+   * @param handler - The event handler function
+   * @returns A function to unsubscribe
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = await jobs.subscribe((event) => {
+   *   console.log('Job event:', event.type, event.data)
+   * })
+   * // Later: await unsubscribe()
+   * ```
    */
-  static fromConfig(config) {
-    const internal = createInternalState(config);
-    return createRuntime(internal, void 0);
+  async subscribe(handler) {
+    const channel = this.buildEventsChannel();
+    return this.adapter.subscribeEvent(channel, async (payload) => {
+      await handler(payload);
+    });
   }
-};
-function createInternalState(config) {
-  return {
-    config,
-    adapter: config.adapter,
-    registered: false
-  };
-}
-function createRuntime(internal, boundScope) {
-  if (!internal.registered) {
-    registerAll(internal.config, internal.adapter);
-    internal.registered = true;
-  }
-  const baseChannel = IgniterJobsPrefix.buildEventsChannel({
-    service: internal.config.service,
-    environment: internal.config.environment
-  });
-  const scopeChannel = boundScope ? IgniterJobsPrefix.buildEventsChannel({
-    service: internal.config.service,
-    environment: internal.config.environment,
-    scope: { type: boundScope.type, id: boundScope.id }
-  }) : void 0;
-  const runtime = {
-    config: internal.config,
-    async subscribe(handler) {
-      const channel = boundScope ? scopeChannel : baseChannel;
-      return internal.adapter.subscribeEvent(channel, async (payload) => {
-        await handler(payload);
-      });
-    },
-    async search(target, filter) {
-      switch (target) {
-        case "jobs":
-          return internal.adapter.searchJobs(filter);
-        case "queues":
-          return internal.adapter.searchQueues(filter);
-        case "workers":
-          return internal.adapter.searchWorkers(filter);
-        default:
-          return [];
-      }
-    },
-    async shutdown() {
-      await internal.adapter.shutdown();
-    },
-    worker: {
+  /**
+   * Searches for jobs, queues, or workers based on filters.
+   *
+   * @param target - The target to search ('jobs', 'queues', or 'workers')
+   * @param filter - The filter criteria
+   * @returns The search results
+   *
+   * @example
+   * ```typescript
+   * const failedJobs = await jobs.search('jobs', { status: 'failed', queue: 'email' })
+   * const queues = await jobs.search('queues', {})
+   * ```
+   */
+  async search(target, filter) {
+    switch (target) {
+      case "jobs":
+        return this.adapter.searchJobs(filter);
+      case "queues":
+        return this.adapter.searchQueues(filter);
+      case "workers":
+        return this.adapter.searchWorkers(filter);
+      default:
+        return [];
+    }
+  }
+  /**
+   * Gracefully shuts down the jobs instance.
+   *
+   * This will close all connections and stop all workers.
+   *
+   * @example
+   * ```typescript
+   * await jobs.shutdown()
+   * ```
+   */
+  async shutdown() {
+    await this.adapter.shutdown();
+  }
+  /**
+   * Creates a new worker builder for processing jobs.
+   *
+   * @returns A new IgniterWorkerBuilder instance
+   *
+   * @example
+   * ```typescript
+   * const worker = await jobs.worker
+   *   .create()
+   *   .addQueue('email')
+   *   .withConcurrency(5)
+   *   .start()
+   * ```
+   */
+  get worker() {
+    return {
       create: () => new IgniterWorkerBuilder({
-        adapter: internal.adapter,
-        allowedQueues: Object.keys(internal.config.queues)
+        adapter: this.adapter,
+        allowedQueues: Object.keys(this.config.queues)
       })
-    }
-  };
-  if (internal.config.scopeDefinition) {
-    runtime.scope = (type, id, tags) => {
-      const scope = { type, id, tags };
-      return createRuntime(internal, scope);
     };
   }
-  for (const [queueName, queueConfig] of Object.entries(
-    internal.config.queues
-  )) {
-    runtime[queueName] = createQueueAccessor({
-      internal,
-      boundScope,
-      queueName,
-      queueConfig
-    });
+  /**
+   * Converts the manager to a runtime proxy with typed queue accessors.
+   *
+   * @internal
+   * @returns The runtime proxy
+   */
+  toRuntime() {
+    this.ensureRegistered();
+    const self = this;
+    const queueNames = Object.keys(this.config.queues);
+    const handler = {
+      get(target, prop) {
+        if (prop === "config") return target.config;
+        if (prop === "subscribe") return target.subscribe.bind(target);
+        if (prop === "search") return target.search.bind(target);
+        if (prop === "shutdown") return target.shutdown.bind(target);
+        if (prop === "worker") return target.worker;
+        if (prop === "scope" && target.config.scopeDefinition) {
+          return (type, id, tags) => target.scope(type, id, tags).toRuntime();
+        }
+        if (queueNames.includes(prop)) {
+          return self.createQueueAccessor(prop);
+        }
+        return void 0;
+      }
+    };
+    return new Proxy(this, handler);
   }
-  return runtime;
-}
-function registerAll(config, adapter) {
-  for (const [queueName, queue] of Object.entries(
-    config.queues
-  )) {
-    for (const [jobName, def] of Object.entries(
-      queue.jobs
+  // ---------------------------------------------------------------------------
+  // Private Methods - Registration
+  // ---------------------------------------------------------------------------
+  /**
+   * Ensures all jobs and crons are registered with the adapter.
+   * Uses a shared WeakSet to prevent duplicate registration across scoped instances.
+   * @internal
+   */
+  ensureRegistered() {
+    if (registeredAdapters.has(this.adapter)) return;
+    for (const [queueName, queue] of Object.entries(
+      this.config.queues
     )) {
-      adapter.registerJob(
-        queueName,
-        jobName,
-        wrapJobDefinition({
-          config,
-          adapter,
+      for (const [jobName, def] of Object.entries(
+        queue.jobs
+      )) {
+        this.adapter.registerJob(
           queueName,
           jobName,
-          definition: def
-        })
-      );
-    }
-    for (const [cronName, cron] of Object.entries(
-      queue.crons
-    )) {
-      adapter.registerCron(
-        queueName,
-        cronName,
-        wrapCronDefinition({
-          config,
-          adapter,
+          this.wrapJobDefinition(queueName, jobName, def)
+        );
+      }
+      for (const [cronName, cron] of Object.entries(
+        queue.crons
+      )) {
+        this.adapter.registerCron(
           queueName,
           cronName,
-          definition: cron
-        })
-      );
+          this.wrapCronDefinition(queueName, cronName, cron)
+        );
+      }
     }
+    registeredAdapters.add(this.adapter);
   }
-}
-function wrapCronDefinition(params) {
-  const { config, adapter, queueName, cronName, definition } = params;
-  const buildExecutionContext = async (ctx) => {
-    const realContext = await config.contextFactory();
-    const scope = ctx.scope ?? IgniterJobsScopeUtils.extractScopeFromMetadata(
-      ctx.job?.metadata
-    );
+  // ---------------------------------------------------------------------------
+  // Private Methods - Accessors
+  // ---------------------------------------------------------------------------
+  /**
+   * Creates a queue accessor with job accessors and management methods.
+   * @internal
+   */
+  createQueueAccessor(queueName) {
+    const queueConfig = this.config.queues[queueName];
+    const self = this;
+    const queueAccessor = {
+      async list(filter) {
+        return self.adapter.queues.getJobs(queueName, filter);
+      },
+      get() {
+        return {
+          retrieve: () => self.adapter.getQueueInfo(queueName),
+          pause: () => self.adapter.pauseQueue(queueName),
+          resume: () => self.adapter.resumeQueue(queueName),
+          drain: () => self.adapter.drainQueue(queueName),
+          clean: (options) => self.adapter.cleanQueue(queueName, options),
+          obliterate: (options) => self.adapter.obliterateQueue(queueName, options),
+          retryAll: () => self.adapter.retryAllInQueue(queueName)
+        };
+      },
+      async subscribe(handler) {
+        const channel = self.buildEventsChannel();
+        return self.adapter.subscribeEvent(channel, async (event) => {
+          const typed = event;
+          if (typeof typed?.type === "string" && typed.type.startsWith(`${queueName}:`)) {
+            await handler(typed);
+          }
+        });
+      },
+      jobs: {}
+    };
+    for (const jobName of Object.keys(queueConfig.jobs)) {
+      const jobAccessor = this.createJobAccessor(queueName, jobName);
+      queueAccessor.jobs[jobName] = jobAccessor;
+      queueAccessor[jobName] = jobAccessor;
+    }
+    return queueAccessor;
+  }
+  /**
+   * Creates a job accessor with dispatch, schedule, and management methods.
+   * @internal
+   */
+  createJobAccessor(queueName, jobName) {
+    const self = this;
     return {
-      ...ctx,
-      context: realContext,
-      job: { ...ctx.job, name: cronName, queue: queueName },
-      scope
+      async dispatch(params) {
+        return self.dispatchJob(queueName, jobName, params);
+      },
+      async schedule(params) {
+        return self.scheduleJob(queueName, jobName, params);
+      },
+      get(id) {
+        return {
+          retrieve: () => self.adapter.getJob(id, queueName),
+          retry: () => self.adapter.retryJob(id, queueName),
+          remove: () => self.adapter.removeJob(id, queueName),
+          promote: () => self.adapter.promoteJob(id, queueName),
+          move: (state, reason) => {
+            if (state !== "failed") return Promise.resolve();
+            return self.adapter.moveJobToFailed(id, reason, queueName);
+          },
+          state: () => self.adapter.getJobState(id, queueName),
+          progress: () => self.adapter.getJobProgress(id, queueName),
+          logs: () => self.adapter.getJobLogs(id, queueName)
+        };
+      },
+      many(ids) {
+        return {
+          retry: () => self.adapter.retryManyJobs(ids, queueName),
+          remove: () => self.adapter.removeManyJobs(ids, queueName)
+        };
+      },
+      pause: () => self.adapter.pauseJobType(queueName, jobName),
+      resume: () => self.adapter.resumeJobType(queueName, jobName),
+      async subscribe(handler) {
+        const channel = self.buildEventsChannel();
+        return self.adapter.subscribeEvent(channel, async (event) => {
+          const typed = event;
+          if (typeof typed?.type === "string" && typed.type.startsWith(`${queueName}:${jobName}:`)) {
+            await handler(typed);
+          }
+        });
+      }
     };
-  };
-  const publishLifecycle = async (event, ctx, data) => {
-    const scope = ctx.scope ?? IgniterJobsScopeUtils.extractScopeFromMetadata(
-      ctx.job?.metadata
+  }
+  // ---------------------------------------------------------------------------
+  // Private Methods - Job Operations
+  // ---------------------------------------------------------------------------
+  /**
+   * Dispatches a job for immediate or delayed processing.
+   * @internal
+   */
+  async dispatchJob(queueName, jobName, params) {
+    const definition = this.getJobDefinition(queueName, jobName);
+    if (definition?.input) {
+      await IgniterJobsValidationUtils.validateInput(
+        definition.input,
+        params.input
+      );
+    }
+    const scope = this.resolveScope(params.scope);
+    const metadata = IgniterJobsScopeUtils.mergeMetadataWithScope(
+      params.metadata,
+      scope
     );
-    await IgniterJobsEventsUtils.publishJobsEvent({
-      adapter,
-      service: config.service,
-      environment: config.environment,
+    const jobId = await this.adapter.dispatch({
+      queue: queueName,
+      jobName,
+      ...params,
       scope,
-      event: {
-        type: IgniterJobsEventsUtils.buildJobEventType(
-          queueName,
-          cronName,
-          event
-        ),
-        data,
-        timestamp: /* @__PURE__ */ new Date(),
-        scope
-      }
+      metadata
     });
-  };
-  return {
-    ...definition,
-    handler: async (ctx) => {
-      const enhanced = await buildExecutionContext(ctx);
-      await publishLifecycle("started", enhanced, {
-        jobId: enhanced.job?.id,
-        jobName: cronName,
-        queue: queueName,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      try {
-        const result = await definition.handler(enhanced);
-        await publishLifecycle("completed", enhanced, {
-          jobId: enhanced.job?.id,
-          jobName: cronName,
-          queue: queueName,
-          result,
-          completedAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        return result;
-      } catch (error) {
-        await publishLifecycle("failed", enhanced, {
-          jobId: enhanced.job?.id,
-          jobName: cronName,
-          queue: queueName,
-          error: { message: error?.message ?? String(error) },
-          failedAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        throw error;
-      }
+    await this.publishJobEvent(
+      queueName,
+      jobName,
+      "enqueued",
+      { jobId, queue: queueName, jobName },
+      scope
+    );
+    this.emitTelemetry("igniter.jobs.job.enqueued", {
+      "ctx.job.id": jobId,
+      "ctx.job.name": jobName,
+      "ctx.job.queue": queueName,
+      "ctx.job.priority": params.priority ?? null,
+      "ctx.job.delay": params.delay ?? null
+    });
+    return jobId;
+  }
+  /**
+   * Schedules a job for future processing.
+   * @internal
+   */
+  async scheduleJob(queueName, jobName, params) {
+    const definition = this.getJobDefinition(queueName, jobName);
+    if (definition?.input) {
+      await IgniterJobsValidationUtils.validateInput(
+        definition.input,
+        params.input
+      );
     }
-  };
-}
-function wrapJobDefinition(params) {
-  const { config, queueName, jobName, definition } = params;
-  const buildExecutionContext = async (ctx) => {
-    const realContext = await config.contextFactory();
-    const scope = ctx.scope ?? IgniterJobsScopeUtils.extractScopeFromMetadata(ctx.job.metadata);
-    return {
-      ...ctx,
-      context: realContext,
-      job: { ...ctx.job, name: jobName, queue: queueName },
+    const scope = this.resolveScope(params.scope);
+    const metadata = IgniterJobsScopeUtils.mergeMetadataWithScope(
+      params.metadata,
       scope
-    };
-  };
-  const publishLifecycle = async (event, ctx, data) => {
-    const scope = ctx.scope ?? IgniterJobsScopeUtils.extractScopeFromMetadata(
-      ctx.job?.metadata
     );
-    await IgniterJobsEventsUtils.publishJobsEvent({
-      adapter: params.adapter,
-      service: config.service,
-      environment: config.environment,
+    const jobId = await this.adapter.schedule({
+      queue: queueName,
+      jobName,
+      ...params,
       scope,
-      event: {
-        type: IgniterJobsEventsUtils.buildJobEventType(
+      metadata
+    });
+    await this.publishJobEvent(
+      queueName,
+      jobName,
+      "scheduled",
+      { jobId, queue: queueName, jobName },
+      scope
+    );
+    this.emitTelemetry("igniter.jobs.job.scheduled", {
+      "ctx.job.id": jobId,
+      "ctx.job.name": jobName,
+      "ctx.job.queue": queueName,
+      "ctx.job.scheduledAt": params.runAt?.toISOString?.() ?? null,
+      "ctx.job.cron": params.cron ?? null
+    });
+    return jobId;
+  }
+  // ---------------------------------------------------------------------------
+  // Private Methods - Handler Wrapping
+  // ---------------------------------------------------------------------------
+  /**
+   * Wraps a job definition with context building, validation, and telemetry.
+   * @internal
+   */
+  wrapJobDefinition(queueName, jobName, definition) {
+    const self = this;
+    return {
+      ...definition,
+      handler: async (ctx) => {
+        const enhanced = await self.buildExecutionContext(
+          ctx,
+          queueName,
+          jobName
+        );
+        if (definition.input) {
+          const validated = await IgniterJobsValidationUtils.validateInput(
+            definition.input,
+            enhanced.input
+          );
+          enhanced.input = validated;
+        }
+        return definition.handler(enhanced);
+      },
+      onStart: async (ctx) => {
+        const enhanced = await self.buildExecutionContext(
+          ctx,
+          queueName,
+          jobName
+        );
+        await self.publishJobEvent(
           queueName,
           jobName,
-          event
-        ),
-        data,
-        timestamp: /* @__PURE__ */ new Date(),
-        scope
-      }
-    });
-  };
-  return {
-    ...definition,
-    handler: async (ctx) => {
-      const enhanced = await buildExecutionContext(ctx);
-      if (definition.input) {
-        const validated = await IgniterJobsValidationUtils.validateInput(
-          definition.input,
-          enhanced.input
+          "started",
+          {
+            jobId: enhanced.job.id,
+            jobName,
+            queue: queueName,
+            attemptsMade: enhanced.job.attemptsMade,
+            startedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          enhanced.scope
         );
-        enhanced.input = validated;
-      }
-      return definition.handler(enhanced);
-    },
-    onStart: async (ctx) => {
-      const enhanced = await buildExecutionContext(ctx);
-      await publishLifecycle("started", enhanced, {
-        jobId: enhanced.job.id,
-        jobName,
-        queue: queueName,
-        attemptsMade: enhanced.job.attemptsMade,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      IgniterJobsTelemetryUtils.emitTelemetry(
-        config.telemetry,
-        "igniter.jobs.job.started",
-        {
+        self.emitTelemetry("igniter.jobs.job.started", {
           "ctx.job.id": enhanced.job.id,
           "ctx.job.name": jobName,
           "ctx.job.queue": queueName,
           "ctx.job.attempt": enhanced.job.attemptsMade,
           "ctx.job.maxAttempts": definition.attempts ?? 3
-        }
-      );
-      await definition.onStart?.(enhanced);
-    },
-    onSuccess: async (ctx) => {
-      const enhanced = await buildExecutionContext(ctx);
-      const duration = ctx.duration ?? ctx.executionTime ?? 0;
-      await publishLifecycle(
-        "completed",
-        { ...enhanced},
-        {
-          jobId: enhanced.job.id,
+        });
+        await definition.onStart?.(enhanced);
+      },
+      onSuccess: async (ctx) => {
+        const enhanced = await self.buildExecutionContext(
+          ctx,
+          queueName,
+          jobName
+        );
+        const duration = ctx.duration ?? ctx.executionTime ?? 0;
+        await self.publishJobEvent(
+          queueName,
           jobName,
-          queue: queueName,
-          result: ctx.result,
-          duration,
-          completedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      );
-      IgniterJobsTelemetryUtils.emitTelemetry(
-        config.telemetry,
-        "igniter.jobs.job.completed",
-        {
+          "completed",
+          {
+            jobId: enhanced.job.id,
+            jobName,
+            queue: queueName,
+            result: ctx.result,
+            duration,
+            completedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          enhanced.scope
+        );
+        self.emitTelemetry("igniter.jobs.job.completed", {
           "ctx.job.id": enhanced.job.id,
           "ctx.job.name": jobName,
           "ctx.job.queue": queueName,
           "ctx.job.duration": typeof duration === "number" ? duration : 0
-        }
-      );
-      await definition.onSuccess?.(enhanced);
-    },
-    onFailure: async (ctx) => {
-      const enhanced = await buildExecutionContext(ctx);
-      const duration = ctx.duration ?? ctx.executionTime ?? 0;
-      const isFinalAttempt = Boolean(ctx.isFinalAttempt);
-      const errorMessage = ctx.error?.message ?? String(ctx.error);
-      const errorCode = ctx.error?.code;
-      const maxAttempts = definition.attempts ?? 3;
-      await publishLifecycle(
-        "failed",
-        { ...enhanced},
-        {
-          jobId: enhanced.job.id,
+        });
+        await definition.onSuccess?.(enhanced);
+      },
+      onFailure: async (ctx) => {
+        const enhanced = await self.buildExecutionContext(
+          ctx,
+          queueName,
+          jobName
+        );
+        const duration = ctx.duration ?? ctx.executionTime ?? 0;
+        const isFinalAttempt = Boolean(ctx.isFinalAttempt);
+        const errorMessage = ctx.error?.message ?? String(ctx.error);
+        const errorCode = ctx.error?.code;
+        const maxAttempts = definition.attempts ?? 3;
+        await self.publishJobEvent(
+          queueName,
           jobName,
-          queue: queueName,
-          error: { message: errorMessage },
-          attemptsMade: enhanced.job.attemptsMade,
-          isFinalAttempt,
-          duration,
-          failedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      );
-      IgniterJobsTelemetryUtils.emitTelemetry(
-        config.telemetry,
-        "igniter.jobs.job.failed",
-        {
-          "ctx.job.id": enhanced.job.id,
-          "ctx.job.name": jobName,
-          "ctx.job.queue": queueName,
-          "ctx.job.error.message": errorMessage,
-          "ctx.job.error.code": errorCode ?? null,
-          "ctx.job.attempt": enhanced.job.attemptsMade,
-          "ctx.job.maxAttempts": maxAttempts,
-          "ctx.job.isFinalAttempt": isFinalAttempt
-        },
-        "error"
-      );
-      await definition.onFailure?.(enhanced);
-    },
-    onProgress: definition.onProgress ? async (ctx) => {
-      const enhanced = await buildExecutionContext(ctx);
-      const progress = ctx.progress ?? 0;
-      const message = ctx.message;
-      await publishLifecycle("progress", enhanced, {
-        jobId: enhanced.job.id,
-        jobName,
-        queue: queueName,
-        progress,
-        message,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      IgniterJobsTelemetryUtils.emitTelemetry(
-        config.telemetry,
-        "igniter.jobs.job.progress",
-        {
+          "failed",
+          {
+            jobId: enhanced.job.id,
+            jobName,
+            queue: queueName,
+            error: { message: errorMessage },
+            attemptsMade: enhanced.job.attemptsMade,
+            isFinalAttempt,
+            duration,
+            failedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          enhanced.scope
+        );
+        self.emitTelemetry(
+          "igniter.jobs.job.failed",
+          {
+            "ctx.job.id": enhanced.job.id,
+            "ctx.job.name": jobName,
+            "ctx.job.queue": queueName,
+            "ctx.job.error.message": errorMessage,
+            "ctx.job.error.code": errorCode ?? null,
+            "ctx.job.attempt": enhanced.job.attemptsMade,
+            "ctx.job.maxAttempts": maxAttempts,
+            "ctx.job.isFinalAttempt": isFinalAttempt
+          },
+          "error"
+        );
+        await definition.onFailure?.(enhanced);
+      },
+      onProgress: definition.onProgress ? async (ctx) => {
+        const enhanced = await self.buildExecutionContext(
+          ctx,
+          queueName,
+          jobName
+        );
+        const progress = ctx.progress ?? 0;
+        const message = ctx.message;
+        await self.publishJobEvent(
+          queueName,
+          jobName,
+          "progress",
+          {
+            jobId: enhanced.job.id,
+            jobName,
+            queue: queueName,
+            progress,
+            message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          enhanced.scope
+        );
+        self.emitTelemetry("igniter.jobs.job.progress", {
           "ctx.job.id": enhanced.job.id,
           "ctx.job.name": jobName,
           "ctx.job.queue": queueName,
           "ctx.job.progress": typeof progress === "number" ? progress : 0,
           "ctx.job.progress.message": message ?? null
+        });
+        await definition.onProgress?.(enhanced);
+      } : void 0
+    };
+  }
+  /**
+   * Wraps a cron definition with context building and lifecycle events.
+   * @internal
+   */
+  wrapCronDefinition(queueName, cronName, definition) {
+    const self = this;
+    return {
+      ...definition,
+      handler: async (ctx) => {
+        const enhanced = await self.buildCronExecutionContext(
+          ctx,
+          queueName,
+          cronName
+        );
+        await self.publishJobEvent(
+          queueName,
+          cronName,
+          "started",
+          {
+            jobId: enhanced.job?.id,
+            jobName: cronName,
+            queue: queueName,
+            startedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          enhanced.scope
+        );
+        try {
+          const result = await definition.handler(enhanced);
+          await self.publishJobEvent(
+            queueName,
+            cronName,
+            "completed",
+            {
+              jobId: enhanced.job?.id,
+              jobName: cronName,
+              queue: queueName,
+              result,
+              completedAt: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            enhanced.scope
+          );
+          return result;
+        } catch (error) {
+          await self.publishJobEvent(
+            queueName,
+            cronName,
+            "failed",
+            {
+              jobId: enhanced.job?.id,
+              jobName: cronName,
+              queue: queueName,
+              error: { message: error?.message ?? String(error) },
+              failedAt: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            enhanced.scope
+          );
+          throw error;
         }
-      );
-      await definition.onProgress?.(enhanced);
-    } : void 0
-  };
-}
-function createQueueAccessor(params) {
-  const { internal, boundScope, queueName, queueConfig } = params;
-  const queueAccessor = {
-    async list(filter) {
-      return internal.adapter.queues.getJobs(queueName, filter);
-    },
-    get() {
-      return {
-        retrieve: () => internal.adapter.getQueueInfo(queueName),
-        pause: () => internal.adapter.pauseQueue(queueName),
-        resume: () => internal.adapter.resumeQueue(queueName),
-        drain: () => internal.adapter.drainQueue(queueName),
-        clean: (options) => internal.adapter.cleanQueue(queueName, options),
-        obliterate: (options) => internal.adapter.obliterateQueue(queueName, options),
-        retryAll: () => internal.adapter.retryAllInQueue(queueName)
-      };
-    },
-    async subscribe(handler) {
-      const channel = boundScope ? IgniterJobsPrefix.buildEventsChannel({
-        service: internal.config.service,
-        environment: internal.config.environment,
-        scope: { type: boundScope.type, id: boundScope.id }
-      }) : IgniterJobsPrefix.buildEventsChannel({
-        service: internal.config.service,
-        environment: internal.config.environment
-      });
-      return internal.adapter.subscribeEvent(channel, async (event) => {
-        const typed = event;
-        if (typeof typed?.type === "string" && typed.type.startsWith(`${queueName}:`)) {
-          await handler(typed);
-        }
-      });
-    },
-    jobs: {}
-  };
-  for (const jobName of Object.keys(queueConfig.jobs)) {
-    queueAccessor.jobs[jobName] = createJobAccessor({
-      internal,
-      boundScope,
-      queueName,
-      jobName
-    });
-    queueAccessor[jobName] = queueAccessor.jobs[jobName];
+      }
+    };
   }
-  return queueAccessor;
-}
-function createJobAccessor(params) {
-  const { internal, boundScope, queueName, jobName } = params;
-  const resolveScope = (paramsScope) => {
-    if (!internal.config.scopeDefinition) return void 0;
+  // ---------------------------------------------------------------------------
+  // Private Methods - Helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Builds the execution context for a job.
+   * @internal
+   */
+  async buildExecutionContext(ctx, queueName, jobName) {
+    const realContext = await this.config.contextFactory();
+    const scope = ctx.scope ?? IgniterJobsScopeUtils.extractScopeFromMetadata(ctx.job.metadata);
+    return {
+      ...ctx,
+      context: realContext,
+      job: { ...ctx.job, name: jobName, queue: queueName },
+      scope
+    };
+  }
+  /**
+   * Builds the execution context for a cron job.
+   * @internal
+   */
+  async buildCronExecutionContext(ctx, queueName, cronName) {
+    const realContext = await this.config.contextFactory();
+    const scope = ctx.scope ?? IgniterJobsScopeUtils.extractScopeFromMetadata(
+      ctx.job?.metadata
+    );
+    return {
+      ...ctx,
+      context: realContext,
+      job: { ...ctx.job, name: cronName, queue: queueName },
+      scope
+    };
+  }
+  /**
+   * Gets a job definition by queue and job name.
+   * @internal
+   */
+  getJobDefinition(queueName, jobName) {
+    const queue = this.config.queues[queueName];
+    return queue?.jobs?.[jobName];
+  }
+  /**
+   * Resolves the effective scope for a job operation.
+   * @internal
+   */
+  resolveScope(paramsScope) {
+    if (!this.config.scopeDefinition) return void 0;
     const required = Object.values(
-      internal.config.scopeDefinition
+      this.config.scopeDefinition
     )[0]?.required ?? false;
-    const effective = boundScope ?? paramsScope;
+    const effective = this.scopeEntry ?? paramsScope;
     if (required && !effective) {
       throw new IgniterJobsError({
         code: "JOBS_CONFIGURATION_INVALID",
         message: "Scope is required for this jobs instance."
       });
     }
-    if (boundScope && paramsScope) {
-      if (boundScope.type !== paramsScope.type || boundScope.id !== paramsScope.id) {
+    if (this.scopeEntry && paramsScope) {
+      if (this.scopeEntry.type !== paramsScope.type || this.scopeEntry.id !== paramsScope.id) {
         throw new IgniterJobsError({
           code: "JOBS_CONFIGURATION_INVALID",
           message: "Cannot override scope on a scoped jobs instance."
@@ -744,308 +937,57 @@ function createJobAccessor(params) {
       }
     }
     return effective;
-  };
-  const publish = async (event) => {
-    await IgniterJobsEventsUtils.publishJobsEvent({
-      adapter: internal.adapter,
-      service: internal.config.service,
-      environment: internal.config.environment,
-      scope: event.scope,
-      event
+  }
+  /**
+   * Builds the events channel string for subscriptions.
+   * @internal
+   */
+  buildEventsChannel() {
+    return this.scopeEntry ? IgniterJobsPrefix.buildEventsChannel({
+      service: this.config.service,
+      environment: this.config.environment,
+      scope: { type: this.scopeEntry.type, id: this.scopeEntry.id }
+    }) : IgniterJobsPrefix.buildEventsChannel({
+      service: this.config.service,
+      environment: this.config.environment
     });
-  };
-  const getDefinition = () => {
-    const q = internal.config.queues[queueName];
-    return q?.jobs?.[jobName];
-  };
-  return {
-    async dispatch(params2) {
-      const definition = getDefinition();
-      if (definition?.input) {
-        await IgniterJobsValidationUtils.validateInput(
-          definition.input,
-          params2.input
-        );
-      }
-      const scope = resolveScope(params2.scope);
-      const metadata = IgniterJobsScopeUtils.mergeMetadataWithScope(
-        params2.metadata,
-        scope
-      );
-      const jobId = await internal.adapter.dispatch({
-        queue: queueName,
-        jobName,
-        ...params2,
-        scope,
-        metadata
-      });
-      await publish({
+  }
+  /**
+   * Publishes a job lifecycle event.
+   * @internal
+   */
+  async publishJobEvent(queueName, jobName, eventType, data, scope) {
+    await IgniterJobsEventsUtils.publishJobsEvent({
+      adapter: this.adapter,
+      service: this.config.service,
+      environment: this.config.environment,
+      scope,
+      event: {
         type: IgniterJobsEventsUtils.buildJobEventType(
           queueName,
           jobName,
-          "enqueued"
+          eventType
         ),
-        data: { jobId, queue: queueName, jobName },
+        data,
         timestamp: /* @__PURE__ */ new Date(),
         scope
-      });
-      IgniterJobsTelemetryUtils.emitTelemetry(
-        internal.config.telemetry,
-        "igniter.jobs.job.enqueued",
-        {
-          "ctx.job.id": jobId,
-          "ctx.job.name": jobName,
-          "ctx.job.queue": queueName,
-          "ctx.job.priority": params2.priority ?? null,
-          "ctx.job.delay": params2.delay ?? null
-        }
-      );
-      return jobId;
-    },
-    async schedule(params2) {
-      const definition = getDefinition();
-      if (definition?.input) {
-        await IgniterJobsValidationUtils.validateInput(
-          definition.input,
-          params2.input
-        );
       }
-      const scope = resolveScope(params2.scope);
-      const metadata = IgniterJobsScopeUtils.mergeMetadataWithScope(
-        params2.metadata,
-        scope
-      );
-      const jobId = await internal.adapter.schedule({
-        queue: queueName,
-        jobName,
-        ...params2,
-        scope,
-        metadata
-      });
-      await publish({
-        type: IgniterJobsEventsUtils.buildJobEventType(
-          queueName,
-          jobName,
-          "scheduled"
-        ),
-        data: { jobId, queue: queueName, jobName },
-        timestamp: /* @__PURE__ */ new Date(),
-        scope
-      });
-      IgniterJobsTelemetryUtils.emitTelemetry(
-        internal.config.telemetry,
-        "igniter.jobs.job.scheduled",
-        {
-          "ctx.job.id": jobId,
-          "ctx.job.name": jobName,
-          "ctx.job.queue": queueName,
-          "ctx.job.scheduledAt": params2.runAt?.toISOString?.() ?? null,
-          "ctx.job.cron": params2.cron ?? null
-        }
-      );
-      return jobId;
-    },
-    get(id) {
-      return {
-        retrieve: () => internal.adapter.getJob(id, queueName),
-        retry: () => internal.adapter.retryJob(id, queueName),
-        remove: () => internal.adapter.removeJob(id, queueName),
-        promote: () => internal.adapter.promoteJob(id, queueName),
-        move: (state, reason) => {
-          if (state !== "failed") return Promise.resolve();
-          return internal.adapter.moveJobToFailed(id, reason, queueName);
-        },
-        state: () => internal.adapter.getJobState(id, queueName),
-        progress: () => internal.adapter.getJobProgress(id, queueName),
-        logs: () => internal.adapter.getJobLogs(id, queueName)
-      };
-    },
-    many(ids) {
-      return {
-        retry: () => internal.adapter.retryManyJobs(ids, queueName),
-        remove: () => internal.adapter.removeManyJobs(ids, queueName)
-      };
-    },
-    pause: () => internal.adapter.pauseJobType(queueName, jobName),
-    resume: () => internal.adapter.resumeJobType(queueName, jobName),
-    async subscribe(handler) {
-      const channel = boundScope ? IgniterJobsPrefix.buildEventsChannel({
-        service: internal.config.service,
-        environment: internal.config.environment,
-        scope: { type: boundScope.type, id: boundScope.id }
-      }) : IgniterJobsPrefix.buildEventsChannel({
-        service: internal.config.service,
-        environment: internal.config.environment
-      });
-      return internal.adapter.subscribeEvent(channel, async (event) => {
-        const typed = event;
-        if (typeof typed?.type === "string" && typed.type.startsWith(`${queueName}:${jobName}:`)) {
-          await handler(typed);
-        }
-      });
-    }
-  };
-}
-
-// src/builders/igniter-jobs.builder.ts
-var IgniterJobsBuilder = class _IgniterJobsBuilder {
-  constructor(state) {
-    this.state = {
-      queues: state?.queues ?? {},
-      ...state
-    };
-  }
-  /**
-   * Creates the initial builder with no configuration.
-   */
-  static create() {
-    return new _IgniterJobsBuilder({ queues: {} });
-  }
-  /**
-   * Returns a new builder with updated state while preserving generics.
-   */
-  clone(patch) {
-    return new _IgniterJobsBuilder({
-      ...this.state,
-      ...patch,
-      queues: patch.queues ?? this.state.queues,
-      scope: patch.scope ?? this.state.scope
     });
   }
   /**
-   * Attaches the jobs adapter.
-   *
-   * @param adapter - Backend adapter implementation (BullMQ, memory, etc.).
-   */
-  withAdapter(adapter) {
-    return this.clone({ adapter });
-  }
-  /**
-   * Sets the service identifier for telemetry and metrics.
-   *
-   * @param service - Service name (e.g., "my-api").
-   */
-  withService(service) {
-    return this.clone({ service });
-  }
-  /**
-   * Sets the environment name (e.g., development, staging, production).
-   */
-  withEnvironment(environment) {
-    return this.clone({ environment });
-  }
-  /**
-   * Provides a context factory used when executing jobs.
-   */
-  withContext(factory) {
-    return this.clone({ contextFactory: factory });
-  }
-  /**
-   * Adds a scope definition (single scope supported).
-   */
-  addScope(name, options) {
-    if (this.state.scope) {
-      throw new IgniterJobsError({
-        code: "JOBS_SCOPE_ALREADY_DEFINED",
-        message: "Only one scope can be defined for IgniterJobs."
-      });
-    }
-    return this.clone({ scope: { name, options } });
-  }
-  /**
-   * Registers a queue definition on the builder.
-   */
-  addQueue(queue) {
-    if (this.state.queues[queue.name]) {
-      throw new IgniterJobsError({
-        code: "JOBS_QUEUE_DUPLICATE",
-        message: `Queue "${queue.name}" is already registered.`
-      });
-    }
-    const nextQueues = {
-      ...this.state.queues,
-      [queue.name]: queue
-    };
-    return this.clone({ queues: nextQueues });
-  }
-  /**
-   * Applies default job options to all queues.
-   */
-  withQueueDefaults(defaults) {
-    return this.clone({ queueDefaults: defaults });
-  }
-  /**
-   * Applies default worker options.
-   */
-  withWorkerDefaults(defaults) {
-    return this.clone({ workerDefaults: defaults });
-  }
-  /**
-   * Configures automatic worker startup.
-   */
-  withAutoStartWorker(config) {
-    return this.clone({ autoStartWorker: config });
-  }
-  /**
-   * Attaches telemetry support.
-   */
-  withTelemetry(telemetry) {
-    return this.clone({ telemetry });
-  }
-  /**
-   * Attaches a custom logger.
-   */
-  withLogger(logger) {
-    return this.clone({ logger });
-  }
-  /**
-   * Finalizes the configuration and returns the runtime instance.
+   * Emits a telemetry event if telemetry is configured.
+   * @internal
    */
-  build() {
-    if (!this.state.adapter) {
-      throw new IgniterJobsError({
-        code: "JOBS_ADAPTER_REQUIRED",
-        message: "Jobs adapter is required. Call withAdapter() before build()."
-      });
-    }
-    if (!this.state.service) {
-      throw new IgniterJobsError({
-        code: "JOBS_SERVICE_REQUIRED",
-        message: "Service name is required. Call withService() before build()."
-      });
-    }
-    if (!this.state.environment) {
-      throw new IgniterJobsError({
-        code: "JOBS_CONFIGURATION_INVALID",
-        message: "Environment is required. Call withEnvironment() before build()."
-      });
-    }
-    if (!this.state.contextFactory) {
-      throw new IgniterJobsError({
-        code: "JOBS_CONTEXT_REQUIRED",
-        message: "Context factory is required. Call withContext() before build()."
-      });
-    }
-    const config = {
-      adapter: this.state.adapter,
-      service: this.state.service,
-      environment: this.state.environment,
-      contextFactory: this.state.contextFactory,
-      queues: this.state.queues,
-      scopeDefinition: this.state.scope ? {
-        [this.state.scope.name]: this.state.scope.options ?? {}
-      } : void 0,
-      queueDefaults: this.state.queueDefaults,
-      workerDefaults: this.state.workerDefaults,
-      autoStartWorker: this.state.autoStartWorker,
-      logger: this.state.logger,
-      telemetry: this.state.telemetry
-    };
-    return IgniterJobs.fromConfig(config);
+  emitTelemetry(eventName, attributes, level = "info") {
+    if (!this.telemetry) return;
+    this.telemetry.emit(eventName, {
+      attributes,
+      level
+    });
   }
 };
 
-// src/builders/igniter-queue.builder.ts
+// src/builders/queue.builder.ts
 var IgniterQueueBuilder = class _IgniterQueueBuilder {
   constructor(state) {
     this.state = state;
@@ -1066,21 +1008,6 @@ var IgniterQueueBuilder = class _IgniterQueueBuilder {
       crons: {}
     });
   }
-  /**
-   * Re-types this builder with the application context type.
-   *
-   * This is a type-level helper; it does not mutate runtime state.
-   *
-   * @example
-   * ```typescript
-   * const queue = IgniterQueue.create('email')
-   *   .withContext<AppContext>()
-   *   .addJob('send', { handler: async ({ context }) => context.mailer.send() })
-   * ```
-   */
-  withContext() {
-    return this;
-  }
   clone(patch) {
     return new _IgniterQueueBuilder({
       ...this.state,
@@ -1195,7 +1122,7 @@ var IgniterQueueBuilder = class _IgniterQueueBuilder {
   }
 };
 
-// src/core/igniter-queue.ts
+// src/core/queue.ts
 var IgniterQueue = class {
   /**
    * Creates a new queue builder for the given name.
@@ -1212,54 +1139,253 @@ var IgniterQueue = class {
     return IgniterQueueBuilder.create(name);
   }
 };
-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.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)
+
+// src/builders/main.builder.ts
+var IgniterJobsBuilder = class _IgniterJobsBuilder {
+  constructor(state) {
+    this.state = {
+      queues: state?.queues ?? {},
+      ...state
     };
   }
-  static create(options) {
-    return new _IgniterJobsBullMQAdapter(options);
-  }
+  /**
+   * Creates the initial builder with no configuration.
+   *
+   * Context type is inferred from `withContext()` - no explicit generic needed.
+   *
+   * @example
+   * ```typescript
+   * // Context is inferred from the factory return type
+   * const jobs = IgniterJobs.create()
+   *   .withContext(async () => ({ db: prisma, cache: redis }))
+   *   // TContext is now { db: PrismaClient, cache: Redis }
+   *   .build()
+   * ```
+   */
+  static create() {
+    return new _IgniterJobsBuilder({
+      queues: {}
+    });
+  }
+  /**
+   * Returns a new builder with updated state while preserving generics.
+   */
+  clone(patch) {
+    return new _IgniterJobsBuilder({
+      ...this.state,
+      ...patch,
+      queues: patch.queues ?? this.state.queues,
+      scope: patch.scope ?? this.state.scope
+    });
+  }
+  /**
+   * Attaches the jobs adapter.
+   *
+   * @param adapter - Backend adapter implementation (BullMQ, memory, etc.).
+   */
+  withAdapter(adapter) {
+    return this.clone({ adapter });
+  }
+  /**
+   * Sets the service identifier for telemetry and metrics.
+   *
+   * @param service - Service name (e.g., "my-api").
+   */
+  withService(service) {
+    return this.clone({ service });
+  }
+  /**
+   * Sets the environment name (e.g., development, staging, production).
+   */
+  withEnvironment(environment) {
+    return this.clone({ environment });
+  }
+  /**
+   * Provides a context factory used when executing jobs.
+   *
+   * The context type is inferred from the factory return type, eliminating
+   * the need for explicit generics on `IgniterJobs.create()`.
+   *
+   * **Note:** This must be called before adding any queues, as the context
+   * type affects queue type compatibility.
+   *
+   * @param factory - Function that returns the context (sync or async)
+   * @returns A new builder with the inferred context type
+   *
+   * @example
+   * ```typescript
+   * // Context type is inferred as { db: PrismaClient, cache: Redis }
+   * const jobs = IgniterJobs.create()
+   *   .withContext(async () => ({
+   *     db: new PrismaClient(),
+   *     cache: new Redis(),
+   *   }))
+   *   .addQueue(emailQueue)
+   *   .build()
+   * ```
+   */
+  withContext(factory) {
+    return new _IgniterJobsBuilder({
+      ...this.state,
+      contextFactory: factory,
+      queues: {}
+    });
+  }
+  /**
+   * Adds a scope definition (single scope supported).
+   */
+  addScope(name, options) {
+    if (this.state.scope) {
+      throw new IgniterJobsError({
+        code: "JOBS_SCOPE_ALREADY_DEFINED",
+        message: "Only one scope can be defined for IgniterJobs."
+      });
+    }
+    return this.clone({ scope: { name, options } });
+  }
+  /**
+   * Registers a queue definition on the builder.
+   */
+  addQueue(queue) {
+    if (this.state.queues[queue.name]) {
+      throw new IgniterJobsError({
+        code: "JOBS_QUEUE_DUPLICATE",
+        message: `Queue "${queue.name}" is already registered.`
+      });
+    }
+    const nextQueues = {
+      ...this.state.queues,
+      [queue.name]: queue
+    };
+    return this.clone({ queues: nextQueues });
+  }
+  /**
+   * Applies default job options to all queues.
+   */
+  withQueueDefaults(defaults) {
+    return this.clone({ queueDefaults: defaults });
+  }
+  /**
+   * Applies default worker options.
+   */
+  withWorkerDefaults(defaults) {
+    return this.clone({ workerDefaults: defaults });
+  }
+  /**
+   * Configures automatic worker startup.
+   */
+  withAutoStartWorker(config) {
+    return this.clone({ autoStartWorker: config });
+  }
+  /**
+   * Attaches telemetry support.
+   */
+  withTelemetry(telemetry) {
+    return this.clone({ telemetry });
+  }
+  /**
+   * Attaches a custom logger.
+   */
+  withLogger(logger) {
+    return this.clone({ logger });
+  }
+  /**
+   * Finalizes the configuration and returns the runtime instance.
+   */
+  build() {
+    if (!this.state.adapter) {
+      throw new IgniterJobsError({
+        code: "JOBS_ADAPTER_REQUIRED",
+        message: "Jobs adapter is required. Call withAdapter() before build()."
+      });
+    }
+    if (!this.state.service) {
+      throw new IgniterJobsError({
+        code: "JOBS_SERVICE_REQUIRED",
+        message: "Service name is required. Call withService() before build()."
+      });
+    }
+    if (!this.state.environment) {
+      throw new IgniterJobsError({
+        code: "JOBS_CONFIGURATION_INVALID",
+        message: "Environment is required. Call withEnvironment() before build()."
+      });
+    }
+    if (!this.state.contextFactory) {
+      throw new IgniterJobsError({
+        code: "JOBS_CONTEXT_REQUIRED",
+        message: "Context factory is required. Call withContext() before build()."
+      });
+    }
+    const config = {
+      adapter: this.state.adapter,
+      service: this.state.service,
+      environment: this.state.environment,
+      contextFactory: this.state.contextFactory,
+      queues: this.state.queues,
+      scopeDefinition: this.state.scope ? {
+        [this.state.scope.name]: this.state.scope.options ?? {}
+      } : void 0,
+      queueDefaults: this.state.queueDefaults,
+      workerDefaults: this.state.workerDefaults,
+      autoStartWorker: this.state.autoStartWorker,
+      logger: this.state.logger,
+      telemetry: this.state.telemetry
+    };
+    return new IgniterJobsManager(config).toRuntime();
+  }
+};
+var IgniterJobs = {
+  create: IgniterJobsBuilder.create
+};
+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.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)
+    };
+  }
+  static create(options) {
+    return new _IgniterJobsBullMQAdapter(options);
+  }
   registerJob(queueName, jobName, definition) {
     const map = this.jobsByQueue.get(queueName) ?? /* @__PURE__ */ new Map();
     if (map.has(jobName)) {
@@ -1752,38 +1878,761 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
   async dispatch(params) {
     const jobId = params.jobId ?? IgniterJobsIdGenerator.generate("job");
     const maxAttempts = params.attempts ?? 1;
-    const metadata = params.metadata ?? {};
-    const job = {
-      id: jobId,
-      name: params.jobName,
-      queue: params.queue,
-      input: params.input,
-      status: this.pausedQueues.has(params.queue) ? "paused" : params.delay && params.delay > 0 ? "delayed" : "waiting",
-      progress: 0,
-      attemptsMade: 0,
+    const metadata = params.metadata ?? {};
+    const job = {
+      id: jobId,
+      name: params.jobName,
+      queue: params.queue,
+      input: params.input,
+      status: this.pausedQueues.has(params.queue) ? "paused" : params.delay && params.delay > 0 ? "delayed" : "waiting",
+      progress: 0,
+      attemptsMade: 0,
+      maxAttempts,
+      priority: params.priority ?? 0,
+      createdAt: /* @__PURE__ */ new Date(),
+      metadata,
+      scope: params.scope,
+      logs: []
+    };
+    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) {
+    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) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return null;
+    if (queue && job.queue !== queue) return null;
+    return this.toSearchResult(job);
+  }
+  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 getJobLogs(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return [];
+    if (queue && job.queue !== queue) return [];
+    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(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) {
+      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.status = "waiting";
+    job.error = void 0;
+    job.completedAt = void 0;
+    job.progress = 0;
+    void this.kickWorkers(job.queue);
+  }
+  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(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) {
+      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.status === "delayed" || job.status === "paused") {
+      job.status = this.pausedQueues.has(job.queue) ? "paused" : "waiting";
+      void this.kickWorkers(job.queue);
+    }
+  }
+  async moveJobToFailed(jobId, reason, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) {
+      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.status = "failed";
+    job.error = reason;
+    job.completedAt = /* @__PURE__ */ new Date();
+  }
+  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 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) {
+    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 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);
+      }
+    }
+  }
+};
+
+// 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,
-      priority: params.priority ?? 0,
-      createdAt: /* @__PURE__ */ new Date(),
-      metadata,
-      scope: params.scope,
-      logs: []
-    };
-    this.jobsById.set(jobId, job);
-    const queueList = this.jobsByQueue.get(params.queue) ?? [];
-    queueList.push(jobId);
-    this.jobsByQueue.set(params.queue, queueList);
+      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(() => {
-        const stored = this.jobsById.get(jobId);
-        if (!stored) return;
-        if (!this.pausedQueues.has(params.queue)) stored.status = "waiting";
-        void this.kickWorkers(params.queue);
+        this.promoteDelayedJob(jobId, params.queue);
       }, params.delay);
-      return jobId;
     }
-    void this.kickWorkers(params.queue);
     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();
@@ -1801,75 +2650,116 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
     return this.dispatch(params);
   }
   async getJob(jobId, queue) {
-    const job = this.jobsById.get(jobId);
-    if (!job) return null;
-    if (queue && job.queue !== queue) return null;
-    return this.toSearchResult(job);
+    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) {
-    const job = this.jobsById.get(jobId);
-    if (!job) return null;
-    if (queue && job.queue !== queue) return null;
-    return job.status;
+    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) {
-    const job = this.jobsById.get(jobId);
-    if (!job) return [];
-    if (queue && job.queue !== queue) return [];
-    return job.logs;
+    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) {
-    const job = this.jobsById.get(jobId);
-    if (!job) return 0;
-    if (queue && job.queue !== queue) return 0;
-    return job.progress;
+    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) {
-    const job = this.jobsById.get(jobId);
-    if (!job) {
-      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found.` });
+    let sql = "SELECT id FROM jobs WHERE id = ?";
+    const checkParams = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      checkParams.push(queue);
     }
-    if (queue && job.queue !== queue) {
-      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found in queue "${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}"` : ""}.`
+      });
     }
-    job.status = "waiting";
-    job.error = void 0;
-    job.completedAt = void 0;
-    job.progress = 0;
-    void this.kickWorkers(job.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) {
-    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));
+    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) {
-    const job = this.jobsById.get(jobId);
-    if (!job) {
-      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found.` });
+    let sql = "SELECT id, status, queue FROM jobs WHERE id = ?";
+    const checkParams = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      checkParams.push(queue);
     }
-    if (queue && job.queue !== queue) {
-      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found in queue "${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 (job.status === "delayed" || job.status === "paused") {
-      job.status = this.pausedQueues.has(job.queue) ? "paused" : "waiting";
-      void this.kickWorkers(job.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) {
-    const job = this.jobsById.get(jobId);
-    if (!job) {
-      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found.` });
+    let sql = "SELECT id FROM jobs WHERE id = ?";
+    const checkParams = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      checkParams.push(queue);
     }
-    if (queue && job.queue !== queue) {
-      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found in queue "${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}"` : ""}.`
+      });
     }
-    job.status = "failed";
-    job.error = reason;
-    job.completedAt = /* @__PURE__ */ new Date();
+    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)));
@@ -1886,7 +2776,6 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
     };
   }
   async getQueueJobCounts(queue) {
-    const jobIds = this.jobsByQueue.get(queue) ?? [];
     const counts = {
       waiting: 0,
       active: 0,
@@ -1895,132 +2784,131 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
       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]++;
+    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 listQueues() {
-    const queues = Array.from(/* @__PURE__ */ new Set([...this.jobsByQueue.keys(), ...this.registeredJobs.keys(), ...this.registeredCrons.keys()]));
+    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 queues) {
-      result.push(await this.getQueueInfo(q));
+    for (const q of allQueues) {
+      const info = await this.getQueueInfo(q);
+      if (info) result.push(info);
     }
     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";
-    }
+    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);
-    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);
+    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 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;
+    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 jobIds = this.jobsByQueue.get(queue) ?? [];
-    const now = Date.now();
-    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;
+    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) {
-    const jobIds = this.jobsByQueue.get(queue) ?? [];
-    for (const id of jobIds) this.jobsById.delete(id);
-    this.jobsByQueue.delete(queue);
+  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 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;
+    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;
   }
   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";
-    }
+    this.db.prepare(
+      "UPDATE jobs SET status = 'paused' WHERE queue = ? AND name = ? AND status = 'waiting'"
+    ).run(queue, jobName);
   }
   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);
+    this.db.prepare(
+      "UPDATE jobs SET status = 'waiting' WHERE queue = ? AND name = ? AND status = 'paused'"
+    ).run(queue, 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));
+    let sql = "SELECT * FROM jobs WHERE 1=1";
+    const params = [];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
+    }
+    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);
+    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));
+    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");
@@ -2032,15 +2920,18 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
       closed: false,
       startedAt: /* @__PURE__ */ new Date(),
       metrics: { processed: 0, failed: 0, totalDuration: 0 },
-      handlers: config.handlers
+      handlers: config.handlers,
+      activeJobs: 0
     };
     this.workers.set(workerId, state);
-    for (const q of state.queues) void this.kickWorkers(q);
+    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));
+    for (const [id, state] of this.workers) {
+      out.set(id, this.toWorkerHandle(state));
+    }
     return out;
   }
   async publishEvent(channel, payload) {
@@ -2060,26 +2951,36 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
     };
   }
   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();
   }
-  toSearchResult(job) {
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+  rowToSearchResult(row) {
     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
+      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) {
@@ -2091,10 +2992,12 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
       },
       resume: async () => {
         worker.paused = false;
-        for (const q of worker.queues) void this.kickWorkers(q);
       },
       close: async () => {
         worker.closed = true;
+        if (worker.pollingTimer) {
+          clearInterval(worker.pollingTimer);
+        }
       },
       isRunning: () => !worker.closed && !worker.paused,
       isPaused: () => worker.paused,
@@ -2113,150 +3016,167 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
       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);
-    }
+  startPollingLoop(worker) {
+    const poll = () => {
+      if (worker.closed || worker.paused) return;
+      void this.processNextJobs(worker);
+    };
+    poll();
+    worker.pollingTimer = setInterval(poll, this.options.pollingInterval);
   }
-  async processLoop(worker, queue) {
+  async processNextJobs(worker) {
     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();
+    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();
+        }
+      });
     }
   }
-  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;
+  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 });
     }
-    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);
+      const definition = this.registeredJobs.get(row.queue)?.get(row.name);
       if (!definition) {
         throw new IgniterJobsError({
           code: "JOBS_NOT_REGISTERED",
-          message: `Job "${job.name}" is not registered for queue "${job.queue}".`
+          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, metadata: job.metadata },
+          job: {
+            id: job.id,
+            name: job.name,
+            queue: job.queue,
+            attemptsMade: job.attemptsMade + 1,
+            metadata: job.metadata
+          },
           scope: job.scope,
-          startedAt: job.startedAt
+          startedAt: /* @__PURE__ */ new Date()
         });
       }
       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 },
+        job: {
+          id: job.id,
+          name: job.name,
+          queue: job.queue,
+          attemptsMade: job.attemptsMade + 1,
+          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;
+      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, metadata: job.metadata },
+          job: {
+            id: job.id,
+            name: job.name,
+            queue: job.queue,
+            attemptsMade: job.attemptsMade + 1,
+            metadata: job.metadata
+          },
           scope: job.scope,
           result,
           duration
         });
       }
-      if (worker.handlers?.onSuccess) await worker.handlers.onSuccess({ job: this.toSearchResult(job), result });
+      if (worker.handlers?.onSuccess) {
+        const updatedJob = await this.getJob(jobId);
+        if (updatedJob) {
+          await worker.handlers.onSuccess({ job: updatedJob, 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;
+      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) {
-        job.status = "failed";
-        job.completedAt = /* @__PURE__ */ new Date();
-        worker.metrics.failed += 1;
-        const definition = this.registeredJobs.get(job.queue)?.get(job.name);
+        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: job.attemptsMade, metadata: job.metadata },
+            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) await worker.handlers.onFailure({ job: this.toSearchResult(job), error });
+        if (worker.handlers?.onFailure) {
+          const updatedJob = await this.getJob(jobId);
+          if (updatedJob) {
+            await worker.handlers.onFailure({ job: updatedJob, error });
+          }
+        }
       } else {
-        job.status = "waiting";
-        void this.kickWorkers(job.queue);
+        this.db.prepare("UPDATE jobs SET status = 'waiting' WHERE id = ?").run(jobId);
       }
     }
   }
-};
-
-// src/telemetry/jobs.telemetry.ts
-var IgniterJobsTelemetryEvents = {
-  namespace: "igniter.jobs",
-  events: {
-    // Job lifecycle events
-    job: {
-      enqueued: {},
-      started: {},
-      completed: {},
-      failed: {},
-      progress: {},
-      retrying: {},
-      scheduled: {}
-    },
-    // Worker lifecycle events
-    worker: {
-      started: {},
-      stopped: {},
-      idle: {},
-      paused: {},
-      resumed: {}
-    },
-    // Queue management events
-    queue: {
-      paused: {},
-      resumed: {},
-      drained: {},
-      cleaned: {},
-      obliterated: {}
-    }
+  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);
   }
 };
 
-export { IGNITER_JOBS_ERROR_CODES, IgniterJobs, IgniterJobsBuilder, IgniterJobsBullMQAdapter, IgniterJobsError, IgniterJobsMemoryAdapter, IgniterJobsTelemetryEvents, IgniterQueue, IgniterQueueBuilder, IgniterWorkerBuilder };
+export { IGNITER_JOBS_ERROR_CODES, IgniterJobs, IgniterJobsBuilder, IgniterJobsBullMQAdapter, IgniterJobsError, IgniterJobsManager, IgniterJobsMemoryAdapter, IgniterJobsSQLiteAdapter, IgniterQueue, IgniterQueueBuilder, IgniterWorkerBuilder };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map