@igniter-js/jobs 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -1,1000 +1,1065 @@
 import { IgniterError } from '@igniter-js/core';
+import { createBullMQAdapter } from '@igniter-js/adapter-bullmq';
 
 // src/errors/igniter-jobs.error.ts
 var IGNITER_JOBS_ERROR_CODES = {
-  // Configuration errors
   JOBS_ADAPTER_REQUIRED: "JOBS_ADAPTER_REQUIRED",
+  JOBS_SERVICE_REQUIRED: "JOBS_SERVICE_REQUIRED",
   JOBS_CONTEXT_REQUIRED: "JOBS_CONTEXT_REQUIRED",
-  JOBS_QUEUE_REQUIRED: "JOBS_QUEUE_REQUIRED",
   JOBS_CONFIGURATION_INVALID: "JOBS_CONFIGURATION_INVALID",
-  // Queue errors
   JOBS_QUEUE_NOT_FOUND: "JOBS_QUEUE_NOT_FOUND",
-  JOBS_QUEUE_ALREADY_EXISTS: "JOBS_QUEUE_ALREADY_EXISTS",
-  JOBS_QUEUE_NAME_INVALID: "JOBS_QUEUE_NAME_INVALID",
-  JOBS_QUEUE_PAUSE_FAILED: "JOBS_QUEUE_PAUSE_FAILED",
-  JOBS_QUEUE_RESUME_FAILED: "JOBS_QUEUE_RESUME_FAILED",
-  JOBS_QUEUE_DRAIN_FAILED: "JOBS_QUEUE_DRAIN_FAILED",
-  JOBS_QUEUE_CLEAN_FAILED: "JOBS_QUEUE_CLEAN_FAILED",
-  JOBS_QUEUE_OBLITERATE_FAILED: "JOBS_QUEUE_OBLITERATE_FAILED",
-  // Job definition errors
-  JOBS_JOB_NOT_FOUND: "JOBS_JOB_NOT_FOUND",
-  JOBS_JOB_ALREADY_EXISTS: "JOBS_JOB_ALREADY_EXISTS",
-  JOBS_JOB_NAME_INVALID: "JOBS_JOB_NAME_INVALID",
-  JOBS_JOB_HANDLER_REQUIRED: "JOBS_JOB_HANDLER_REQUIRED",
-  // Cron errors
-  JOBS_CRON_NOT_FOUND: "JOBS_CRON_NOT_FOUND",
-  JOBS_CRON_ALREADY_EXISTS: "JOBS_CRON_ALREADY_EXISTS",
-  JOBS_CRON_EXPRESSION_INVALID: "JOBS_CRON_EXPRESSION_INVALID",
-  JOBS_CRON_HANDLER_REQUIRED: "JOBS_CRON_HANDLER_REQUIRED",
-  // Dispatch errors
-  JOBS_DISPATCH_FAILED: "JOBS_DISPATCH_FAILED",
-  JOBS_SCHEDULE_FAILED: "JOBS_SCHEDULE_FAILED",
-  JOBS_INPUT_REQUIRED: "JOBS_INPUT_REQUIRED",
-  JOBS_INPUT_VALIDATION_FAILED: "JOBS_INPUT_VALIDATION_FAILED",
-  // Scope errors
-  JOBS_SCOPE_REQUIRED: "JOBS_SCOPE_REQUIRED",
+  JOBS_QUEUE_DUPLICATE: "JOBS_QUEUE_DUPLICATE",
+  JOBS_QUEUE_OPERATION_FAILED: "JOBS_QUEUE_OPERATION_FAILED",
+  JOBS_INVALID_DEFINITION: "JOBS_INVALID_DEFINITION",
+  JOBS_HANDLER_REQUIRED: "JOBS_HANDLER_REQUIRED",
+  JOBS_DUPLICATE_JOB: "JOBS_DUPLICATE_JOB",
+  JOBS_NOT_FOUND: "JOBS_NOT_FOUND",
+  JOBS_NOT_REGISTERED: "JOBS_NOT_REGISTERED",
+  JOBS_EXECUTION_FAILED: "JOBS_EXECUTION_FAILED",
+  JOBS_TIMEOUT: "JOBS_TIMEOUT",
+  JOBS_CONTEXT_FACTORY_FAILED: "JOBS_CONTEXT_FACTORY_FAILED",
+  JOBS_VALIDATION_FAILED: "JOBS_VALIDATION_FAILED",
+  JOBS_INVALID_INPUT: "JOBS_INVALID_INPUT",
+  JOBS_INVALID_CRON: "JOBS_INVALID_CRON",
+  JOBS_INVALID_SCHEDULE: "JOBS_INVALID_SCHEDULE",
   JOBS_SCOPE_ALREADY_DEFINED: "JOBS_SCOPE_ALREADY_DEFINED",
-  JOBS_SCOPE_INVALID: "JOBS_SCOPE_INVALID",
-  // Actor errors
-  JOBS_ACTOR_ALREADY_DEFINED: "JOBS_ACTOR_ALREADY_DEFINED",
-  JOBS_ACTOR_INVALID: "JOBS_ACTOR_INVALID",
-  // Job management errors
-  JOBS_GET_FAILED: "JOBS_GET_FAILED",
-  JOBS_RETRY_FAILED: "JOBS_RETRY_FAILED",
-  JOBS_REMOVE_FAILED: "JOBS_REMOVE_FAILED",
-  JOBS_PROMOTE_FAILED: "JOBS_PROMOTE_FAILED",
-  JOBS_MOVE_FAILED: "JOBS_MOVE_FAILED",
-  JOBS_STATE_FAILED: "JOBS_STATE_FAILED",
-  JOBS_PROGRESS_FAILED: "JOBS_PROGRESS_FAILED",
-  JOBS_LOGS_FAILED: "JOBS_LOGS_FAILED",
-  // Worker errors
-  JOBS_WORKER_CREATE_FAILED: "JOBS_WORKER_CREATE_FAILED",
-  JOBS_WORKER_START_FAILED: "JOBS_WORKER_START_FAILED",
-  JOBS_WORKER_STOP_FAILED: "JOBS_WORKER_STOP_FAILED",
-  JOBS_WORKER_NOT_FOUND: "JOBS_WORKER_NOT_FOUND",
-  JOBS_WORKER_ALREADY_RUNNING: "JOBS_WORKER_ALREADY_RUNNING",
-  // Event/Subscribe errors
-  JOBS_SUBSCRIBE_FAILED: "JOBS_SUBSCRIBE_FAILED",
-  JOBS_UNSUBSCRIBE_FAILED: "JOBS_UNSUBSCRIBE_FAILED",
-  JOBS_EVENT_EMIT_FAILED: "JOBS_EVENT_EMIT_FAILED",
-  // Search errors
-  JOBS_SEARCH_FAILED: "JOBS_SEARCH_FAILED",
-  JOBS_SEARCH_INVALID_TARGET: "JOBS_SEARCH_INVALID_TARGET",
-  // Shutdown errors
-  JOBS_SHUTDOWN_FAILED: "JOBS_SHUTDOWN_FAILED",
-  // Handler errors
-  JOBS_HANDLER_FAILED: "JOBS_HANDLER_FAILED",
-  JOBS_HANDLER_TIMEOUT: "JOBS_HANDLER_TIMEOUT"
+  JOBS_WORKER_FAILED: "JOBS_WORKER_FAILED",
+  JOBS_ADAPTER_ERROR: "JOBS_ADAPTER_ERROR",
+  JOBS_ADAPTER_CONNECTION_FAILED: "JOBS_ADAPTER_CONNECTION_FAILED",
+  JOBS_SUBSCRIBE_FAILED: "JOBS_SUBSCRIBE_FAILED"
 };
-var IgniterJobsError = class _IgniterJobsError extends IgniterError {
+var IgniterJobsError = class extends IgniterError {
   constructor(options) {
-    super({
-      code: options.code,
-      message: options.message,
-      statusCode: options.statusCode ?? 500,
-      causer: "@igniter-js/jobs",
-      cause: options.cause,
-      details: options.details,
-      logger: options.logger
-    });
-    this.code = options.code;
-    this.details = options.details;
-    this.name = "IgniterJobsError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _IgniterJobsError);
-    }
-  }
-  /**
-   * Convert error to a plain object for serialization.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      statusCode: this.statusCode,
-      details: this.details,
-      stack: this.stack
-    };
+    super(options);
   }
 };
 
 // src/builders/igniter-worker.builder.ts
-var IgniterWorkerBuilder = class {
-  constructor(adapter, jobHandler, availableQueues) {
-    this.adapter = adapter;
-    this.jobHandler = jobHandler;
-    this.availableQueues = availableQueues;
+var IgniterWorkerBuilder = class _IgniterWorkerBuilder {
+  constructor(params) {
+    this.adapter = params.adapter;
+    this.allowedQueues = params.allowedQueues;
     this.state = {
-      queues: [],
-      concurrency: 1
+      queues: params.state?.queues ?? [],
+      concurrency: params.state?.concurrency,
+      limiter: params.state?.limiter,
+      handlers: params.state?.handlers ?? {}
     };
   }
+  clone(patch) {
+    return new _IgniterWorkerBuilder({
+      adapter: this.adapter,
+      allowedQueues: this.allowedQueues,
+      state: { ...this.state, ...patch }
+    });
+  }
   /**
-   * Specify which queues this worker should process.
-   * If not called, worker processes all queues.
-   *
-   * @param queues - Queue names to process
-   * @returns The builder for chaining
+   * Adds a queue to the worker.
    *
-   * @example
-   * ```typescript
-   * .forQueues('email', 'payment')
-   * ```
+   * @param queue - Queue name registered on the jobs instance.
    */
-  forQueues(...queues) {
-    for (const queue of queues) {
-      if (!this.availableQueues.includes(queue)) {
-        throw new IgniterJobsError({
-          code: "JOBS_QUEUE_NOT_FOUND",
-          message: `Queue "${queue}" is not registered. Available queues: ${this.availableQueues.join(", ")}`,
-          statusCode: 400,
-          details: { queue, availableQueues: this.availableQueues }
-        });
-      }
+  addQueue(queue) {
+    if (!this.allowedQueues.includes(queue)) {
+      throw new IgniterJobsError({
+        code: "JOBS_QUEUE_NOT_FOUND",
+        message: `Queue "${queue}" is not registered on this jobs instance.`
+      });
     }
-    this.state.queues = queues;
-    return this;
+    if (this.state.queues.includes(queue)) return this;
+    return this.clone({ queues: [...this.state.queues, queue] });
   }
   /**
-   * Set the concurrency level (jobs processed in parallel per queue).
-   *
-   * @param concurrency - Number of parallel jobs
-   * @returns The builder for chaining
-   *
-   * @example
-   * ```typescript
-   * .withConcurrency(10)
-   * ```
+   * Sets the worker concurrency.
    */
   withConcurrency(concurrency) {
-    if (concurrency < 1) {
+    if (!Number.isFinite(concurrency) || concurrency <= 0) {
       throw new IgniterJobsError({
         code: "JOBS_CONFIGURATION_INVALID",
-        message: "Concurrency must be at least 1",
-        statusCode: 400,
-        details: { concurrency }
+        message: "Worker concurrency must be a positive number."
       });
     }
-    this.state.concurrency = concurrency;
-    return this;
+    return this.clone({ concurrency });
   }
   /**
-   * Set the lock duration in milliseconds.
-   * Jobs are locked for this duration while being processed.
-   *
-   * @param duration - Lock duration in milliseconds
-   * @returns The builder for chaining
-   *
-   * @example
-   * ```typescript
-   * .withLockDuration(30000) // 30 seconds
-   * ```
+   * Sets a worker-level rate limiter.
    */
-  withLockDuration(duration) {
-    if (duration < 1e3) {
+  withLimiter(limiter) {
+    if (!limiter || !Number.isFinite(limiter.max) || !Number.isFinite(limiter.duration) || limiter.max <= 0 || limiter.duration <= 0) {
       throw new IgniterJobsError({
         code: "JOBS_CONFIGURATION_INVALID",
-        message: "Lock duration must be at least 1000ms",
-        statusCode: 400,
-        details: { duration }
+        message: "Limiter must include positive max and duration."
       });
     }
-    this.state.lockDuration = duration;
-    return this;
+    return this.clone({ limiter });
+  }
+  onActive(handler) {
+    return this.clone({ handlers: { ...this.state.handlers, onActive: handler } });
+  }
+  onSuccess(handler) {
+    return this.clone({ handlers: { ...this.state.handlers, onSuccess: handler } });
+  }
+  onFailure(handler) {
+    return this.clone({ handlers: { ...this.state.handlers, onFailure: handler } });
+  }
+  onIdle(handler) {
+    return this.clone({ handlers: { ...this.state.handlers, onIdle: handler } });
   }
   /**
-   * Configure rate limiting for the worker.
+   * Builds and starts the worker.
    *
-   * @param config - Rate limiter configuration
-   * @returns The builder for chaining
-   *
-   * @example
-   * ```typescript
-   * .withLimiter({ max: 100, duration: 60000 }) // 100 jobs per minute
-   * ```
+   * If no queues are added explicitly, the adapter should interpret it as "all queues".
    */
-  withLimiter(config) {
-    if (config.max < 1) {
-      throw new IgniterJobsError({
-        code: "JOBS_CONFIGURATION_INVALID",
-        message: "Limiter max must be at least 1",
-        statusCode: 400,
-        details: { max: config.max }
-      });
-    }
-    if (config.duration < 1) {
-      throw new IgniterJobsError({
-        code: "JOBS_CONFIGURATION_INVALID",
-        message: "Limiter duration must be at least 1ms",
-        statusCode: 400,
-        details: { duration: config.duration }
-      });
-    }
-    this.state.limiter = config;
-    return this;
+  async start() {
+    const concurrency = this.state.concurrency ?? 1;
+    return this.adapter.createWorker({
+      queues: this.state.queues,
+      concurrency,
+      limiter: this.state.limiter,
+      handlers: this.state.handlers
+    });
   }
+};
+
+// src/utils/prefix.ts
+var _IgniterJobsPrefix = class _IgniterJobsPrefix {
   /**
-   * Set a callback to be called when the worker becomes idle.
-   *
-   * @param callback - Idle callback
-   * @returns The builder for chaining
+   * Builds a normalized queue name using the global prefix and queue id.
    *
    * @example
    * ```typescript
-   * .onIdle(() => console.log('Worker is idle'))
+   * const name = IgniterJobsPrefix.buildQueueName('email')
+   * // -> igniter:jobs:email
    * ```
    */
-  onIdle(callback) {
-    this.state.onIdle = callback;
-    return this;
+  static buildQueueName(queue) {
+    return `${_IgniterJobsPrefix.BASE_PREFIX}:${queue}`;
   }
   /**
-   * Start the worker.
-   *
-   * @returns Worker handle for management
+   * Builds the event channel used for pub/sub.
    *
-   * @example
-   * ```typescript
-   * const worker = await jobs.worker
-   *   .create()
-   *   .forQueues('email')
-   *   .start()
-   *
-   * // Later
-   * await worker.pause()
-   * await worker.close()
-   * ```
+   * Unscoped events are published to a global channel per service/environment.
+   * Scoped events are also published to an additional channel for that scope.
    */
-  async start() {
-    const queuesToProcess = this.state.queues.length > 0 ? this.state.queues : this.availableQueues;
-    try {
-      const handle = await this.adapter.createWorker(
-        {
-          queues: queuesToProcess,
-          concurrency: this.state.concurrency,
-          lockDuration: this.state.lockDuration,
-          limiter: this.state.limiter,
-          onIdle: this.state.onIdle
-        },
-        this.jobHandler
-      );
-      return {
-        id: handle.id,
-        pause: () => handle.pause(),
-        resume: () => handle.resume(),
-        close: () => handle.close(),
-        isRunning: () => handle.isRunning(),
-        isPaused: () => handle.isPaused(),
-        getMetrics: () => handle.getMetrics()
-      };
-    } catch (error) {
-      throw new IgniterJobsError({
-        code: "JOBS_WORKER_START_FAILED",
-        message: "Failed to start worker",
-        statusCode: 500,
-        cause: error instanceof Error ? error : void 0,
-        details: { queues: queuesToProcess }
-      });
-    }
+  static buildEventsChannel(params) {
+    const base = `${_IgniterJobsPrefix.BASE_PREFIX}:events:${params.environment}:${params.service}`;
+    if (!params.scope) return base;
+    return `${base}:scope:${params.scope.type}:${params.scope.id}`;
   }
 };
+_IgniterJobsPrefix.BASE_PREFIX = "igniter:jobs";
+var IgniterJobsPrefix = _IgniterJobsPrefix;
 
-// src/core/igniter-jobs.ts
-var IGNITER_JOBS_PREFIX = "igniter:jobs";
-function getFullQueueName(queueName) {
-  return `${IGNITER_JOBS_PREFIX}:${queueName}`;
-}
-var IgniterJobsRuntime = class {
-  constructor(config) {
-    this.config = config;
-    this.queueNames = Object.keys(config.queues);
-    return this.createProxy();
-  }
+// src/utils/events.utils.ts
+var IgniterJobsEventsUtils = class {
   /**
-   * Create the main proxy that provides queue access and global methods.
+   * Constructs a standardized job event type string.
+   *
+   * @param queue - The queue name.
+   * @param jobName - The job name.
+   * @param event - The specific event name (e.g., 'started', 'completed').
+   * @returns A string in the format `queue:jobName:event`.
    */
-  createProxy() {
-    const self = this;
-    return new Proxy({}, {
-      get(_, prop) {
-        if (prop === "subscribe") {
-          return self.createGlobalSubscribe();
-        }
-        if (prop === "search") {
-          return self.createSearch();
-        }
-        if (prop === "worker") {
-          return self.createWorkerBuilder();
-        }
-        if (prop === "shutdown") {
-          return () => self.shutdown();
-        }
-        if (self.queueNames.includes(prop)) {
-          return self.createQueueProxy(prop);
-        }
-        return void 0;
-      },
-      has(_, prop) {
-        return ["subscribe", "search", "worker", "shutdown", ...self.queueNames].includes(prop);
-      },
-      ownKeys() {
-        return ["subscribe", "search", "worker", "shutdown", ...self.queueNames];
-      },
-      getOwnPropertyDescriptor(_, prop) {
-        if (["subscribe", "search", "worker", "shutdown", ...self.queueNames].includes(prop)) {
-          return { configurable: true, enumerable: true };
-        }
-        return void 0;
-      }
-    });
+  static buildJobEventType(queue, jobName, event) {
+    return `${queue}:${jobName}:${event}`;
   }
   /**
-   * Create a proxy for a specific queue.
+   * Publishes a job event to the configured adapter.
+   * Handles publishing to both the base channel and the scope-specific channel if a scope is provided.
+   *
+   * @param params - Configuration parameters for publishing the event.
    */
-  createQueueProxy(queueName) {
-    const self = this;
-    const queueConfig = this.config.queues[queueName];
-    const jobNames = Object.keys(queueConfig.jobs);
-    return new Proxy({}, {
-      get(_, prop) {
-        if (prop === "subscribe") {
-          return self.createQueueSubscribe(queueName);
-        }
-        if (prop === "list") {
-          return (options) => self.listQueueJobs(queueName, options);
-        }
-        if (prop === "get") {
-          return () => self.createQueueManagement(queueName);
-        }
-        if (jobNames.includes(prop)) {
-          return self.createJobProxy(queueName, prop);
-        }
-        return void 0;
-      }
+  static async publishJobsEvent(params) {
+    const baseChannel = IgniterJobsPrefix.buildEventsChannel({
+      service: params.service,
+      environment: params.environment
     });
-  }
-  /**
-   * Create a proxy for a specific job.
-   */
-  createJobProxy(queueName, jobName) {
-    const self = this;
-    return {
-      dispatch: (input, options) => self.dispatchJob(queueName, jobName, input, options),
-      schedule: (params) => self.scheduleJob(queueName, jobName, params),
-      get: (jobId) => self.createJobManagement(queueName, jobId),
-      many: (jobIds) => self.createJobBatchManagement(queueName, jobIds),
-      pause: () => self.pauseJobType(queueName, jobName),
-      resume: () => self.resumeJobType(queueName, jobName),
-      subscribe: (handler) => self.subscribeToJob(queueName, jobName, handler)
-    };
-  }
-  /**
-   * Dispatch a job.
-   */
-  async dispatchJob(queueName, jobName, input, options) {
-    const queueConfig = this.config.queues[queueName];
-    const jobDef = queueConfig.jobs[jobName];
-    if (jobDef.input) {
-      try {
-        const result = await jobDef.input["~standard"].validate(input);
-        if (result.issues) {
-          throw new IgniterJobsError({
-            code: "JOBS_INPUT_VALIDATION_FAILED",
-            message: `Input validation failed for job "${jobName}"`,
-            statusCode: 400,
-            details: { issues: result.issues }
-          });
-        }
-        input = result.value;
-      } catch (error) {
-        if (error instanceof IgniterJobsError) throw error;
-        if (typeof jobDef.input.parse === "function") {
-          input = jobDef.input.parse(input);
-        }
-      }
-    }
-    if (this.config.scope?.options?.required && !options?.scope) {
-      throw new IgniterJobsError({
-        code: "JOBS_SCOPE_REQUIRED",
-        message: `Scope "${this.config.scope.key}" is required for job dispatch`,
-        statusCode: 400,
-        details: { queue: queueName, job: jobName }
-      });
-    }
-    const params = {
-      queue: getFullQueueName(queueName),
-      name: jobName,
-      data: input,
-      jobId: options?.jobId,
-      delay: options?.delay,
-      priority: options?.priority ?? jobDef.priority,
-      attempts: jobDef.retry?.attempts ?? this.config.defaults?.retry?.attempts ?? 3,
-      backoff: jobDef.retry?.backoff ?? this.config.defaults?.retry?.backoff,
-      removeOnComplete: jobDef.removeOnComplete ?? this.config.defaults?.removeOnComplete,
-      removeOnFail: jobDef.removeOnFail ?? this.config.defaults?.removeOnFail,
-      scope: options?.scope,
-      actor: options?.actor
-    };
-    try {
-      const jobId = await this.config.adapter.dispatch(params);
-      if (this.config.telemetry) {
-      }
-      return jobId;
-    } catch (error) {
-      throw new IgniterJobsError({
-        code: "JOBS_DISPATCH_FAILED",
-        message: `Failed to dispatch job "${jobName}" to queue "${queueName}"`,
-        statusCode: 500,
-        cause: error instanceof Error ? error : void 0,
-        details: { queue: queueName, job: jobName }
-      });
-    }
-  }
-  /**
-   * Schedule a job for future execution.
-   */
-  async scheduleJob(queueName, jobName, params) {
-    const queueConfig = this.config.queues[queueName];
-    const jobDef = queueConfig.jobs[jobName];
-    let validatedInput = params.input;
-    if (jobDef.input) {
-      try {
-        const result = await jobDef.input["~standard"].validate(params.input);
-        if (result.issues) {
-          throw new IgniterJobsError({
-            code: "JOBS_INPUT_VALIDATION_FAILED",
-            message: `Input validation failed for job "${jobName}"`,
-            statusCode: 400,
-            details: { issues: result.issues }
-          });
-        }
-        validatedInput = result.value;
-      } catch (error) {
-        if (error instanceof IgniterJobsError) throw error;
-        if (typeof jobDef.input.parse === "function") {
-          validatedInput = jobDef.input.parse(params.input);
-        }
-      }
-    }
-    const scheduleParams = {
-      queue: getFullQueueName(queueName),
-      name: jobName,
-      data: validatedInput,
-      jobId: params.jobId,
-      at: params.at,
-      cron: params.cron,
-      every: params.every,
-      timezone: params.timezone,
-      attempts: jobDef.retry?.attempts ?? this.config.defaults?.retry?.attempts ?? 3,
-      backoff: jobDef.retry?.backoff ?? this.config.defaults?.retry?.backoff,
-      removeOnComplete: jobDef.removeOnComplete ?? this.config.defaults?.removeOnComplete,
-      removeOnFail: jobDef.removeOnFail ?? this.config.defaults?.removeOnFail,
-      scope: params.scope,
-      actor: params.actor
-    };
-    try {
-      return await this.config.adapter.schedule(scheduleParams);
-    } catch (error) {
-      throw new IgniterJobsError({
-        code: "JOBS_SCHEDULE_FAILED",
-        message: `Failed to schedule job "${jobName}" in queue "${queueName}"`,
-        statusCode: 500,
-        cause: error instanceof Error ? error : void 0,
-        details: { queue: queueName, job: jobName }
+    await params.adapter.publishEvent(baseChannel, params.event);
+    if (params.scope) {
+      const scopeChannel = IgniterJobsPrefix.buildEventsChannel({
+        service: params.service,
+        environment: params.environment,
+        scope: { type: params.scope.type, id: params.scope.id }
       });
+      await params.adapter.publishEvent(scopeChannel, params.event);
     }
   }
+};
+
+// src/utils/scope.ts
+var IgniterJobsScopeUtils = class {
   /**
-   * Create job management methods.
-   */
-  createJobManagement(queueName, jobId) {
-    const adapter = this.config.adapter;
-    const fullQueueName = getFullQueueName(queueName);
-    return {
-      retrieve: () => adapter.getJob(fullQueueName, jobId),
-      retry: () => adapter.retryJob(fullQueueName, jobId),
-      remove: () => adapter.removeJob(fullQueueName, jobId),
-      state: () => adapter.getJobState(fullQueueName, jobId),
-      progress: () => adapter.getJobProgress(fullQueueName, jobId),
-      logs: () => adapter.getJobLogs(fullQueueName, jobId),
-      promote: () => adapter.promoteJob(fullQueueName, jobId),
-      move: (state, reason) => adapter.moveJob(fullQueueName, jobId, state, reason)
-    };
-  }
-  /**
-   * Create batch job management methods.
-   */
-  createJobBatchManagement(queueName, jobIds) {
-    const adapter = this.config.adapter;
-    const fullQueueName = getFullQueueName(queueName);
-    return {
-      retry: () => adapter.retryJobs(fullQueueName, jobIds),
-      remove: () => adapter.removeJobs(fullQueueName, jobIds)
-    };
-  }
-  /**
-   * Create queue management methods.
+   * Merges a scope entry into a metadata object.
+   *
+   * @param metadata - Existing metadata object.
+   * @param scope - The scope entry to merge.
+   * @returns A new metadata object containing the scope information, or the original metadata if no scope is provided.
    */
-  createQueueManagement(queueName) {
-    const adapter = this.config.adapter;
-    const fullQueueName = getFullQueueName(queueName);
+  static mergeMetadataWithScope(metadata, scope) {
+    if (!scope) return metadata;
     return {
-      retrieve: () => adapter.getQueue(fullQueueName),
-      pause: () => adapter.pauseQueue(fullQueueName),
-      resume: () => adapter.resumeQueue(fullQueueName),
-      drain: () => adapter.drainQueue(fullQueueName),
-      clean: (options) => adapter.cleanQueue(fullQueueName, {
-        status: options.status,
-        olderThan: options.olderThan,
-        limit: options.limit
-      }),
-      obliterate: (options) => adapter.obliterateQueue(fullQueueName, options),
-      retryAll: () => adapter.retryAllFailed(fullQueueName)
-    };
-  }
-  /**
-   * Pause a specific job type.
-   */
-  async pauseJobType(queueName, jobName) {
-    const fullQueueName = getFullQueueName(queueName);
-    await this.config.adapter.pauseJobType(fullQueueName, jobName);
-  }
-  /**
-   * Resume a specific job type.
-   */
-  async resumeJobType(queueName, jobName) {
-    const fullQueueName = getFullQueueName(queueName);
-    await this.config.adapter.resumeJobType(fullQueueName, jobName);
-  }
-  /**
-   * Subscribe to events for a specific job.
-   */
-  async subscribeToJob(queueName, jobName, handler) {
-    const pattern = `${queueName}:${jobName}:*`;
-    return this.config.adapter.subscribe(pattern, handler);
-  }
-  /**
-   * Create queue-level subscribe.
-   */
-  createQueueSubscribe(queueName) {
-    return async (handler) => {
-      const pattern = `${queueName}:*`;
-      return this.config.adapter.subscribe(pattern, handler);
+      ...metadata ?? {},
+      [this.SCOPE_METADATA_KEY]: scope
     };
   }
   /**
-   * List jobs in a queue.
+   * Extracts a scope entry from a metadata object.
+   *
+   * @param metadata - The metadata object to inspect.
+   * @returns The extracted scope entry, or undefined if not found.
    */
-  async listQueueJobs(queueName, options) {
-    const fullQueueName = getFullQueueName(queueName);
-    return this.config.adapter.listJobs(fullQueueName, {
-      status: options?.status,
-      end: options?.limit
-    });
+  static extractScopeFromMetadata(metadata) {
+    if (!metadata) return void 0;
+    const value = metadata[this.SCOPE_METADATA_KEY];
+    if (!value || typeof value !== "object") return void 0;
+    if (!("type" in value) || !("id" in value)) return void 0;
+    return value;
   }
+};
+/**
+ * The key used to store scope information in job metadata.
+ */
+IgniterJobsScopeUtils.SCOPE_METADATA_KEY = "__igniter_jobs_scope";
+
+// src/utils/telemetry.ts
+var IgniterJobsTelemetryUtils = class {
   /**
-   * Create global subscribe.
+   * 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').
    */
-  createGlobalSubscribe() {
-    return async (handler) => {
-      return this.config.adapter.subscribe("*", handler);
-    };
+  static emitTelemetry(telemetry, eventName, attributes, level = "info") {
+    if (!telemetry) return;
+    try {
+      telemetry.emit(eventName, { attributes, level });
+    } catch {
+    }
   }
+};
+
+// src/utils/validation.ts
+var IgniterJobsValidationUtils = class {
   /**
-   * Create search function.
+   * Checks if a value conforms to the Standard Schema V1 interface.
+   *
+   * @param value - The value to check.
+   * @returns True if the value is a Standard Schema.
    */
-  createSearch() {
-    const adapter = this.config.adapter;
-    return async (target, filter) => {
-      switch (target) {
-        case "queues":
-          return adapter.searchQueues(filter || {});
-        case "jobs":
-          return adapter.searchJobs(filter || {});
-        case "workers":
-          return [];
-        default:
-          throw new IgniterJobsError({
-            code: "JOBS_SEARCH_INVALID_TARGET",
-            message: `Invalid search target "${target}". Use "queues", "jobs", or "workers".`,
-            statusCode: 400
-          });
-      }
-    };
+  static isStandardSchema(value) {
+    return Boolean(
+      value && typeof value === "object" && "~standard" in value
+    );
   }
   /**
-   * Create worker builder.
+   * Checks if a value conforms to a Zod-like schema interface.
+   *
+   * @param value - The value to check.
+   * @returns True if the value is a Zod-like schema.
    */
-  createWorkerBuilder() {
-    return {
-      create: () => new IgniterWorkerBuilder(
-        this.config.adapter,
-        this.createJobHandler(),
-        this.queueNames.map((q) => getFullQueueName(q))
-      )
-    };
+  static isZodLikeSchema(value) {
+    return Boolean(
+      value && typeof value === "object" && "parse" in value
+    );
   }
   /**
-   * Create the job handler function for workers.
+   * Validates input against a provided schema (Standard Schema or Zod-like).
+   *
+   * @param schema - The schema definition.
+   * @param input - The input data to validate.
+   * @returns The validated (and possibly transformed) data.
+   * @throws {IgniterJobsError} If validation fails.
    */
-  createJobHandler() {
-    const self = this;
-    return async (job) => {
-      const queueName = job.queue.replace(`${IGNITER_JOBS_PREFIX}:`, "");
-      const queueConfig = self.config.queues[queueName];
-      if (!queueConfig) {
+  static async validateInput(schema, input) {
+    if (this.isStandardSchema(schema)) {
+      const result = await schema["~standard"].validate(input);
+      if ("issues" in result && result.issues) {
+        const message = result.issues.map((i) => i.message).join("; ");
         throw new IgniterJobsError({
-          code: "JOBS_QUEUE_NOT_FOUND",
-          message: `Queue "${queueName}" not found`,
-          statusCode: 404
+          code: "JOBS_VALIDATION_FAILED",
+          message: `Input validation failed: ${message}`,
+          details: { issues: result.issues },
+          statusCode: 400
         });
       }
-      const jobDef = queueConfig.jobs[job.name];
-      if (!jobDef) {
-        throw new IgniterJobsError({
-          code: "JOBS_JOB_NOT_FOUND",
-          message: `Job "${job.name}" not found in queue "${queueName}"`,
-          statusCode: 404
-        });
+      return result.value;
+    }
+    if (this.isZodLikeSchema(schema)) {
+      if (typeof schema.safeParse === "function") {
+        const result = schema.safeParse(input);
+        if (!result.success) {
+          throw new IgniterJobsError({
+            code: "JOBS_VALIDATION_FAILED",
+            message: "Input validation failed.",
+            details: { error: result.error },
+            statusCode: 400
+          });
+        }
+        return result.data;
       }
-      const context = await self.config.context();
-      const ctx = {
-        input: job.data,
-        context,
-        job: {
-          id: job.id,
-          name: job.name,
-          queue: queueName,
-          timestamp: job.timestamp
-        },
-        attempt: job.attempt,
-        scope: job.scope,
-        actor: job.actor,
-        log: job.log,
-        updateProgress: job.updateProgress
-      };
       try {
-        const result = await jobDef.handler(ctx);
-        if (jobDef.onComplete) {
-          await jobDef.onComplete(ctx, result);
-        }
-        return result;
+        return schema.parse(input);
       } catch (error) {
-        if (jobDef.onFailure) {
-          await jobDef.onFailure(ctx, error instanceof Error ? error : new Error(String(error)));
-        }
-        throw error;
+        throw new IgniterJobsError({
+          code: "JOBS_VALIDATION_FAILED",
+          message: "Input validation failed.",
+          details: { error },
+          statusCode: 400
+        });
       }
-    };
-  }
-  /**
-   * Shutdown the jobs instance.
-   */
-  async shutdown() {
-    try {
-      await this.config.adapter.shutdown();
-    } catch (error) {
-      throw new IgniterJobsError({
-        code: "JOBS_SHUTDOWN_FAILED",
-        message: "Failed to shutdown jobs instance",
-        statusCode: 500,
-        cause: error instanceof Error ? error : void 0
-      });
     }
+    return input;
   }
 };
 
-// src/builders/igniter-jobs.builder.ts
-var IgniterJobsBuilder = class _IgniterJobsBuilder {
-  constructor(state) {
-    this.state = state;
-  }
+// src/core/igniter-jobs.ts
+var IgniterJobs = class {
   /**
-   * Create a new IgniterJobs builder.
-   *
-   * @returns A new IgniterJobsBuilder instance
+   * Starts the fluent builder API for jobs.
    *
    * @example
    * ```typescript
    * const jobs = IgniterJobs.create<AppContext>()
-   *   .withAdapter(...)
+   *   .withAdapter(IgniterJobsMemoryAdapter.create())
+   *   .withService('my-api')
+   *   .withEnvironment('test')
+   *   .withContext(async () => ({ db }))
+   *   .addQueue(emailQueue)
    *   .build()
    * ```
    */
   static create() {
-    return new _IgniterJobsBuilder({
-      queues: {}
-    });
+    return IgniterJobsBuilder.create();
   }
   /**
-   * Configure the queue adapter (required).
-   *
-   * @param adapter - The queue adapter (e.g., BullMQAdapter)
-   * @returns The builder with adapter configured
-   *
-   * @example
-   * ```typescript
-   * .withAdapter(BullMQAdapter.create({ redis }))
-   * ```
+   * Creates a runtime instance from a validated configuration.
    */
-  withAdapter(adapter) {
-    return new _IgniterJobsBuilder({
-      ...this.state,
-      adapter
-    });
+  static fromConfig(config) {
+    const internal = createInternalState(config);
+    return createRuntime(internal, void 0);
   }
-  /**
-   * Configure the application context provider (required).
-   * This function is called for each job to provide the application context.
-   *
-   * @param contextFn - Function that returns the application context
-   * @returns The builder with context configured
-   *
-   * @example
-   * ```typescript
-   * .withContext(() => ({
-   *   db: prisma,
-   *   mailer: mailerService,
-   *   cache: redis,
-   * }))
-   * ```
-   */
-  withContext(contextFn) {
-    return new _IgniterJobsBuilder({
-      ...this.state,
-      context: contextFn
-    });
+};
+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;
   }
-  /**
-   * Add a queue to the jobs instance.
-   *
-   * @param queue - Queue configuration from IgniterQueue.create().build()
-   * @returns The builder with the queue added
-   *
-   * @example
-   * ```typescript
-   * const emailQueue = IgniterQueue.create<AppContext>('email')
-   *   .addJob('sendWelcome', { ... })
-   *   .build()
-   *
-   * const jobs = IgniterJobs.create<AppContext>()
-   *   .addQueue(emailQueue)
-   *   .build()
-   * ```
-   */
-  addQueue(queue) {
-    const queueName = queue.name;
-    if (queueName in this.state.queues) {
+  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: {
+      create: () => new IgniterWorkerBuilder({
+        adapter: internal.adapter,
+        allowedQueues: Object.keys(internal.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
+    });
+  }
+  return runtime;
+}
+function registerAll(config, adapter) {
+  for (const [queueName, queue] of Object.entries(
+    config.queues
+  )) {
+    for (const [jobName, def] of Object.entries(
+      queue.jobs
+    )) {
+      adapter.registerJob(
+        queueName,
+        jobName,
+        wrapJobDefinition({
+          config,
+          adapter,
+          queueName,
+          jobName,
+          definition: def
+        })
+      );
+    }
+    for (const [cronName, cron] of Object.entries(
+      queue.crons
+    )) {
+      adapter.registerCron(
+        queueName,
+        cronName,
+        wrapCronDefinition({
+          config,
+          adapter,
+          queueName,
+          cronName,
+          definition: cron
+        })
+      );
+    }
+  }
+}
+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
+    );
+    return {
+      ...ctx,
+      context: realContext,
+      job: { ...ctx.job, name: cronName, queue: queueName },
+      scope
+    };
+  };
+  const publishLifecycle = async (event, ctx, data) => {
+    const scope = ctx.scope ?? IgniterJobsScopeUtils.extractScopeFromMetadata(
+      ctx.job?.metadata
+    );
+    await IgniterJobsEventsUtils.publishJobsEvent({
+      adapter,
+      service: config.service,
+      environment: config.environment,
+      scope,
+      event: {
+        type: IgniterJobsEventsUtils.buildJobEventType(
+          queueName,
+          cronName,
+          event
+        ),
+        data,
+        timestamp: /* @__PURE__ */ new Date(),
+        scope
+      }
+    });
+  };
+  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;
+      }
+    }
+  };
+}
+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 },
+      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,
+      scope,
+      event: {
+        type: IgniterJobsEventsUtils.buildJobEventType(
+          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
+        );
+        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",
+        {
+          "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,
+          jobName,
+          queue: queueName,
+          result: ctx.result,
+          duration,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      );
+      IgniterJobsTelemetryUtils.emitTelemetry(
+        config.telemetry,
+        "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,
+          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",
+        {
+          "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
+  };
+}
+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;
+    const required = Object.values(
+      internal.config.scopeDefinition
+    )[0]?.required ?? false;
+    const effective = boundScope ?? paramsScope;
+    if (required && !effective) {
       throw new IgniterJobsError({
-        code: "JOBS_QUEUE_ALREADY_EXISTS",
-        message: `Queue "${queueName}" has already been added`,
-        statusCode: 400,
-        details: { queue: queueName }
+        code: "JOBS_CONFIGURATION_INVALID",
+        message: "Scope is required for this jobs instance."
+      });
+    }
+    if (boundScope && paramsScope) {
+      if (boundScope.type !== paramsScope.type || boundScope.id !== paramsScope.id) {
+        throw new IgniterJobsError({
+          code: "JOBS_CONFIGURATION_INVALID",
+          message: "Cannot override scope on a scoped jobs instance."
+        });
+      }
+    }
+    return effective;
+  };
+  const publish = async (event) => {
+    await IgniterJobsEventsUtils.publishJobsEvent({
+      adapter: internal.adapter,
+      service: internal.config.service,
+      environment: internal.config.environment,
+      scope: event.scope,
+      event
+    });
+  };
+  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({
+        type: IgniterJobsEventsUtils.buildJobEventType(
+          queueName,
+          jobName,
+          "enqueued"
+        ),
+        data: { jobId, queue: queueName, jobName },
+        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,
-      queues: {
-        ...this.state.queues,
-        [queueName]: queue
-      }
+      ...patch,
+      queues: patch.queues ?? this.state.queues,
+      scope: patch.scope ?? this.state.scope
     });
   }
   /**
-   * Add a scope for multi-tenancy (only one scope allowed).
-   * Scopes are used to isolate jobs by organization, tenant, etc.
+   * Attaches the jobs adapter.
    *
-   * @param key - Scope key (e.g., 'organization', 'tenant')
-   * @param options - Optional scope configuration
-   * @returns The builder with scope configured
+   * @param adapter - Backend adapter implementation (BullMQ, memory, etc.).
+   */
+  withAdapter(adapter) {
+    return this.clone({ adapter });
+  }
+  /**
+   * Sets the service identifier for telemetry and metrics.
    *
-   * @example
-   * ```typescript
-   * .addScope('organization', { required: true })
-   * ```
+   * @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(key, options) {
+  addScope(name, options) {
     if (this.state.scope) {
       throw new IgniterJobsError({
         code: "JOBS_SCOPE_ALREADY_DEFINED",
-        message: `Scope "${this.state.scope.key}" is already defined. Only one scope is allowed.`,
-        statusCode: 400,
-        details: { existingScope: this.state.scope.key, newScope: key }
+        message: "Only one scope can be defined for IgniterJobs."
       });
     }
-    return new _IgniterJobsBuilder({
-      ...this.state,
-      scope: { key, options }
-    });
+    return this.clone({ scope: { name, options } });
   }
   /**
-   * Add an actor for auditing (only one actor type allowed).
-   * Actors are used to track who initiated jobs.
-   *
-   * @param key - Actor key (e.g., 'user', 'system')
-   * @param options - Optional actor configuration
-   * @returns The builder with actor configured
-   *
-   * @example
-   * ```typescript
-   * .addActor('user', { description: 'The user who initiated the job' })
-   * ```
+   * Registers a queue definition on the builder.
    */
-  addActor(key, options) {
-    if (this.state.actor) {
+  addQueue(queue) {
+    if (this.state.queues[queue.name]) {
       throw new IgniterJobsError({
-        code: "JOBS_ACTOR_ALREADY_DEFINED",
-        message: `Actor "${this.state.actor.key}" is already defined. Only one actor is allowed.`,
-        statusCode: 400,
-        details: { existingActor: this.state.actor.key, newActor: key }
+        code: "JOBS_QUEUE_DUPLICATE",
+        message: `Queue "${queue.name}" is already registered.`
       });
     }
-    return new _IgniterJobsBuilder({
-      ...this.state,
-      actor: { key, options }
-    });
+    const nextQueues = {
+      ...this.state.queues,
+      [queue.name]: queue
+    };
+    return this.clone({ queues: nextQueues });
   }
   /**
-   * Configure telemetry for observability (optional).
-   *
-   * @param telemetry - IgniterTelemetry instance
-   * @returns The builder with telemetry configured
-   *
-   * @example
-   * ```typescript
-   * .withTelemetry(telemetry)
-   * ```
+   * Applies default job options to all queues.
    */
-  withTelemetry(telemetry) {
-    return new _IgniterJobsBuilder({
-      ...this.state,
-      telemetry
-    });
+  withQueueDefaults(defaults) {
+    return this.clone({ queueDefaults: defaults });
   }
   /**
-   * Configure a custom logger (optional).
-   *
-   * @param logger - Logger instance
-   * @returns The builder with logger configured
-   *
-   * @example
-   * ```typescript
-   * .withLogger(customLogger)
-   * ```
+   * Applies default worker options.
    */
-  withLogger(logger) {
-    return new _IgniterJobsBuilder({
-      ...this.state,
-      logger
-    });
+  withWorkerDefaults(defaults) {
+    return this.clone({ workerDefaults: defaults });
   }
   /**
-   * Configure default job options applied to all jobs.
-   *
-   * @param defaults - Default job configuration
-   * @returns The builder with defaults configured
-   *
-   * @example
-   * ```typescript
-   * .withDefaults({
-   *   retry: { attempts: 3, backoff: { type: 'exponential', delay: 1000 } },
-   *   timeout: 30000,
-   *   removeOnComplete: { count: 1000 },
-   * })
-   * ```
+   * Configures automatic worker startup.
    */
-  withDefaults(defaults) {
-    return new _IgniterJobsBuilder({
-      ...this.state,
-      defaults
-    });
+  withAutoStartWorker(config) {
+    return this.clone({ autoStartWorker: config });
   }
   /**
-   * Build the IgniterJobs instance.
-   * Validates configuration and returns a fully typed jobs instance.
-   *
-   * @returns The IgniterJobs instance with proxy for typed access
-   *
-   * @throws {IgniterJobsError} If adapter is not configured
-   * @throws {IgniterJobsError} If context is not configured
-   * @throws {IgniterJobsError} If no queues are defined
-   *
-   * @example
-   * ```typescript
-   * const jobs = IgniterJobs.create<AppContext>()
-   *   .withAdapter(adapter)
-   *   .withContext(() => context)
-   *   .addQueue(emailQueue)
-   *   .build()
-   *
-   * // Now use with full type safety
-   * await jobs.email.sendWelcome.dispatch({ userId: '123' })
-   * ```
+   * 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: "Adapter is required. Use .withAdapter() to configure.",
-        statusCode: 400
+        message: "Jobs adapter is required. Call withAdapter() before build()."
       });
     }
-    if (!this.state.context) {
+    if (!this.state.service) {
       throw new IgniterJobsError({
-        code: "JOBS_CONTEXT_REQUIRED",
-        message: "Context provider is required. Use .withContext() to configure.",
-        statusCode: 400
+        code: "JOBS_SERVICE_REQUIRED",
+        message: "Service name is required. Call withService() before build()."
       });
     }
-    if (Object.keys(this.state.queues).length === 0) {
+    if (!this.state.environment) {
       throw new IgniterJobsError({
-        code: "JOBS_QUEUE_REQUIRED",
-        message: "At least one queue is required. Use .addQueue() to add queues.",
-        statusCode: 400
+        code: "JOBS_CONFIGURATION_INVALID",
+        message: "Environment is required. Call withEnvironment() before build()."
       });
     }
-    return new IgniterJobsRuntime(
-      this.state
-    );
+    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);
   }
 };
-var IgniterJobs = {
-  create: IgniterJobsBuilder.create
-};
 
 // src/builders/igniter-queue.builder.ts
-function validateQueueName(name) {
-  if (!name || typeof name !== "string") {
-    throw new IgniterJobsError({
-      code: "JOBS_QUEUE_NAME_INVALID",
-      message: "Queue name must be a non-empty string",
-      statusCode: 400
-    });
-  }
-  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
-    throw new IgniterJobsError({
-      code: "JOBS_QUEUE_NAME_INVALID",
-      message: `Queue name "${name}" must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens`,
-      statusCode: 400,
-      details: { name }
-    });
-  }
-}
-function validateJobName(name) {
-  if (!name || typeof name !== "string") {
-    throw new IgniterJobsError({
-      code: "JOBS_JOB_NAME_INVALID",
-      message: "Job name must be a non-empty string",
-      statusCode: 400
-    });
-  }
-  if (!/^[a-zA-Z][a-zA-Z0-9]*$/.test(name)) {
-    throw new IgniterJobsError({
-      code: "JOBS_JOB_NAME_INVALID",
-      message: `Job name "${name}" must start with a letter and contain only letters and numbers (camelCase recommended)`,
-      statusCode: 400,
-      details: { name }
-    });
-  }
-}
 var IgniterQueueBuilder = class _IgniterQueueBuilder {
   constructor(state) {
     this.state = state;
   }
   /**
-   * Create a new queue builder.
-   *
-   * @param name - Queue name (kebab-case, e.g., 'email', 'payment-processing')
-   * @returns A new IgniterQueueBuilder instance
-   *
-   * @example
-   * ```typescript
-   * const emailQueue = IgniterQueue.create<AppContext>('email')
-   * ```
+   * Creates a new queue builder for the given queue name.
    */
   static create(name) {
-    validateQueueName(name);
+    if (!name || typeof name !== "string") {
+      throw new IgniterJobsError({
+        code: "JOBS_CONFIGURATION_INVALID",
+        message: "Queue name must be a non-empty string."
+      });
+    }
     return new _IgniterQueueBuilder({
       name,
       jobs: {},
@@ -1002,127 +1067,1196 @@ var IgniterQueueBuilder = class _IgniterQueueBuilder {
     });
   }
   /**
-   * Add a job definition to the queue.
+   * Re-types this builder with the application context type.
    *
-   * @param name - Job name (camelCase, e.g., 'sendWelcome', 'processPayment')
-   * @param definition - Job definition with input schema, handler, retry config, etc.
-   * @returns The builder with the new job added
+   * This is a type-level helper; it does not mutate runtime state.
    *
    * @example
    * ```typescript
-   * .addJob('sendWelcome', {
-   *   input: z.object({
-   *     userId: z.string(),
-   *     email: z.string().email(),
-   *   }),
-   *   retry: { attempts: 3, backoff: { type: 'exponential', delay: 1000 } },
-   *   handler: async (ctx) => {
-   *     await ctx.context.mailer.send({
-   *       to: ctx.input.email,
-   *       template: 'welcome',
-   *     })
-   *   },
-   * })
+   * const queue = IgniterQueue.create('email')
+   *   .withContext<AppContext>()
+   *   .addJob('send', { handler: async ({ context }) => context.mailer.send() })
    * ```
    */
-  addJob(name, definition) {
-    validateJobName(name);
-    if (name in this.state.jobs) {
-      throw new IgniterJobsError({
-        code: "JOBS_JOB_ALREADY_EXISTS",
-        message: `Job "${name}" already exists in queue "${this.state.name}"`,
-        statusCode: 400,
-        details: { queue: this.state.name, job: name }
-      });
-    }
-    if (!definition.handler || typeof definition.handler !== "function") {
-      throw new IgniterJobsError({
-        code: "JOBS_JOB_HANDLER_REQUIRED",
-        message: `Job "${name}" must have a handler function`,
-        statusCode: 400,
-        details: { queue: this.state.name, job: name }
-      });
-    }
+  withContext() {
+    return this;
+  }
+  clone(patch) {
     return new _IgniterQueueBuilder({
       ...this.state,
-      jobs: {
-        ...this.state.jobs,
-        [name]: definition
-      }
+      ...patch
     });
   }
   /**
-   * Add a cron job definition to the queue.
-   *
-   * @param name - Cron job name (camelCase)
-   * @param definition - Cron definition with expression, handler, etc.
-   * @returns The builder with the new cron added
+   * Registers a job on the queue.
    *
-   * @example
-   * ```typescript
-   * .addCron('cleanupExpired', {
-   *   expression: '0 0 * * *', // Every day at midnight
-   *   timezone: 'America/New_York',
-   *   handler: async (ctx) => {
-   *     await ctx.context.db.cleanup.expiredSessions()
-   *   },
-   * })
-   * ```
+   * @param jobName - Unique name of the job inside the queue.
+   * @param definition - Job definition (handler, schemas, options, hooks).
    */
-  addCron(name, definition) {
-    validateJobName(name);
-    if (name in this.state.crons) {
+  addJob(jobName, definition) {
+    if (!jobName || typeof jobName !== "string") {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_DEFINITION",
+        message: "Job name must be a non-empty string."
+      });
+    }
+    if (this.state.jobs[jobName]) {
+      throw new IgniterJobsError({
+        code: "JOBS_DUPLICATE_JOB",
+        message: `Job "${jobName}" is already registered in queue "${this.state.name}".`
+      });
+    }
+    if (this.state.crons[jobName]) {
       throw new IgniterJobsError({
-        code: "JOBS_CRON_ALREADY_EXISTS",
-        message: `Cron "${name}" already exists in queue "${this.state.name}"`,
-        statusCode: 400,
-        details: { queue: this.state.name, cron: name }
+        code: "JOBS_DUPLICATE_JOB",
+        message: `Job "${jobName}" conflicts with an existing cron in queue "${this.state.name}".`
       });
     }
-    if (!definition.expression || typeof definition.expression !== "string") {
+    if (!definition || typeof definition !== "object") {
       throw new IgniterJobsError({
-        code: "JOBS_CRON_EXPRESSION_INVALID",
-        message: `Cron "${name}" must have a valid expression`,
-        statusCode: 400,
-        details: { queue: this.state.name, cron: name }
+        code: "JOBS_INVALID_DEFINITION",
+        message: `Job "${jobName}" definition must be an object.`
       });
     }
     if (!definition.handler || typeof definition.handler !== "function") {
       throw new IgniterJobsError({
-        code: "JOBS_CRON_HANDLER_REQUIRED",
-        message: `Cron "${name}" must have a handler function`,
-        statusCode: 400,
-        details: { queue: this.state.name, cron: name }
+        code: "JOBS_HANDLER_REQUIRED",
+        message: `Job "${jobName}" handler is required and must be a function.`
       });
     }
-    return new _IgniterQueueBuilder({
-      ...this.state,
-      crons: {
-        ...this.state.crons,
-        [name]: definition
-      }
+    const nextJobs = {
+      ...this.state.jobs,
+      [jobName]: definition
+    };
+    return this.clone({
+      jobs: nextJobs
     });
   }
   /**
-   * Build the queue configuration.
+   * Registers a cron task on the queue.
    *
-   * @returns The queue configuration ready to be registered with IgniterJobs
+   * @param cronName - Unique name of the cron task inside the queue.
+   * @param definition - Cron definition (cron string, tz, handler, options).
+   */
+  addCron(cronName, definition) {
+    if (!cronName || typeof cronName !== "string") {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: "Cron name must be a non-empty string."
+      });
+    }
+    if (this.state.crons[cronName]) {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" is already registered in queue "${this.state.name}".`
+      });
+    }
+    if (this.state.jobs[cronName]) {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" conflicts with an existing job in queue "${this.state.name}".`
+      });
+    }
+    if (!definition || typeof definition !== "object") {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" definition must be an object.`
+      });
+    }
+    if (!definition.cron || typeof definition.cron !== "string") {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" must include a valid cron expression string.`
+      });
+    }
+    if (!definition.handler || typeof definition.handler !== "function") {
+      throw new IgniterJobsError({
+        code: "JOBS_HANDLER_REQUIRED",
+        message: `Cron "${cronName}" handler is required and must be a function.`
+      });
+    }
+    const nextCrons = {
+      ...this.state.crons,
+      [cronName]: definition
+    };
+    return this.clone({
+      crons: nextCrons
+    });
+  }
+  /**
+   * Finalizes the queue definition.
+   */
+  build() {
+    return {
+      name: this.state.name,
+      jobs: this.state.jobs,
+      crons: this.state.crons
+    };
+  }
+};
+
+// src/core/igniter-queue.ts
+var IgniterQueue = class {
+  /**
+   * Creates a new queue builder for the given name.
    *
    * @example
    * ```typescript
-   * const emailQueue = IgniterQueue.create<AppContext>('email')
-   *   .addJob('sendWelcome', { ... })
+   * const queue = IgniterQueue.create('email')
+   *   .withContext<AppContext>()
+   *   .addJob('sendWelcome', { handler: async () => {} })
    *   .build()
    * ```
    */
-  build() {
-    return { ...this.state };
+  static create(name) {
+    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)
+    };
+  }
+  static create(options) {
+    return new _IgniterJobsBullMQAdapter(options);
+  }
+  registerJob(queueName, jobName, definition) {
+    const map = this.jobsByQueue.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (map.has(jobName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_DUPLICATE_JOB",
+        message: `Job "${jobName}" is already registered in queue "${queueName}".`
+      });
+    }
+    map.set(jobName, definition);
+    this.jobsByQueue.set(queueName, map);
+    this.executorDirty = true;
+  }
+  registerCron(queueName, cronName, definition) {
+    const map = this.cronsByQueue.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (map.has(cronName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" is already registered in queue "${queueName}".`
+      });
+    }
+    map.set(cronName, definition);
+    this.cronsByQueue.set(queueName, map);
+    this.executorDirty = true;
+  }
+  async dispatch(params) {
+    const executor = await this.executor();
+    const namespace = executor[params.queue];
+    if (!namespace) {
+      throw new IgniterJobsError({
+        code: "JOBS_QUEUE_NOT_FOUND",
+        message: `Queue "${params.queue}" is not registered in the adapter.`
+      });
+    }
+    return namespace.enqueue({
+      task: params.jobName,
+      input: params.input,
+      jobId: params.jobId,
+      delay: params.delay,
+      priority: params.priority,
+      attempts: params.attempts,
+      metadata: params.metadata,
+      removeOnComplete: params.removeOnComplete,
+      removeOnFail: params.removeOnFail,
+      limiter: params.limiter
+    });
+  }
+  async schedule(params) {
+    const executor = await this.executor();
+    const namespace = executor[params.queue];
+    if (!namespace) {
+      throw new IgniterJobsError({
+        code: "JOBS_QUEUE_NOT_FOUND",
+        message: `Queue "${params.queue}" is not registered in the adapter.`
+      });
+    }
+    const schedule = {
+      jobId: params.jobId,
+      delay: params.delay,
+      priority: params.priority,
+      attempts: params.attempts,
+      metadata: params.metadata,
+      removeOnComplete: params.removeOnComplete,
+      removeOnFail: params.removeOnFail,
+      limiter: params.limiter,
+      at: params.at,
+      repeat: params.cron || params.every || params.maxExecutions || params.skipWeekends || params.onlyBusinessHours || params.businessHours || params.onlyWeekdays || params.skipDates ? {
+        cron: params.cron,
+        every: params.every,
+        times: params.maxExecutions,
+        skipWeekends: params.skipWeekends,
+        onlyBusinessHours: params.onlyBusinessHours,
+        businessHours: params.businessHours,
+        onlyWeekdays: params.onlyWeekdays,
+        skipDates: toDateArray(params.skipDates)
+      } : void 0
+    };
+    return namespace.schedule({
+      task: params.jobName,
+      input: params.input,
+      ...schedule
+    });
+  }
+  async getJob(jobId, queue) {
+    const result = await this.core().job.get(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+    return result ? this.mapJob(result, queue) : null;
+  }
+  async getJobState(jobId, queue) {
+    const state = await this.core().job.getState(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+    return state;
+  }
+  async getJobLogs(jobId, queue) {
+    const logs = await this.core().job.getLogs(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+    return logs;
+  }
+  async getJobProgress(jobId, queue) {
+    return this.core().job.getProgress(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async retryJob(jobId, queue) {
+    await this.core().job.retry(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async removeJob(jobId, queue) {
+    await this.core().job.remove(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async promoteJob(jobId, queue) {
+    await this.core().job.promote(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async moveJobToFailed(jobId, reason, queue) {
+    await this.core().job.moveToFailed(jobId, reason, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async retryManyJobs(jobIds, queue) {
+    await this.core().job.retryMany(jobIds, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async removeManyJobs(jobIds, queue) {
+    await this.core().job.removeMany(jobIds, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async getQueueInfo(queue) {
+    const info = await this.core().queues.get(this.toCoreQueueName(queue));
+    if (!info) return null;
+    return this.mapQueueInfo(info);
+  }
+  async getQueueJobCounts(queue) {
+    const counts = await this.core().queues.getJobCounts(this.toCoreQueueName(queue));
+    return counts;
+  }
+  async listQueues() {
+    const list = await this.core().queues.list();
+    return list.map((q) => this.mapQueueInfo(q));
+  }
+  async pauseQueue(queue) {
+    await this.core().queues.pause(this.toCoreQueueName(queue));
+  }
+  async resumeQueue(queue) {
+    await this.core().queues.resume(this.toCoreQueueName(queue));
+  }
+  async drainQueue(queue) {
+    return this.core().queues.drain(this.toCoreQueueName(queue));
+  }
+  async cleanQueue(queue, options) {
+    return this.core().queues.clean(this.toCoreQueueName(queue), options);
+  }
+  async obliterateQueue(queue, options) {
+    await this.core().queues.obliterate(this.toCoreQueueName(queue), options);
+  }
+  async retryAllInQueue(queue) {
+    const jobs = await this.core().queues.getJobs(this.toCoreQueueName(queue), { status: ["failed"], limit: 1e3 });
+    await Promise.all(jobs.map((j) => this.core().job.retry(j.id, this.toCoreQueueName(queue))));
+    return jobs.length;
+  }
+  async pauseJobType(queue, jobName) {
+    throw new IgniterJobsError({
+      code: "JOBS_QUEUE_OPERATION_FAILED",
+      message: "BullMQ backend does not support pausing a single job type; pause the queue or adjust worker filters."
+    });
+  }
+  async resumeJobType(queue, jobName) {
+    throw new IgniterJobsError({
+      code: "JOBS_QUEUE_OPERATION_FAILED",
+      message: "BullMQ backend does not support resuming a single job type; resume the queue or adjust worker filters."
+    });
+  }
+  async searchJobs(filter) {
+    const queue = filter?.queue;
+    const status = filter?.status;
+    const limit = filter?.limit ?? 100;
+    const offset = filter?.offset ?? 0;
+    if (queue) {
+      const jobs = await this.core().queues.getJobs(this.toCoreQueueName(queue), { status, limit, offset });
+      return jobs.map((j) => this.mapJob(j, queue));
+    }
+    const queues = await this.listQueues();
+    const results = [];
+    for (const q of queues) {
+      const jobs = await this.core().queues.getJobs(this.toCoreQueueName(q.name), { status, limit, offset });
+      results.push(...jobs.map((j) => this.mapJob(j, q.name)));
+      if (results.length >= limit) break;
+    }
+    return results.slice(0, limit);
+  }
+  async searchQueues(filter) {
+    const all = await this.listQueues();
+    const name = filter?.name;
+    const isPaused = filter?.isPaused;
+    return all.filter((q) => name ? q.name.includes(name) : true).filter((q) => typeof isPaused === "boolean" ? q.isPaused === isPaused : true);
+  }
+  async searchWorkers(filter) {
+    const queue = filter?.queue;
+    const isRunning = filter?.isRunning;
+    const all = Array.from(this.core().getWorkers().values());
+    return all.filter((w) => {
+      if (!queue) return true;
+      const coreQueue = this.toCoreQueueName(queue);
+      const queues = w.config?.queues ?? [w.queueName];
+      return Array.isArray(queues) ? queues.includes(coreQueue) : false;
+    }).filter((w) => typeof isRunning === "boolean" ? isRunning ? w.isRunning() : !w.isRunning() : true).map((w) => this.mapWorker(w));
+  }
+  async createWorker(config) {
+    await this.executor();
+    const queuesSource = config.queues?.length ? config.queues : Array.from(/* @__PURE__ */ new Set([...this.jobsByQueue.keys(), ...this.cronsByQueue.keys()]));
+    const queues = queuesSource.map((q) => this.toCoreQueueName(q));
+    const coreConfig = {
+      queues,
+      concurrency: config.concurrency ?? 1,
+      limiter: config.limiter,
+      onActive: config.handlers?.onActive,
+      onSuccess: config.handlers?.onSuccess,
+      onFailure: config.handlers?.onFailure,
+      onIdle: config.handlers?.onIdle
+    };
+    const handle = await this.core().worker(coreConfig);
+    return this.mapWorker(handle);
+  }
+  getWorkers() {
+    const out = /* @__PURE__ */ new Map();
+    for (const [id, handle] of this.core().getWorkers()) out.set(id, this.mapWorker(handle));
+    return out;
+  }
+  async publishEvent(channel, payload) {
+    await this.publisher.publish(channel, JSON.stringify(payload));
+  }
+  async subscribeEvent(channel, handler) {
+    const set = this.subscribers.get(channel) ?? /* @__PURE__ */ new Set();
+    const wrapped = (payload) => void handler(payload);
+    set.add(wrapped);
+    this.subscribers.set(channel, set);
+    if (set.size === 1) {
+      await this.subscriber.subscribe(channel);
+    }
+    return async () => {
+      const current = this.subscribers.get(channel);
+      if (!current) return;
+      current.delete(wrapped);
+      if (current.size === 0) {
+        this.subscribers.delete(channel);
+        await this.subscriber.unsubscribe(channel);
+      }
+    };
+  }
+  async shutdown() {
+    await this.subscriber.quit();
+  }
+  core() {
+    if (!this.coreAdapter) {
+      this.coreAdapter = createBullMQAdapter({
+        store: { client: this.redis }
+      });
+    }
+    return this.coreAdapter;
+  }
+  async executor() {
+    if (!this.executorDirty && this.coreExecutor) return this.coreExecutor;
+    const routers = {};
+    const flattened = {};
+    const allQueues = /* @__PURE__ */ new Set([...this.jobsByQueue.keys(), ...this.cronsByQueue.keys()]);
+    for (const queueName of allQueues) {
+      const coreJobs = {};
+      const jobs = this.jobsByQueue.get(queueName);
+      if (jobs) {
+        for (const [jobName, def] of jobs.entries()) {
+          const queue = def.queue ? `${queueName}.${def.queue}` : queueName;
+          const fullQueue = IgniterJobsPrefix.buildQueueName(queue);
+          coreJobs[jobName] = this.toCoreJobDefinition(queueName, jobName, def, fullQueue);
+        }
+      }
+      const crons = this.cronsByQueue.get(queueName);
+      if (crons) {
+        for (const [cronName, def] of crons.entries()) {
+          const fullQueue = IgniterJobsPrefix.buildQueueName(queueName);
+          coreJobs[cronName] = this.toCoreCronJobDefinition(queueName, cronName, def, fullQueue);
+        }
+      }
+      if (Object.keys(coreJobs).length === 0) continue;
+      routers[queueName] = this.core().router({
+        jobs: coreJobs,
+        namespace: queueName
+      });
+      for (const [jobName, def] of Object.entries(coreJobs)) {
+        flattened[`${queueName}.${jobName}`] = def;
+      }
+    }
+    await this.core().bulkRegister(flattened);
+    this.coreExecutor = this.core().merge(routers);
+    this.executorDirty = false;
+    return this.coreExecutor;
+  }
+  toCoreQueueName(queueName) {
+    return IgniterJobsPrefix.buildQueueName(queueName);
+  }
+  mapQueueInfo(info) {
+    return {
+      name: this.fromCoreQueueName(info.name),
+      isPaused: info.isPaused,
+      jobCounts: info.jobCounts
+    };
+  }
+  fromCoreQueueName(full) {
+    const prefix = `${IgniterJobsPrefix.BASE_PREFIX}:`;
+    return full.startsWith(prefix) ? full.slice(prefix.length) : full;
+  }
+  mapJob(job, queue) {
+    const q = queue ?? this.fromCoreQueueName(job.metadata?.queue ?? job.queueName ?? "");
+    const scope = job.metadata?.__igniter_jobs_scope;
+    return {
+      id: job.id,
+      name: job.name,
+      queue: q,
+      status: job.status,
+      input: job.payload,
+      result: job.result,
+      error: job.error,
+      progress: 0,
+      attemptsMade: job.attemptsMade ?? 0,
+      priority: job.priority ?? 0,
+      createdAt: job.createdAt,
+      startedAt: job.processedAt,
+      completedAt: job.completedAt,
+      metadata: job.metadata,
+      scope
+    };
+  }
+  mapWorker(handle) {
+    const queues = handle.config?.queues ?? [handle.queueName];
+    return {
+      id: handle.id,
+      queues: queues.map((q) => this.fromCoreQueueName(q)),
+      pause: () => handle.pause(),
+      resume: () => handle.resume(),
+      close: () => handle.close(),
+      isRunning: () => handle.isRunning(),
+      isPaused: () => handle.isPaused(),
+      isClosed: () => handle.isClosed(),
+      getMetrics: async () => handle.getMetrics()
+    };
+  }
+  toCoreJobDefinition(queueName, jobName, def, fullQueueName) {
+    const handler = async (ctx) => {
+      return def.handler({
+        input: ctx.input,
+        context: ctx.context,
+        job: {
+          id: ctx.job.id,
+          name: jobName,
+          queue: queueName,
+          attemptsMade: ctx.job.attemptsMade,
+          createdAt: ctx.job.createdAt,
+          metadata: ctx.job.metadata
+        },
+        scope: ctx.job.metadata?.__igniter_jobs_scope
+      });
+    };
+    return {
+      name: jobName,
+      input: def.input,
+      handler,
+      queue: { name: fullQueueName },
+      attempts: def.attempts,
+      priority: def.priority,
+      delay: def.delay,
+      removeOnComplete: def.removeOnComplete,
+      removeOnFail: def.removeOnFail,
+      metadata: def.metadata,
+      limiter: def.limiter,
+      onStart: def.onStart,
+      onSuccess: def.onSuccess,
+      onFailure: def.onFailure,
+      onProgress: def.onProgress
+    };
+  }
+  toCoreCronJobDefinition(queueName, cronName, def, fullQueueName) {
+    const handler = async (ctx) => {
+      return def.handler({
+        context: ctx.context,
+        job: {
+          id: ctx.job.id,
+          name: cronName,
+          queue: queueName,
+          attemptsMade: ctx.job.attemptsMade,
+          createdAt: ctx.job.createdAt,
+          metadata: ctx.job.metadata
+        },
+        scope: ctx.job.metadata?.__igniter_jobs_scope
+      });
+    };
+    return {
+      name: cronName,
+      handler,
+      queue: { name: fullQueueName },
+      repeat: {
+        cron: def.cron,
+        tz: def.tz,
+        limit: def.maxExecutions,
+        startDate: def.startDate,
+        endDate: def.endDate
+      },
+      metadata: def.onlyBusinessHours || def.skipWeekends || def.businessHours || def.onlyWeekdays || def.skipDates || def.startDate && def.endDate ? {
+        advancedScheduling: {
+          onlyBusinessHours: def.onlyBusinessHours,
+          skipWeekends: def.skipWeekends,
+          businessHours: def.businessHours,
+          skipDates: toDateArray(def.skipDates),
+          onlyWeekdays: def.onlyWeekdays,
+          between: def.startDate && def.endDate ? [def.startDate, def.endDate] : void 0
+        }
+      } : void 0
+    };
   }
 };
-var IgniterQueue = {
-  create: IgniterQueueBuilder.create
+
+// src/utils/id-generator.ts
+var IgniterJobsIdGenerator = class {
+  /**
+   * Generates a unique identifier with a prefix.
+   *
+   * @example
+   * ```typescript
+   * const jobId = IgniterJobsIdGenerator.generate('job')
+   * ```
+   */
+  static generate(prefix) {
+    const now = Date.now().toString(36);
+    const random = Math.random().toString(36).slice(2, 8);
+    return `${prefix}_${now}_${random}`;
+  }
+};
+
+// src/adapters/memory.adapter.ts
+var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
+  constructor() {
+    this.client = {
+      type: "memory"
+    };
+    this.jobsById = /* @__PURE__ */ new Map();
+    this.jobsByQueue = /* @__PURE__ */ new Map();
+    this.registeredJobs = /* @__PURE__ */ new Map();
+    this.registeredCrons = /* @__PURE__ */ new Map();
+    this.workers = /* @__PURE__ */ new Map();
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.queues = {
+      list: async () => this.listQueues(),
+      get: async (name) => this.getQueueInfo(name),
+      getJobCounts: async (name) => this.getQueueJobCounts(name),
+      getJobs: async (name, filter) => {
+        const statuses = filter?.status;
+        const limit = filter?.limit ?? 100;
+        const offset = filter?.offset ?? 0;
+        const results = await this.searchJobs({
+          queue: name,
+          status: statuses,
+          limit,
+          offset
+        });
+        return results;
+      },
+      pause: async (name) => this.pauseQueue(name),
+      resume: async (name) => this.resumeQueue(name),
+      isPaused: async (name) => {
+        const info = await this.getQueueInfo(name);
+        return info?.isPaused ?? false;
+      },
+      drain: async (name) => this.drainQueue(name),
+      clean: async (name, options) => this.cleanQueue(name, options),
+      obliterate: async (name, options) => this.obliterateQueue(name, options)
+    };
+    this.pausedQueues = /* @__PURE__ */ new Set();
+  }
+  static create() {
+    return new _IgniterJobsMemoryAdapter();
+  }
+  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 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/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: {}
+    }
+  }
 };
 
-export { IGNITER_JOBS_ERROR_CODES, IgniterJobs, IgniterJobsBuilder, IgniterJobsError, IgniterJobsRuntime, IgniterQueue, IgniterQueueBuilder, IgniterWorkerBuilder };
+export { IGNITER_JOBS_ERROR_CODES, IgniterJobs, IgniterJobsBuilder, IgniterJobsBullMQAdapter, IgniterJobsError, IgniterJobsMemoryAdapter, IgniterJobsTelemetryEvents, IgniterQueue, IgniterQueueBuilder, IgniterWorkerBuilder };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map