@gravito/stream 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/index.cjs

@@ -56,10 +56,11 @@ var init_DatabaseDriver = __esm({
        */
       async push(queue, job) {
         const availableAt = job.delaySeconds ? new Date(Date.now() + job.delaySeconds * 1e3) : /* @__PURE__ */ new Date();
+        const payload = JSON.stringify(job);
         await this.dbService.execute(
           `INSERT INTO ${this.tableName} (queue, payload, attempts, available_at, created_at)
        VALUES ($1, $2, $3, $4, $5)`,
-          [queue, job.data, job.attempts ?? 0, availableAt.toISOString(), (/* @__PURE__ */ new Date()).toISOString()]
+          [queue, payload, job.attempts ?? 0, availableAt.toISOString(), (/* @__PURE__ */ new Date()).toISOString()]
         );
       }
       /**
@@ -102,15 +103,32 @@ var init_DatabaseDriver = __esm({
         );
         const createdAt = new Date(row.created_at).getTime();
         const delaySeconds = row.available_at ? Math.max(0, Math.floor((new Date(row.available_at).getTime() - createdAt) / 1e3)) : void 0;
-        return {
-          id: row.id,
-          type: "class",
-          // Default; should be inferred from payload in a full implementation
-          data: row.payload,
-          createdAt,
-          attempts: row.attempts,
-          ...delaySeconds !== void 0 ? { delaySeconds } : {}
-        };
+        let job;
+        try {
+          const parsed = JSON.parse(row.payload);
+          if (parsed && typeof parsed === "object" && parsed.type && parsed.data) {
+            job = {
+              ...parsed,
+              id: row.id,
+              // DB ID is the source of truth for deletion
+              attempts: row.attempts
+            };
+          } else {
+            throw new Error("Fallback");
+          }
+        } catch (_e) {
+          job = {
+            id: row.id,
+            type: "class",
+            data: row.payload,
+            createdAt,
+            attempts: row.attempts
+          };
+        }
+        if (delaySeconds !== void 0) {
+          job.delaySeconds = delaySeconds;
+        }
+        return job;
       }
       /**
        * Get queue size.
@@ -150,6 +168,27 @@ var init_DatabaseDriver = __esm({
           }
         });
       }
+      /**
+       * Mark a job as failed (DLQ).
+       */
+      async fail(queue, job) {
+        const failedQueue = `failed:${queue}`;
+        const payload = JSON.stringify(job);
+        await this.dbService.execute(
+          `INSERT INTO ${this.tableName} (queue, payload, attempts, available_at, created_at)
+       VALUES ($1, $2, $3, $4, $5)`,
+          [failedQueue, payload, job.attempts, (/* @__PURE__ */ new Date()).toISOString(), (/* @__PURE__ */ new Date()).toISOString()]
+        );
+      }
+      /**
+       * Acknowledge/Complete a job.
+       */
+      async complete(_queue, job) {
+        if (!job.id) {
+          return;
+        }
+        await this.dbService.execute(`DELETE FROM ${this.tableName} WHERE id = $1`, [job.id]);
+      }
     };
   }
 });
@@ -328,6 +367,150 @@ var init_KafkaDriver = __esm({
   }
 });
 
+// src/drivers/RabbitMQDriver.ts
+var RabbitMQDriver_exports = {};
+__export(RabbitMQDriver_exports, {
+  RabbitMQDriver: () => RabbitMQDriver
+});
+var RabbitMQDriver;
+var init_RabbitMQDriver = __esm({
+  "src/drivers/RabbitMQDriver.ts"() {
+    "use strict";
+    RabbitMQDriver = class {
+      connection;
+      channel;
+      exchange;
+      exchangeType;
+      constructor(config) {
+        this.connection = config.client;
+        this.exchange = config.exchange;
+        this.exchangeType = config.exchangeType ?? "fanout";
+        if (!this.connection) {
+          throw new Error(
+            "[RabbitMQDriver] RabbitMQ connection is required. Please provide a connection from amqplib."
+          );
+        }
+      }
+      /**
+       * Ensure channel is created.
+       */
+      async ensureChannel() {
+        if (this.channel) {
+          return this.channel;
+        }
+        if (typeof this.connection.createChannel === "function") {
+          this.channel = await this.connection.createChannel();
+        } else {
+          this.channel = this.connection;
+        }
+        if (this.exchange) {
+          await this.channel.assertExchange(this.exchange, this.exchangeType, { durable: true });
+        }
+        return this.channel;
+      }
+      /**
+       * Get the underlying connection.
+       */
+      getRawConnection() {
+        return this.connection;
+      }
+      /**
+       * Push a job (sendToQueue / publish).
+       */
+      async push(queue, job) {
+        const channel = await this.ensureChannel();
+        const payload = Buffer.from(JSON.stringify(job));
+        if (this.exchange) {
+          await channel.assertQueue(queue, { durable: true });
+          await channel.bindQueue(queue, this.exchange, "");
+          channel.publish(this.exchange, "", payload, { persistent: true });
+        } else {
+          await channel.assertQueue(queue, { durable: true });
+          channel.sendToQueue(queue, payload, { persistent: true });
+        }
+      }
+      /**
+       * Pop a job (get).
+       */
+      async pop(queue) {
+        const channel = await this.ensureChannel();
+        await channel.assertQueue(queue, { durable: true });
+        const msg = await channel.get(queue, { noAck: false });
+        if (!msg) {
+          return null;
+        }
+        const job = JSON.parse(msg.content.toString());
+        job._raw = msg;
+        return job;
+      }
+      /**
+       * Acknowledge a message.
+       */
+      async acknowledge(messageId) {
+        const channel = await this.ensureChannel();
+        if (typeof messageId === "object") {
+          channel.ack(messageId);
+        }
+      }
+      /**
+       * Negative acknowledge a message.
+       */
+      async nack(message, requeue = true) {
+        const channel = await this.ensureChannel();
+        channel.nack(message, false, requeue);
+      }
+      /**
+       * Reject a message.
+       */
+      async reject(message, requeue = true) {
+        const channel = await this.ensureChannel();
+        channel.reject(message, requeue);
+      }
+      /**
+       * Subscribe to a queue.
+       */
+      async subscribe(queue, callback, options = {}) {
+        const channel = await this.ensureChannel();
+        await channel.assertQueue(queue, { durable: true });
+        if (this.exchange) {
+          await channel.bindQueue(queue, this.exchange, "");
+        }
+        const { autoAck = true } = options;
+        await channel.consume(
+          queue,
+          async (msg) => {
+            if (!msg) {
+              return;
+            }
+            const job = JSON.parse(msg.content.toString());
+            job._raw = msg;
+            await callback(job);
+            if (autoAck) {
+              channel.ack(msg);
+            }
+          },
+          { noAck: false }
+        );
+      }
+      /**
+       * Get queue size.
+       */
+      async size(queue) {
+        const channel = await this.ensureChannel();
+        const ok = await channel.checkQueue(queue);
+        return ok.messageCount;
+      }
+      /**
+       * Clear a queue.
+       */
+      async clear(queue) {
+        const channel = await this.ensureChannel();
+        await channel.purgeQueue(queue);
+      }
+    };
+  }
+});
+
 // src/drivers/RedisDriver.ts
 var RedisDriver_exports = {};
 __export(RedisDriver_exports, {
@@ -337,9 +520,43 @@ var RedisDriver;
 var init_RedisDriver = __esm({
   "src/drivers/RedisDriver.ts"() {
     "use strict";
-    RedisDriver = class {
+    RedisDriver = class _RedisDriver {
       prefix;
       client;
+      // Lua Logic:
+      // IF (IS_MEMBER(activeSet, groupId)) -> PUSH(pendingList, job)
+      // ELSE -> SADD(activeSet, groupId) & LPUSH(waitList, job)
+      static PUSH_SCRIPT = `
+    local waitList = KEYS[1]
+    local activeSet = KEYS[2]
+    local pendingList = KEYS[3]
+    local groupId = ARGV[1]
+    local payload = ARGV[2]
+    
+    if redis.call('SISMEMBER', activeSet, groupId) == 1 then
+      return redis.call('RPUSH', pendingList, payload)
+    else
+      redis.call('SADD', activeSet, groupId)
+      return redis.call('LPUSH', waitList, payload)
+    end
+  `;
+      // Lua Logic:
+      // local next = LPOP(pendingList)
+      // IF (next) -> LPUSH(waitList, next)
+      // ELSE -> SREM(activeSet, groupId)
+      static COMPLETE_SCRIPT = `
+    local waitList = KEYS[1]
+    local activeSet = KEYS[2]
+    local pendingList = KEYS[3]
+    local groupId = ARGV[1]
+
+    local nextJob = redis.call('LPOP', pendingList)
+    if nextJob then
+      return redis.call('LPUSH', waitList, nextJob)
+    else
+      return redis.call('SREM', activeSet, groupId)
+    end
+  `;
       constructor(config) {
         this.client = config.client;
         this.prefix = config.prefix ?? "queue:";
@@ -348,19 +565,36 @@ var init_RedisDriver = __esm({
             "[RedisDriver] Redis client is required. Please install ioredis or redis package."
           );
         }
+        if (typeof this.client.defineCommand === "function") {
+          ;
+          this.client.defineCommand("pushGroupJob", {
+            numberOfKeys: 3,
+            lua: _RedisDriver.PUSH_SCRIPT
+          });
+          this.client.defineCommand("completeGroupJob", {
+            numberOfKeys: 3,
+            lua: _RedisDriver.COMPLETE_SCRIPT
+          });
+        }
       }
       /**
        * Get full Redis key for a queue.
        */
-      getKey(queue) {
+      getKey(queue, priority) {
+        if (priority) {
+          return `${this.prefix}${queue}:${priority}`;
+        }
         return `${this.prefix}${queue}`;
       }
       /**
        * Push a job (LPUSH).
        */
-      async push(queue, job) {
-        const key = this.getKey(queue);
-        const payload = JSON.stringify({
+      async push(queue, job, options) {
+        const key = this.getKey(queue, options?.priority);
+        const groupId = options?.groupId;
+        if (groupId && options?.priority) {
+        }
+        const payloadObj = {
           id: job.id,
           type: job.type,
           data: job.data,
@@ -368,8 +602,18 @@ var init_RedisDriver = __esm({
           createdAt: job.createdAt,
           delaySeconds: job.delaySeconds,
           attempts: job.attempts,
-          maxAttempts: job.maxAttempts
-        });
+          maxAttempts: job.maxAttempts,
+          groupId,
+          error: job.error,
+          failedAt: job.failedAt
+        };
+        const payload = JSON.stringify(payloadObj);
+        if (groupId && typeof this.client.pushGroupJob === "function") {
+          const activeSetKey = `${this.prefix}active`;
+          const pendingListKey = `${this.prefix}pending:${groupId}`;
+          await this.client.pushGroupJob(key, activeSetKey, pendingListKey, groupId, payload);
+          return;
+        }
         if (job.delaySeconds && job.delaySeconds > 0) {
           const delayKey = `${key}:delayed`;
           const score = Date.now() + job.delaySeconds * 1e3;
@@ -382,29 +626,53 @@ var init_RedisDriver = __esm({
           await this.client.lpush(key, payload);
         }
       }
+      /**
+       * Complete a job (handle Group FIFO).
+       */
+      async complete(queue, job) {
+        if (!job.groupId) {
+          return;
+        }
+        const key = this.getKey(queue);
+        const activeSetKey = `${this.prefix}active`;
+        const pendingListKey = `${this.prefix}pending:${job.groupId}`;
+        if (typeof this.client.completeGroupJob === "function") {
+          await this.client.completeGroupJob(key, activeSetKey, pendingListKey, job.groupId);
+        }
+      }
       /**
        * Pop a job (RPOP, FIFO).
+       * Supports implicit priority polling (critical -> high -> default -> low).
        */
       async pop(queue) {
-        const key = this.getKey(queue);
-        const delayKey = `${key}:delayed`;
-        if (typeof this.client.zrange === "function") {
-          const now = Date.now();
-          const delayedJobs = await this.client.zrange(delayKey, 0, 0, true);
-          if (delayedJobs && delayedJobs.length >= 2) {
-            const score = parseFloat(delayedJobs[1]);
-            if (score <= now) {
-              const payload2 = delayedJobs[0];
-              await this.client.zrem(delayKey, payload2);
-              return this.parsePayload(payload2);
+        const priorities = ["critical", "high", void 0, "low"];
+        for (const priority of priorities) {
+          const key = this.getKey(queue, priority);
+          const delayKey = `${key}:delayed`;
+          if (typeof this.client.zrange === "function") {
+            const now = Date.now();
+            const delayedJobs = await this.client.zrange(delayKey, 0, 0, "WITHSCORES");
+            if (delayedJobs && delayedJobs.length >= 2) {
+              const score = parseFloat(delayedJobs[1]);
+              if (score <= now) {
+                const payload2 = delayedJobs[0];
+                await this.client.zrem(delayKey, payload2);
+                return this.parsePayload(payload2);
+              }
             }
           }
+          if (typeof this.client.get === "function") {
+            const isPaused = await this.client.get(`${key}:paused`);
+            if (isPaused === "1") {
+              continue;
+            }
+          }
+          const payload = await this.client.rpop(key);
+          if (payload) {
+            return this.parsePayload(payload);
+          }
         }
-        const payload = await this.client.rpop(key);
-        if (!payload) {
-          return null;
-        }
-        return this.parsePayload(payload);
+        return null;
       }
       /**
        * Parse Redis payload.
@@ -419,7 +687,11 @@ var init_RedisDriver = __esm({
           createdAt: parsed.createdAt,
           delaySeconds: parsed.delaySeconds,
           attempts: parsed.attempts,
-          maxAttempts: parsed.maxAttempts
+          maxAttempts: parsed.maxAttempts,
+          groupId: parsed.groupId,
+          error: parsed.error,
+          failedAt: parsed.failedAt,
+          priority: parsed.priority
         };
       }
       /**
@@ -429,15 +701,31 @@ var init_RedisDriver = __esm({
         const key = this.getKey(queue);
         return this.client.llen(key);
       }
+      /**
+       * Mark a job as permanently failed (DLQ).
+       */
+      async fail(queue, job) {
+        const key = `${this.getKey(queue)}:failed`;
+        const payload = JSON.stringify({
+          ...job,
+          failedAt: Date.now()
+        });
+        await this.client.lpush(key, payload);
+        if (typeof this.client.ltrim === "function") {
+          await this.client.ltrim(key, 0, 999);
+        }
+      }
       /**
        * Clear a queue.
        */
       async clear(queue) {
         const key = this.getKey(queue);
         const delayKey = `${key}:delayed`;
+        const activeSetKey = `${this.prefix}active`;
         await this.client.del(key);
         if (typeof this.client.del === "function") {
           await this.client.del(delayKey);
+          await this.client.del(activeSetKey);
         }
       }
       /**
@@ -447,6 +735,17 @@ var init_RedisDriver = __esm({
         if (jobs.length === 0) {
           return;
         }
+        const hasGroup = jobs.some((j) => j.groupId);
+        const hasPriority = jobs.some((j) => j.priority);
+        if (hasGroup || hasPriority) {
+          for (const job of jobs) {
+            await this.push(queue, job, {
+              groupId: job.groupId,
+              priority: job.priority
+            });
+          }
+          return;
+        }
         const key = this.getKey(queue);
         const payloads = jobs.map(
           (job) => JSON.stringify({
@@ -457,7 +756,9 @@ var init_RedisDriver = __esm({
             createdAt: job.createdAt,
             delaySeconds: job.delaySeconds,
             attempts: job.attempts,
-            maxAttempts: job.maxAttempts
+            maxAttempts: job.maxAttempts,
+            groupId: job.groupId,
+            priority: job.priority
           })
         );
         await this.client.lpush(key, ...payloads);
@@ -478,6 +779,89 @@ var init_RedisDriver = __esm({
         }
         return results;
       }
+      /**
+       * Report worker heartbeat for monitoring.
+       */
+      async reportHeartbeat(workerInfo, prefix) {
+        const key = `${prefix ?? this.prefix}worker:${workerInfo.id}`;
+        if (typeof this.client.set === "function") {
+          await this.client.set(key, JSON.stringify(workerInfo), "EX", 10);
+        }
+      }
+      /**
+       * Publish a log message for monitoring.
+       */
+      async publishLog(logPayload, prefix) {
+        const payload = JSON.stringify(logPayload);
+        const monitorPrefix = prefix ?? this.prefix;
+        if (typeof this.client.publish === "function") {
+          await this.client.publish(`${monitorPrefix}logs`, payload);
+        }
+        const historyKey = `${monitorPrefix}logs:history`;
+        if (typeof this.client.pipeline === "function") {
+          const pipe = this.client.pipeline();
+          pipe.lpush(historyKey, payload);
+          pipe.ltrim(historyKey, 0, 99);
+          await pipe.exec();
+        } else {
+          await this.client.lpush(historyKey, payload);
+        }
+      }
+      /**
+       * Check if a queue is rate limited.
+       * Uses a fixed window counter.
+       */
+      async checkRateLimit(queue, config) {
+        const key = `${this.prefix}${queue}:ratelimit`;
+        const now = Date.now();
+        const windowStart = Math.floor(now / config.duration);
+        const windowKey = `${key}:${windowStart}`;
+        const client = this.client;
+        if (typeof client.incr === "function") {
+          const current = await client.incr(windowKey);
+          if (current === 1) {
+            await client.expire(windowKey, Math.ceil(config.duration / 1e3) + 1);
+          }
+          return current <= config.max;
+        }
+        return true;
+      }
+      /**
+       * Get failed jobs from DLQ.
+       */
+      async getFailed(queue, start = 0, end = -1) {
+        const key = `${this.getKey(queue)}:failed`;
+        const payloads = await this.client.lrange(key, start, end);
+        return payloads.map((p) => this.parsePayload(p));
+      }
+      /**
+       * Retry failed jobs from DLQ.
+       * Moves jobs from failed list back to the main queue.
+       */
+      async retryFailed(queue, count = 1) {
+        const failedKey = `${this.getKey(queue)}:failed`;
+        let retried = 0;
+        for (let i = 0; i < count; i++) {
+          const payload = await this.client.rpop(failedKey);
+          if (!payload) {
+            break;
+          }
+          const job = this.parsePayload(payload);
+          job.attempts = 0;
+          delete job.error;
+          delete job.failedAt;
+          await this.push(queue, job, { priority: job.priority, groupId: job.groupId });
+          retried++;
+        }
+        return retried;
+      }
+      /**
+       * Clear failed jobs from DLQ.
+       */
+      async clearFailed(queue) {
+        const key = `${this.getKey(queue)}:failed`;
+        await this.client.del(key);
+      }
     };
   }
 });
@@ -683,6 +1067,125 @@ var init_SQSDriver = __esm({
   }
 });
 
+// src/Scheduler.ts
+var Scheduler_exports = {};
+__export(Scheduler_exports, {
+  Scheduler: () => Scheduler
+});
+var import_cron_parser, Scheduler;
+var init_Scheduler = __esm({
+  "src/Scheduler.ts"() {
+    "use strict";
+    import_cron_parser = __toESM(require("cron-parser"), 1);
+    Scheduler = class {
+      constructor(manager, options = {}) {
+        this.manager = manager;
+        this.prefix = options.prefix ?? "queue:";
+      }
+      prefix;
+      get client() {
+        const driver = this.manager.getDriver(this.manager.getDefaultConnection());
+        return driver.client;
+      }
+      /**
+       * Register a scheduled job.
+       */
+      async register(config) {
+        const nextRun = import_cron_parser.default.parse(config.cron).next().getTime();
+        const fullConfig = {
+          ...config,
+          nextRun,
+          enabled: true
+        };
+        const pipe = this.client.pipeline();
+        pipe.hset(`${this.prefix}schedule:${config.id}`, {
+          ...fullConfig,
+          job: JSON.stringify(fullConfig.job)
+        });
+        pipe.zadd(`${this.prefix}schedules`, nextRun, config.id);
+        await pipe.exec();
+      }
+      /**
+       * Remove a scheduled job.
+       */
+      async remove(id) {
+        const pipe = this.client.pipeline();
+        pipe.del(`${this.prefix}schedule:${id}`);
+        pipe.zrem(`${this.prefix}schedules`, id);
+        await pipe.exec();
+      }
+      /**
+       * List all scheduled jobs.
+       */
+      async list() {
+        const ids = await this.client.zrange(`${this.prefix}schedules`, 0, -1);
+        const configs = [];
+        for (const id of ids) {
+          const data = await this.client.hgetall(`${this.prefix}schedule:${id}`);
+          if (data?.id) {
+            configs.push({
+              ...data,
+              lastRun: data.lastRun ? parseInt(data.lastRun, 10) : void 0,
+              nextRun: data.nextRun ? parseInt(data.nextRun, 10) : void 0,
+              enabled: data.enabled === "true",
+              job: JSON.parse(data.job)
+            });
+          }
+        }
+        return configs;
+      }
+      /**
+       * Run a scheduled job immediately (out of schedule).
+       */
+      async runNow(id) {
+        const data = await this.client.hgetall(`${this.prefix}schedule:${id}`);
+        if (data?.id) {
+          const serialized = JSON.parse(data.job);
+          const serializer = this.manager.getSerializer();
+          const job = serializer.deserialize(serialized);
+          await this.manager.push(job);
+        }
+      }
+      /**
+       * Process due tasks (TICK).
+       * This should be called periodically (e.g. every minute).
+       */
+      async tick() {
+        const now = Date.now();
+        const dueIds = await this.client.zrangebyscore(`${this.prefix}schedules`, 0, now);
+        let fired = 0;
+        for (const id of dueIds) {
+          const lockKey = `${this.prefix}lock:schedule:${id}:${Math.floor(now / 1e3)}`;
+          const lock = await this.client.set(lockKey, "1", "EX", 10, "NX");
+          if (lock === "OK") {
+            const data = await this.client.hgetall(`${this.prefix}schedule:${id}`);
+            if (data?.id && data.enabled === "true") {
+              try {
+                const serializedJob = JSON.parse(data.job);
+                const connection = data.connection || this.manager.getDefaultConnection();
+                const driver = this.manager.getDriver(connection);
+                await driver.push(data.queue, serializedJob);
+                const nextRun = import_cron_parser.default.parse(data.cron).next().getTime();
+                const pipe = this.client.pipeline();
+                pipe.hset(`${this.prefix}schedule:${id}`, {
+                  lastRun: now,
+                  nextRun
+                });
+                pipe.zadd(`${this.prefix}schedules`, nextRun, id);
+                await pipe.exec();
+                fired++;
+              } catch (err) {
+                console.error(`[Scheduler] Failed to process schedule ${id}:`, err);
+              }
+            }
+          }
+        }
+        return fired;
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -693,10 +1196,14 @@ __export(index_exports, {
   JsonSerializer: () => JsonSerializer,
   KafkaDriver: () => KafkaDriver,
   MemoryDriver: () => MemoryDriver,
+  MySQLPersistence: () => MySQLPersistence,
   OrbitStream: () => OrbitStream,
   QueueManager: () => QueueManager,
+  RabbitMQDriver: () => RabbitMQDriver,
   RedisDriver: () => RedisDriver,
+  SQLitePersistence: () => SQLitePersistence,
   SQSDriver: () => SQSDriver,
+  Scheduler: () => Scheduler,
   Worker: () => Worker
 });
 module.exports = __toCommonJS(index_exports);
@@ -711,36 +1218,31 @@ var Worker = class {
    * @param job - Job instance
    */
   async process(job) {
-    const maxAttempts = this.options.maxAttempts ?? 3;
+    const maxAttempts = job.maxAttempts ?? this.options.maxAttempts ?? 3;
     const timeout = this.options.timeout;
-    let lastError = null;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        job.attempts = attempt;
-        job.maxAttempts = maxAttempts;
-        if (timeout) {
-          await Promise.race([
-            job.handle(),
-            new Promise(
-              (_, reject) => setTimeout(
-                () => reject(new Error(`Job timeout after ${timeout} seconds`)),
-                timeout * 1e3
-              )
+    if (!job.attempts) {
+      job.attempts = 1;
+    }
+    try {
+      if (timeout) {
+        await Promise.race([
+          job.handle(),
+          new Promise(
+            (_, reject) => setTimeout(
+              () => reject(new Error(`Job timeout after ${timeout} seconds`)),
+              timeout * 1e3
             )
-          ]);
-        } else {
-          await job.handle();
-        }
-        return;
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        if (attempt === maxAttempts) {
-          await this.handleFailure(job, lastError);
-          throw lastError;
-        }
-        const delay = Math.min(1e3 * 2 ** (attempt - 1), 3e4);
-        await new Promise((resolve) => setTimeout(resolve, delay));
+          )
+        ]);
+      } else {
+        await job.handle();
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (job.attempts >= maxAttempts) {
+        await this.handleFailure(job, err);
       }
+      throw err;
     }
   }
   /**
@@ -770,6 +1272,11 @@ var Consumer = class {
   }
   running = false;
   stopRequested = false;
+  workerId = `worker-${Math.random().toString(36).substring(2, 8)}`;
+  heartbeatTimer = null;
+  get connectionName() {
+    return this.options.connection ?? this.queueManager.getDefaultConnection();
+  }
   /**
    * Start the consumer loop.
    */
@@ -784,18 +1291,72 @@ var Consumer = class {
     const keepAlive = this.options.keepAlive ?? true;
     console.log("[Consumer] Started", {
       queues: this.options.queues,
-      connection: this.options.connection
+      connection: this.options.connection,
+      workerId: this.workerId
     });
+    if (this.options.monitor) {
+      this.startHeartbeat();
+      await this.publishLog("info", `Consumer started on [${this.options.queues.join(", ")}]`);
+    }
     while (this.running && !this.stopRequested) {
       let processed = false;
       for (const queue of this.options.queues) {
+        if (this.options.rateLimits?.[queue]) {
+          const limit = this.options.rateLimits[queue];
+          try {
+            const driver = this.queueManager.getDriver(this.connectionName);
+            if (driver.checkRateLimit) {
+              const allowed = await driver.checkRateLimit(queue, limit);
+              if (!allowed) {
+                continue;
+              }
+            }
+          } catch (err) {
+            console.error(`[Consumer] Error checking rate limit for "${queue}":`, err);
+          }
+        }
         try {
           const job = await this.queueManager.pop(queue, this.options.connection);
           if (job) {
             processed = true;
-            await worker.process(job).catch((error) => {
-              console.error(`[Consumer] Error processing job in queue "${queue}":`, error);
-            });
+            if (this.options.monitor) {
+              await this.publishLog("info", `Processing job: ${job.id}`, job.id);
+            }
+            try {
+              await worker.process(job);
+              if (this.options.monitor) {
+                await this.publishLog("success", `Completed job: ${job.id}`, job.id);
+              }
+            } catch (err) {
+              console.error(`[Consumer] Error processing job in queue "${queue}":`, err);
+              if (this.options.monitor) {
+                await this.publishLog("error", `Job failed: ${job.id} - ${err.message}`, job.id);
+              }
+              const attempts = job.attempts ?? 1;
+              const maxAttempts = job.maxAttempts ?? this.options.workerOptions?.maxAttempts ?? 3;
+              if (attempts < maxAttempts) {
+                job.attempts = attempts + 1;
+                const delayMs = job.getRetryDelay(job.attempts);
+                const delaySec = Math.ceil(delayMs / 1e3);
+                job.delay(delaySec);
+                await this.queueManager.push(job);
+                if (this.options.monitor) {
+                  await this.publishLog(
+                    "warning",
+                    `Job retrying in ${delaySec}s (Attempt ${job.attempts}/${maxAttempts})`,
+                    job.id
+                  );
+                }
+              } else {
+                await this.queueManager.fail(job, err).catch((dlqErr) => {
+                  console.error(`[Consumer] Error moving job to DLQ:`, dlqErr);
+                });
+              }
+            } finally {
+              await this.queueManager.complete(job).catch((err) => {
+                console.error(`[Consumer] Error completing job in queue "${queue}":`, err);
+              });
+            }
           }
         } catch (error) {
           console.error(`[Consumer] Error polling queue "${queue}":`, error);
@@ -804,13 +1365,83 @@ var Consumer = class {
       if (!processed && !keepAlive) {
         break;
       }
-      if (!this.stopRequested) {
+      if (!this.stopRequested && !processed) {
         await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      } else if (!this.stopRequested && processed) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
       }
     }
     this.running = false;
+    this.stopHeartbeat();
+    if (this.options.monitor) {
+      await this.publishLog("info", "Consumer stopped");
+    }
     console.log("[Consumer] Stopped");
   }
+  startHeartbeat() {
+    const interval = typeof this.options.monitor === "object" ? this.options.monitor.interval ?? 5e3 : 5e3;
+    const monitorOptions = typeof this.options.monitor === "object" ? this.options.monitor : {};
+    this.heartbeatTimer = setInterval(async () => {
+      try {
+        const driver = this.queueManager.getDriver(this.connectionName);
+        if (driver.reportHeartbeat) {
+          const monitorPrefix = typeof this.options.monitor === "object" ? this.options.monitor.prefix : void 0;
+          const os = require("os");
+          const mem = process.memoryUsage();
+          const metrics = {
+            cpu: os.loadavg()[0],
+            // 1m load avg
+            cores: os.cpus().length,
+            ram: {
+              rss: Math.floor(mem.rss / 1024 / 1024),
+              heapUsed: Math.floor(mem.heapUsed / 1024 / 1024),
+              total: Math.floor(os.totalmem() / 1024 / 1024)
+            }
+          };
+          await driver.reportHeartbeat(
+            {
+              id: this.workerId,
+              status: "online",
+              hostname: os.hostname(),
+              pid: process.pid,
+              uptime: Math.floor(process.uptime()),
+              last_ping: (/* @__PURE__ */ new Date()).toISOString(),
+              queues: this.options.queues,
+              metrics,
+              ...monitorOptions.extraInfo || {}
+            },
+            monitorPrefix
+          );
+        }
+      } catch (_e) {
+      }
+    }, interval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  async publishLog(level, message, jobId) {
+    try {
+      const driver = this.queueManager.getDriver(this.connectionName);
+      if (driver.publishLog) {
+        const monitorPrefix = typeof this.options.monitor === "object" ? this.options.monitor.prefix : void 0;
+        await driver.publishLog(
+          {
+            level,
+            message,
+            workerId: this.workerId,
+            jobId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          monitorPrefix
+        );
+      }
+    } catch (_e) {
+    }
+  }
   /**
    * Stop the consumer loop (graceful shutdown).
    */
@@ -901,11 +1532,16 @@ var MemoryDriver = class {
 };
 
 // src/index.ts
+init_RabbitMQDriver();
 init_RedisDriver();
 init_SQSDriver();
 
 // src/Job.ts
 var Job = class {
+  /**
+   * Unique job identifier.
+   */
+  id;
   /**
    * Queue name.
    */
@@ -926,6 +1562,22 @@ var Job = class {
    * Maximum attempts.
    */
   maxAttempts;
+  /**
+   * Group ID for FIFO.
+   */
+  groupId;
+  /**
+   * Job priority.
+   */
+  priority;
+  /**
+   * Initial retry delay (seconds).
+   */
+  retryAfterSeconds;
+  /**
+   * Retry delay multiplier.
+   */
+  retryMultiplier;
   /**
    * Set target queue.
    */
@@ -940,6 +1592,14 @@ var Job = class {
     this.connectionName = connection;
     return this;
   }
+  /**
+   * Set job priority.
+   * @param priority - 'high', 'low', or number
+   */
+  withPriority(priority) {
+    this.priority = priority;
+    return this;
+  }
   /**
    * Set delay (seconds).
    */
@@ -947,6 +1607,26 @@ var Job = class {
     this.delaySeconds = delay;
     return this;
   }
+  /**
+   * Set retry backoff strategy.
+   * @param seconds - Initial delay in seconds
+   * @param multiplier - Multiplier for each subsequent attempt (default: 2)
+   */
+  backoff(seconds, multiplier = 2) {
+    this.retryAfterSeconds = seconds;
+    this.retryMultiplier = multiplier;
+    return this;
+  }
+  /**
+   * Calculate retry delay for the next attempt.
+   * @param attempt - Current attempt number (1-based)
+   * @returns Delay in milliseconds
+   */
+  getRetryDelay(attempt) {
+    const initialDelay = (this.retryAfterSeconds ?? 1) * 1e3;
+    const multiplier = this.retryMultiplier ?? 2;
+    return Math.min(initialDelay * multiplier ** (attempt - 1), 36e5);
+  }
   /**
    * Failure handler (optional).
    *
@@ -985,7 +1665,7 @@ var ClassNameSerializer = class {
    * Serialize a Job.
    */
   serialize(job) {
-    const id = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const id = job.id || `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
     const className = job.constructor.name;
     const properties = {};
     for (const key in job) {
@@ -1004,7 +1684,11 @@ var ClassNameSerializer = class {
       createdAt: Date.now(),
       ...job.delaySeconds !== void 0 ? { delaySeconds: job.delaySeconds } : {},
       attempts: job.attempts ?? 0,
-      ...job.maxAttempts !== void 0 ? { maxAttempts: job.maxAttempts } : {}
+      ...job.maxAttempts !== void 0 ? { maxAttempts: job.maxAttempts } : {},
+      ...job.groupId ? { groupId: job.groupId } : {},
+      ...job.retryAfterSeconds !== void 0 ? { retryAfterSeconds: job.retryAfterSeconds } : {},
+      ...job.retryMultiplier !== void 0 ? { retryMultiplier: job.retryMultiplier } : {},
+      ...job.priority !== void 0 ? { priority: job.priority } : {}
     };
   }
   /**
@@ -1028,6 +1712,7 @@ var ClassNameSerializer = class {
     if (parsed.properties) {
       Object.assign(job, parsed.properties);
     }
+    job.id = serialized.id;
     if (serialized.delaySeconds !== void 0) {
       job.delaySeconds = serialized.delaySeconds;
     }
@@ -1037,6 +1722,18 @@ var ClassNameSerializer = class {
     if (serialized.maxAttempts !== void 0) {
       job.maxAttempts = serialized.maxAttempts;
     }
+    if (serialized.groupId !== void 0) {
+      job.groupId = serialized.groupId;
+    }
+    if (serialized.retryAfterSeconds !== void 0) {
+      job.retryAfterSeconds = serialized.retryAfterSeconds;
+    }
+    if (serialized.retryMultiplier !== void 0) {
+      job.retryMultiplier = serialized.retryMultiplier;
+    }
+    if (serialized.priority !== void 0) {
+      job.priority = serialized.priority;
+    }
     return job;
   }
 };
@@ -1058,7 +1755,9 @@ var JsonSerializer = class {
       createdAt: Date.now(),
       ...job.delaySeconds !== void 0 ? { delaySeconds: job.delaySeconds } : {},
       attempts: job.attempts ?? 0,
-      ...job.maxAttempts !== void 0 ? { maxAttempts: job.maxAttempts } : {}
+      ...job.maxAttempts !== void 0 ? { maxAttempts: job.maxAttempts } : {},
+      ...job.groupId ? { groupId: job.groupId } : {},
+      ...job.priority ? { priority: job.priority } : {}
     };
   }
   /**
@@ -1074,6 +1773,12 @@ var JsonSerializer = class {
     const parsed = JSON.parse(serialized.data);
     const job = /* @__PURE__ */ Object.create({});
     Object.assign(job, parsed.properties);
+    if (serialized.groupId) {
+      job.groupId = serialized.groupId;
+    }
+    if (serialized.priority) {
+      job.priority = serialized.priority;
+    }
     return job;
   }
 };
@@ -1084,7 +1789,11 @@ var QueueManager = class {
   serializers = /* @__PURE__ */ new Map();
   defaultConnection;
   defaultSerializer;
+  persistence;
+  scheduler;
+  // Using any to avoid circular dependency or import issues for now
   constructor(config = {}) {
+    this.persistence = config.persistence;
     this.defaultConnection = config.default ?? "default";
     const serializerType = config.defaultSerializer ?? "class";
     if (serializerType === "class") {
@@ -1192,9 +1901,30 @@ var QueueManager = class {
         );
         break;
       }
+      case "rabbitmq": {
+        const { RabbitMQDriver: RabbitMQDriver2 } = (init_RabbitMQDriver(), __toCommonJS(RabbitMQDriver_exports));
+        const client = config.client;
+        if (!client) {
+          throw new Error(
+            "[QueueManager] RabbitMQDriver requires client. Please provide RabbitMQ connection/channel in connection config."
+          );
+        }
+        this.drivers.set(
+          name,
+          new RabbitMQDriver2({
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver loading requires type assertion
+            client,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            exchange: config.exchange,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            exchangeType: config.exchangeType
+          })
+        );
+        break;
+      }
       default:
         throw new Error(
-          `Driver "${driverType}" is not supported. Supported drivers: memory, database, redis, kafka, sqs`
+          `Driver "${driverType}" is not supported. Supported drivers: memory, database, redis, kafka, sqs, rabbitmq`
         );
     }
   }
@@ -1210,6 +1940,13 @@ var QueueManager = class {
     }
     return driver;
   }
+  /**
+   * Get the default connection name.
+   * @returns Default connection name
+   */
+  getDefaultConnection() {
+    return this.defaultConnection;
+  }
   /**
    * Get a serializer.
    * @param type - Serializer type
@@ -1239,6 +1976,7 @@ var QueueManager = class {
    *
    * @template T - The type of the job.
    * @param job - Job instance to push.
+   * @param options - Push options.
    * @returns The same job instance (for fluent chaining).
    *
    * @example
@@ -1246,13 +1984,22 @@ var QueueManager = class {
    * await manager.push(new SendEmailJob('user@example.com'));
    * ```
    */
-  async push(job) {
+  async push(job, options) {
     const connection = job.connectionName ?? this.defaultConnection;
     const queue = job.queueName ?? "default";
     const driver = this.getDriver(connection);
     const serializer = this.getSerializer();
     const serialized = serializer.serialize(job);
-    await driver.push(queue, serialized);
+    const pushOptions = { ...options };
+    if (job.priority) {
+      pushOptions.priority = job.priority;
+    }
+    await driver.push(queue, serialized, pushOptions);
+    if (this.persistence?.archiveEnqueued) {
+      this.persistence.adapter.archive(queue, serialized, "waiting").catch((err) => {
+        console.error("[QueueManager] Persistence archive failed (waiting):", err);
+      });
+    }
     return job;
   }
   /**
@@ -1345,6 +2092,92 @@ var QueueManager = class {
     const driver = this.getDriver(connection);
     await driver.clear(queue);
   }
+  /**
+   * Mark a job as completed.
+   * @param job - Job instance
+   */
+  async complete(job) {
+    const connection = job.connectionName ?? this.defaultConnection;
+    const queue = job.queueName ?? "default";
+    const driver = this.getDriver(connection);
+    const serializer = this.getSerializer();
+    if (driver.complete) {
+      const serialized = serializer.serialize(job);
+      await driver.complete(queue, serialized);
+      if (this.persistence?.archiveCompleted) {
+        await this.persistence.adapter.archive(queue, serialized, "completed").catch((err) => {
+          console.error("[QueueManager] Persistence archive failed (completed):", err);
+        });
+      }
+    }
+  }
+  /**
+   * Mark a job as permanently failed.
+   * @param job - Job instance
+   * @param error - Error object
+   */
+  async fail(job, error) {
+    const connection = job.connectionName ?? this.defaultConnection;
+    const queue = job.queueName ?? "default";
+    const driver = this.getDriver(connection);
+    const serializer = this.getSerializer();
+    if (driver.fail) {
+      const serialized = serializer.serialize(job);
+      serialized.error = error.message;
+      serialized.failedAt = Date.now();
+      await driver.fail(queue, serialized);
+      if (this.persistence?.archiveFailed) {
+        await this.persistence.adapter.archive(queue, serialized, "failed").catch((err) => {
+          console.error("[QueueManager] Persistence archive failed (failed):", err);
+        });
+      }
+    }
+  }
+  /**
+   * Get the persistence adapter if configured.
+   */
+  getPersistence() {
+    return this.persistence?.adapter;
+  }
+  /**
+   * Get the scheduler if configured.
+   */
+  getScheduler() {
+    if (!this.scheduler) {
+      const { Scheduler: Scheduler2 } = (init_Scheduler(), __toCommonJS(Scheduler_exports));
+      this.scheduler = new Scheduler2(this);
+    }
+    return this.scheduler;
+  }
+  /**
+   * Get failed jobs from DLQ (if driver supports it).
+   */
+  async getFailed(queue, start = 0, end = -1, connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    if (driver.getFailed) {
+      return driver.getFailed(queue, start, end);
+    }
+    return [];
+  }
+  /**
+   * Retry failed jobs from DLQ (if driver supports it).
+   */
+  async retryFailed(queue, count = 1, connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    if (driver.retryFailed) {
+      return driver.retryFailed(queue, count);
+    }
+    return 0;
+  }
+  /**
+   * Clear failed jobs from DLQ (if driver supports it).
+   */
+  async clearFailed(queue, connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    if (driver.clearFailed) {
+      await driver.clearFailed(queue);
+    }
+  }
 };
 
 // src/OrbitStream.ts
@@ -1425,6 +2258,453 @@ var OrbitStream = class _OrbitStream {
     return this.queueManager;
   }
 };
+
+// src/persistence/MySQLPersistence.ts
+var import_atlas = require("@gravito/atlas");
+var MySQLPersistence = class {
+  /**
+   * @param db - An Atlas DB instance or compatible QueryBuilder.
+   * @param table - The name of the table to store archived jobs.
+   */
+  constructor(db, table = "flux_job_archive", logsTable = "flux_system_logs") {
+    this.db = db;
+    this.table = table;
+    this.logsTable = logsTable;
+  }
+  /**
+   * Archive a job.
+   */
+  async archive(queue, job, status) {
+    try {
+      await this.db.table(this.table).insert({
+        job_id: job.id,
+        queue,
+        status,
+        payload: JSON.stringify(job),
+        error: job.error || null,
+        created_at: new Date(job.createdAt),
+        archived_at: /* @__PURE__ */ new Date()
+      });
+    } catch (err) {
+      console.error(`[MySQLPersistence] Failed to archive job ${job.id}:`, err);
+    }
+  }
+  /**
+   * Find a specific job in the archive.
+   */
+  async find(queue, id) {
+    const row = await this.db.table(this.table).where("queue", queue).where("job_id", id).first();
+    if (!row) {
+      return null;
+    }
+    try {
+      const job = typeof row.payload === "string" ? JSON.parse(row.payload) : row.payload;
+      return job;
+    } catch (_e) {
+      return null;
+    }
+  }
+  /**
+   * List jobs from the archive.
+   */
+  async list(queue, options = {}) {
+    let query = this.db.table(this.table).where("queue", queue);
+    if (options.status) {
+      query = query.where("status", options.status);
+    }
+    if (options.jobId) {
+      query = query.where("job_id", options.jobId);
+    }
+    if (options.startTime) {
+      query = query.where("archived_at", ">=", options.startTime);
+    }
+    if (options.endTime) {
+      query = query.where("archived_at", "<=", options.endTime);
+    }
+    const rows = await query.orderBy("archived_at", "desc").limit(options.limit ?? 50).offset(options.offset ?? 0).get();
+    return rows.map((r) => {
+      try {
+        const job = typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload;
+        return { ...job, _status: r.status, _archivedAt: r.archived_at };
+      } catch (_e) {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+  /**
+   * Search jobs from the archive.
+   */
+  async search(query, options = {}) {
+    let q = this.db.table(this.table);
+    if (options.queue) {
+      q = q.where("queue", options.queue);
+    }
+    const rows = await q.where((sub) => {
+      sub.where("job_id", "like", `%${query}%`).orWhere("payload", "like", `%${query}%`).orWhere("error", "like", `%${query}%`);
+    }).orderBy("archived_at", "desc").limit(options.limit ?? 50).offset(options.offset ?? 0).get();
+    return rows.map((r) => {
+      try {
+        const job = typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload;
+        return { ...job, _status: r.status, _archivedAt: r.archived_at };
+      } catch (_e) {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+  /**
+   * Archive a system log message.
+   */
+  async archiveLog(log) {
+    try {
+      await this.db.table(this.logsTable).insert({
+        level: log.level,
+        message: log.message,
+        worker_id: log.workerId,
+        queue: log.queue || null,
+        timestamp: log.timestamp
+      });
+    } catch (err) {
+      console.error(`[MySQLPersistence] Failed to archive log:`, err.message);
+    }
+  }
+  /**
+   * List system logs from the archive.
+   */
+  async listLogs(options = {}) {
+    let query = this.db.table(this.logsTable);
+    if (options.level) query = query.where("level", options.level);
+    if (options.workerId) query = query.where("worker_id", options.workerId);
+    if (options.queue) query = query.where("queue", options.queue);
+    if (options.search) {
+      query = query.where("message", "like", `%${options.search}%`);
+    }
+    if (options.startTime) {
+      query = query.where("timestamp", ">=", options.startTime);
+    }
+    if (options.endTime) {
+      query = query.where("timestamp", "<=", options.endTime);
+    }
+    return await query.orderBy("timestamp", "desc").limit(options.limit ?? 50).offset(options.offset ?? 0).get();
+  }
+  /**
+   * Count system logs in the archive.
+   */
+  async countLogs(options = {}) {
+    let query = this.db.table(this.logsTable);
+    if (options.level) query = query.where("level", options.level);
+    if (options.workerId) query = query.where("worker_id", options.workerId);
+    if (options.queue) query = query.where("queue", options.queue);
+    if (options.search) {
+      query = query.where("message", "like", `%${options.search}%`);
+    }
+    if (options.startTime) {
+      query = query.where("timestamp", ">=", options.startTime);
+    }
+    if (options.endTime) {
+      query = query.where("timestamp", "<=", options.endTime);
+    }
+    const result = await query.count("id as total").first();
+    return result?.total || 0;
+  }
+  /**
+   * Remove old records from the archive.
+   */
+  async cleanup(days) {
+    const threshold = /* @__PURE__ */ new Date();
+    threshold.setDate(threshold.getDate() - days);
+    const [jobsDeleted, logsDeleted] = await Promise.all([
+      this.db.table(this.table).where("archived_at", "<", threshold).delete(),
+      this.db.table(this.logsTable).where("timestamp", "<", threshold).delete()
+    ]);
+    return (jobsDeleted || 0) + (logsDeleted || 0);
+  }
+  /**
+   * Count jobs in the archive.
+   */
+  async count(queue, options = {}) {
+    let query = this.db.table(this.table).where("queue", queue);
+    if (options.status) {
+      query = query.where("status", options.status);
+    }
+    if (options.jobId) {
+      query = query.where("job_id", options.jobId);
+    }
+    if (options.startTime) {
+      query = query.where("archived_at", ">=", options.startTime);
+    }
+    if (options.endTime) {
+      query = query.where("archived_at", "<=", options.endTime);
+    }
+    const result = await query.count("id as total").first();
+    return result?.total || 0;
+  }
+  /**
+   * Help script to create the necessary table.
+   */
+  async setupTable() {
+    await Promise.all([this.setupJobsTable(), this.setupLogsTable()]);
+  }
+  async setupJobsTable() {
+    const exists = await import_atlas.Schema.hasTable(this.table);
+    if (exists) return;
+    await import_atlas.Schema.create(this.table, (table) => {
+      table.id();
+      table.string("job_id", 64);
+      table.string("queue", 128);
+      table.string("status", 20);
+      table.json("payload");
+      table.text("error").nullable();
+      table.timestamp("created_at").nullable();
+      table.timestamp("archived_at").default(import_atlas.DB.raw("CURRENT_TIMESTAMP"));
+      table.index(["queue", "archived_at"]);
+      table.index(["queue", "job_id"]);
+      table.index(["status", "archived_at"]);
+      table.index(["archived_at"]);
+    });
+    console.log(`[MySQLPersistence] Created jobs archive table: ${this.table}`);
+  }
+  async setupLogsTable() {
+    const exists = await import_atlas.Schema.hasTable(this.logsTable);
+    if (exists) return;
+    await import_atlas.Schema.create(this.logsTable, (table) => {
+      table.id();
+      table.string("level", 20);
+      table.text("message");
+      table.string("worker_id", 128);
+      table.string("queue", 128).nullable();
+      table.timestamp("timestamp").default(import_atlas.DB.raw("CURRENT_TIMESTAMP"));
+      table.index(["worker_id"]);
+      table.index(["queue"]);
+      table.index(["level"]);
+      table.index(["timestamp"]);
+    });
+    console.log(`[MySQLPersistence] Created logs archive table: ${this.logsTable}`);
+  }
+};
+
+// src/persistence/SQLitePersistence.ts
+var import_atlas2 = require("@gravito/atlas");
+var SQLitePersistence = class {
+  /**
+   * @param db - An Atlas DB instance (SQLite driver).
+   * @param table - The name of the table to store archived jobs.
+   */
+  constructor(db, table = "flux_job_archive", logsTable = "flux_system_logs") {
+    this.db = db;
+    this.table = table;
+    this.logsTable = logsTable;
+  }
+  /**
+   * Archive a job.
+   */
+  async archive(queue, job, status) {
+    try {
+      await this.db.table(this.table).insert({
+        job_id: job.id,
+        queue,
+        status,
+        payload: JSON.stringify(job),
+        error: job.error || null,
+        created_at: new Date(job.createdAt),
+        archived_at: /* @__PURE__ */ new Date()
+      });
+    } catch (err) {
+      console.error(`[SQLitePersistence] Failed to archive job ${job.id}:`, err.message);
+    }
+  }
+  /**
+   * Find a specific job in the archive.
+   */
+  async find(queue, id) {
+    const row = await this.db.table(this.table).where("queue", queue).where("job_id", id).first();
+    if (!row) {
+      return null;
+    }
+    try {
+      const job = typeof row.payload === "string" ? JSON.parse(row.payload) : row.payload;
+      return job;
+    } catch (_e) {
+      return null;
+    }
+  }
+  /**
+   * List jobs from the archive.
+   */
+  async list(queue, options = {}) {
+    let query = this.db.table(this.table).where("queue", queue);
+    if (options.status) {
+      query = query.where("status", options.status);
+    }
+    if (options.jobId) {
+      query = query.where("job_id", options.jobId);
+    }
+    if (options.startTime) {
+      query = query.where("archived_at", ">=", options.startTime);
+    }
+    if (options.endTime) {
+      query = query.where("archived_at", "<=", options.endTime);
+    }
+    const rows = await query.orderBy("archived_at", "desc").limit(options.limit ?? 50).offset(options.offset ?? 0).get();
+    return rows.map((r) => {
+      try {
+        const job = typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload;
+        return { ...job, _status: r.status, _archivedAt: r.archived_at };
+      } catch (_e) {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+  /**
+   * Search jobs from the archive.
+   */
+  async search(query, options = {}) {
+    let q = this.db.table(this.table);
+    if (options.queue) {
+      q = q.where("queue", options.queue);
+    }
+    const rows = await q.where((sub) => {
+      sub.where("job_id", "like", `%${query}%`).orWhere("payload", "like", `%${query}%`).orWhere("error", "like", `%${query}%`);
+    }).orderBy("archived_at", "desc").limit(options.limit ?? 50).offset(options.offset ?? 0).get();
+    return rows.map((r) => {
+      try {
+        const job = typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload;
+        return { ...job, _status: r.status, _archivedAt: r.archived_at };
+      } catch (_e) {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+  /**
+   * Archive a system log message.
+   */
+  async archiveLog(log) {
+    try {
+      await this.db.table(this.logsTable).insert({
+        level: log.level,
+        message: log.message,
+        worker_id: log.workerId,
+        queue: log.queue || null,
+        timestamp: log.timestamp
+      });
+    } catch (err) {
+      console.error(`[SQLitePersistence] Failed to archive log:`, err.message);
+    }
+  }
+  /**
+   * List system logs from the archive.
+   */
+  async listLogs(options = {}) {
+    let query = this.db.table(this.logsTable);
+    if (options.level) query = query.where("level", options.level);
+    if (options.workerId) query = query.where("worker_id", options.workerId);
+    if (options.queue) query = query.where("queue", options.queue);
+    if (options.search) {
+      query = query.where("message", "like", `%${options.search}%`);
+    }
+    if (options.startTime) {
+      query = query.where("timestamp", ">=", options.startTime);
+    }
+    if (options.endTime) {
+      query = query.where("timestamp", "<=", options.endTime);
+    }
+    return await query.orderBy("timestamp", "desc").limit(options.limit ?? 50).offset(options.offset ?? 0).get();
+  }
+  /**
+   * Count system logs in the archive.
+   */
+  async countLogs(options = {}) {
+    let query = this.db.table(this.logsTable);
+    if (options.level) query = query.where("level", options.level);
+    if (options.workerId) query = query.where("worker_id", options.workerId);
+    if (options.queue) query = query.where("queue", options.queue);
+    if (options.search) {
+      query = query.where("message", "like", `%${options.search}%`);
+    }
+    if (options.startTime) {
+      query = query.where("timestamp", ">=", options.startTime);
+    }
+    if (options.endTime) {
+      query = query.where("timestamp", "<=", options.endTime);
+    }
+    const result = await query.count("id as total").first();
+    return result?.total || 0;
+  }
+  /**
+   * Remove old records from the archive.
+   */
+  async cleanup(days) {
+    const threshold = /* @__PURE__ */ new Date();
+    threshold.setDate(threshold.getDate() - days);
+    const [jobsDeleted, logsDeleted] = await Promise.all([
+      this.db.table(this.table).where("archived_at", "<", threshold).delete(),
+      this.db.table(this.logsTable).where("timestamp", "<", threshold).delete()
+    ]);
+    return (jobsDeleted || 0) + (logsDeleted || 0);
+  }
+  /**
+   * Count jobs in the archive.
+   */
+  async count(queue, options = {}) {
+    let query = this.db.table(this.table).where("queue", queue);
+    if (options.status) {
+      query = query.where("status", options.status);
+    }
+    if (options.jobId) {
+      query = query.where("job_id", options.jobId);
+    }
+    if (options.startTime) {
+      query = query.where("archived_at", ">=", options.startTime);
+    }
+    if (options.endTime) {
+      query = query.where("archived_at", "<=", options.endTime);
+    }
+    const result = await query.count("id as total").first();
+    return result?.total || 0;
+  }
+  /**
+   * Setup table for SQLite.
+   */
+  async setupTable() {
+    await Promise.all([this.setupJobsTable(), this.setupLogsTable()]);
+  }
+  async setupJobsTable() {
+    const exists = await import_atlas2.Schema.hasTable(this.table);
+    if (exists) return;
+    await import_atlas2.Schema.create(this.table, (table) => {
+      table.id();
+      table.string("job_id", 64);
+      table.string("queue", 128);
+      table.string("status", 20);
+      table.text("payload");
+      table.text("error").nullable();
+      table.timestamp("created_at").nullable();
+      table.timestamp("archived_at").nullable();
+      table.index(["queue", "archived_at"]);
+      table.index(["archived_at"]);
+    });
+    console.log(`[SQLitePersistence] Created jobs archive table: ${this.table}`);
+  }
+  async setupLogsTable() {
+    const exists = await import_atlas2.Schema.hasTable(this.logsTable);
+    if (exists) return;
+    await import_atlas2.Schema.create(this.logsTable, (table) => {
+      table.id();
+      table.string("level", 20);
+      table.text("message");
+      table.string("worker_id", 128);
+      table.string("queue", 128).nullable();
+      table.timestamp("timestamp");
+      table.index(["worker_id"]);
+      table.index(["queue"]);
+      table.index(["level"]);
+      table.index(["timestamp"]);
+    });
+    console.log(`[SQLitePersistence] Created logs archive table: ${this.logsTable}`);
+  }
+};
+
+// src/index.ts
+init_Scheduler();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ClassNameSerializer,
@@ -1434,9 +2714,13 @@ var OrbitStream = class _OrbitStream {
   JsonSerializer,
   KafkaDriver,
   MemoryDriver,
+  MySQLPersistence,
   OrbitStream,
   QueueManager,
+  RabbitMQDriver,
   RedisDriver,
+  SQLitePersistence,
   SQSDriver,
+  Scheduler,
   Worker
 });