@gravito/stream 1.0.0-alpha.6 → 1.0.0-beta.2

package/dist/index.js

@@ -0,0 +1,2700 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/drivers/DatabaseDriver.ts
+var DatabaseDriver_exports = {};
+__export(DatabaseDriver_exports, {
+  DatabaseDriver: () => DatabaseDriver
+});
+var DatabaseDriver;
+var init_DatabaseDriver = __esm({
+  "src/drivers/DatabaseDriver.ts"() {
+    "use strict";
+    DatabaseDriver = class {
+      tableName;
+      dbService;
+      constructor(config) {
+        this.tableName = config.table ?? "jobs";
+        this.dbService = config.dbService;
+        if (!this.dbService) {
+          throw new Error(
+            "[DatabaseDriver] dbService is required. Please provide a database service that implements DatabaseService interface."
+          );
+        }
+      }
+      /**
+       * Push a job to a queue.
+       */
+      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, payload, job.attempts ?? 0, availableAt.toISOString(), (/* @__PURE__ */ new Date()).toISOString()]
+        );
+      }
+      /**
+       * Pop a job from the queue (FIFO, with delay support).
+       */
+      async pop(queue) {
+        const result = await this.dbService.execute(
+          `SELECT id, payload, attempts, created_at, available_at
+       FROM ${this.tableName}
+       WHERE queue = $1
+         AND available_at <= NOW()
+         AND (reserved_at IS NULL OR reserved_at < NOW() - INTERVAL '5 minutes')
+       ORDER BY created_at ASC
+       LIMIT 1
+       FOR UPDATE SKIP LOCKED`,
+          [queue]
+        ).catch(() => {
+          return this.dbService.execute(
+            `SELECT id, payload, attempts, created_at, available_at
+         FROM ${this.tableName}
+         WHERE queue = $1
+           AND available_at <= NOW()
+           AND (reserved_at IS NULL OR reserved_at < NOW() - INTERVAL '5 minutes')
+         ORDER BY created_at ASC
+         LIMIT 1
+         FOR UPDATE`,
+            [queue]
+          );
+        });
+        const rows = result;
+        if (!rows || rows.length === 0) {
+          return null;
+        }
+        const row = rows[0];
+        await this.dbService.execute(
+          `UPDATE ${this.tableName}
+       SET reserved_at = NOW()
+       WHERE id = $1`,
+          [row.id]
+        );
+        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;
+        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.
+       */
+      async size(queue) {
+        const result = await this.dbService.execute(
+          `SELECT COUNT(*) as count
+       FROM ${this.tableName}
+       WHERE queue = $1
+         AND available_at <= NOW()
+         AND (reserved_at IS NULL OR reserved_at < NOW() - INTERVAL '5 minutes')`,
+          [queue]
+        );
+        return result?.[0]?.count ?? 0;
+      }
+      /**
+       * Clear a queue.
+       */
+      async clear(queue) {
+        await this.dbService.execute(`DELETE FROM ${this.tableName} WHERE queue = $1`, [queue]);
+      }
+      /**
+       * Push multiple jobs.
+       */
+      async pushMany(queue, jobs) {
+        if (jobs.length === 0) {
+          return;
+        }
+        await this.dbService.transaction(async (tx) => {
+          for (const job of jobs) {
+            const availableAt = job.delaySeconds ? new Date(Date.now() + job.delaySeconds * 1e3) : /* @__PURE__ */ new Date();
+            await tx.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()]
+            );
+          }
+        });
+      }
+      /**
+       * 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]);
+      }
+    };
+  }
+});
+
+// src/drivers/KafkaDriver.ts
+var KafkaDriver_exports = {};
+__export(KafkaDriver_exports, {
+  KafkaDriver: () => KafkaDriver
+});
+var KafkaDriver;
+var init_KafkaDriver = __esm({
+  "src/drivers/KafkaDriver.ts"() {
+    "use strict";
+    KafkaDriver = class {
+      client;
+      consumerGroupId;
+      producer;
+      admin;
+      constructor(config) {
+        this.client = config.client;
+        this.consumerGroupId = config.consumerGroupId ?? "gravito-workers";
+        if (!this.client) {
+          throw new Error("[KafkaDriver] Kafka client is required. Please install kafkajs package.");
+        }
+      }
+      /**
+       * Ensure the producer is connected.
+       */
+      async ensureProducer() {
+        if (!this.producer) {
+          this.producer = this.client.producer();
+          await this.producer.connect();
+        }
+        return this.producer;
+      }
+      /**
+       * Ensure the admin client is connected.
+       */
+      async ensureAdmin() {
+        if (!this.admin) {
+          this.admin = this.client.admin();
+          await this.admin.connect();
+        }
+        return this.admin;
+      }
+      /**
+       * Push a job to a topic.
+       */
+      async push(queue, job) {
+        const producer = await this.ensureProducer();
+        const payload = JSON.stringify({
+          id: job.id,
+          type: job.type,
+          data: job.data,
+          className: job.className,
+          createdAt: job.createdAt,
+          delaySeconds: job.delaySeconds,
+          attempts: job.attempts,
+          maxAttempts: job.maxAttempts
+        });
+        await producer.send({
+          topic: queue,
+          messages: [
+            {
+              key: job.id,
+              value: payload
+            }
+          ]
+        });
+      }
+      /**
+       * Pop is not supported for Kafka.
+       *
+       * Note: Kafka uses a push-based model, so you should use `subscribe()`.
+       */
+      async pop(_queue) {
+        throw new Error("[KafkaDriver] Kafka uses push-based model. Use subscribe() instead of pop().");
+      }
+      /**
+       * Kafka does not provide a direct queue size.
+       *
+       * Returns 0; use Kafka tooling/metrics for lag/size insights.
+       */
+      async size(_queue) {
+        return 0;
+      }
+      /**
+       * Clear a queue by deleting the topic.
+       */
+      async clear(queue) {
+        const admin = await this.ensureAdmin();
+        await admin.deleteTopics({ topics: [queue] });
+      }
+      /**
+       * Push multiple jobs.
+       */
+      async pushMany(queue, jobs) {
+        if (jobs.length === 0) {
+          return;
+        }
+        const producer = await this.ensureProducer();
+        const messages = jobs.map((job) => {
+          const payload = JSON.stringify({
+            id: job.id,
+            type: job.type,
+            data: job.data,
+            className: job.className,
+            createdAt: job.createdAt,
+            delaySeconds: job.delaySeconds,
+            attempts: job.attempts,
+            maxAttempts: job.maxAttempts
+          });
+          return {
+            key: job.id,
+            value: payload
+          };
+        });
+        await producer.send({
+          topic: queue,
+          messages
+        });
+      }
+      /**
+       * Create a topic.
+       */
+      async createTopic(topic, options) {
+        const admin = await this.ensureAdmin();
+        await admin.createTopics({
+          topics: [
+            {
+              topic,
+              numPartitions: options?.partitions ?? 1,
+              replicationFactor: options?.replicationFactor ?? 1
+            }
+          ]
+        });
+      }
+      /**
+       * Delete a topic.
+       */
+      async deleteTopic(topic) {
+        await this.clear(topic);
+      }
+      /**
+       * Subscribe to a topic (push-based model).
+       */
+      async subscribe(queue, callback) {
+        const consumer = this.client.consumer({ groupId: this.consumerGroupId });
+        await consumer.connect();
+        await consumer.subscribe({ topics: [queue] });
+        await consumer.run({
+          eachMessage: async ({ message }) => {
+            if (!message.value) {
+              return;
+            }
+            const payload = JSON.parse(message.value.toString());
+            const job = {
+              id: payload.id,
+              type: payload.type,
+              data: payload.data,
+              className: payload.className,
+              createdAt: payload.createdAt,
+              delaySeconds: payload.delaySeconds,
+              attempts: payload.attempts,
+              maxAttempts: payload.maxAttempts
+            };
+            try {
+              await callback(job);
+            } catch (error) {
+              console.error("[KafkaDriver] Error processing message:", error);
+            }
+          }
+        });
+      }
+    };
+  }
+});
+
+// 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, {
+  RedisDriver: () => RedisDriver
+});
+var RedisDriver;
+var init_RedisDriver = __esm({
+  "src/drivers/RedisDriver.ts"() {
+    "use strict";
+    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:";
+        if (!this.client) {
+          throw new Error(
+            "[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, priority) {
+        if (priority) {
+          return `${this.prefix}${queue}:${priority}`;
+        }
+        return `${this.prefix}${queue}`;
+      }
+      /**
+       * Push a job (LPUSH).
+       */
+      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,
+          className: job.className,
+          createdAt: job.createdAt,
+          delaySeconds: job.delaySeconds,
+          attempts: job.attempts,
+          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;
+          if (typeof this.client.zadd === "function") {
+            await this.client.zadd(delayKey, score, payload);
+          } else {
+            await this.client.lpush(key, payload);
+          }
+        } else {
+          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 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);
+          }
+        }
+        return null;
+      }
+      /**
+       * Parse Redis payload.
+       */
+      parsePayload(payload) {
+        const parsed = JSON.parse(payload);
+        return {
+          id: parsed.id,
+          type: parsed.type,
+          data: parsed.data,
+          className: parsed.className,
+          createdAt: parsed.createdAt,
+          delaySeconds: parsed.delaySeconds,
+          attempts: parsed.attempts,
+          maxAttempts: parsed.maxAttempts,
+          groupId: parsed.groupId,
+          error: parsed.error,
+          failedAt: parsed.failedAt,
+          priority: parsed.priority
+        };
+      }
+      /**
+       * Get queue size.
+       */
+      async size(queue) {
+        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);
+        }
+      }
+      /**
+       * Push multiple jobs.
+       */
+      async pushMany(queue, jobs) {
+        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({
+            id: job.id,
+            type: job.type,
+            data: job.data,
+            className: job.className,
+            createdAt: job.createdAt,
+            delaySeconds: job.delaySeconds,
+            attempts: job.attempts,
+            maxAttempts: job.maxAttempts,
+            groupId: job.groupId,
+            priority: job.priority
+          })
+        );
+        await this.client.lpush(key, ...payloads);
+      }
+      /**
+       * Pop multiple jobs.
+       */
+      async popMany(queue, count) {
+        const key = this.getKey(queue);
+        const results = [];
+        for (let i = 0; i < count; i++) {
+          const payload = await this.client.rpop(key);
+          if (payload) {
+            results.push(this.parsePayload(payload));
+          } else {
+            break;
+          }
+        }
+        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`;
+        const queueKey = this.getKey(queue);
+        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);
+      }
+    };
+  }
+});
+
+// src/drivers/SQSDriver.ts
+var SQSDriver_exports = {};
+__export(SQSDriver_exports, {
+  SQSDriver: () => SQSDriver
+});
+var SQSDriver;
+var init_SQSDriver = __esm({
+  "src/drivers/SQSDriver.ts"() {
+    "use strict";
+    SQSDriver = class {
+      client;
+      queueUrlPrefix;
+      visibilityTimeout;
+      waitTimeSeconds;
+      queueUrls = /* @__PURE__ */ new Map();
+      constructor(config) {
+        this.client = config.client;
+        this.queueUrlPrefix = config.queueUrlPrefix ?? "";
+        this.visibilityTimeout = config.visibilityTimeout ?? 30;
+        this.waitTimeSeconds = config.waitTimeSeconds ?? 20;
+        if (!this.client) {
+          throw new Error(
+            "[SQSDriver] SQS client is required. Please install @aws-sdk/client-sqs package."
+          );
+        }
+      }
+      /**
+       * Resolve the full queue URL.
+       */
+      async getQueueUrl(queue) {
+        if (this.queueUrls.has(queue)) {
+          return this.queueUrls.get(queue);
+        }
+        if (this.queueUrlPrefix) {
+          const url = `${this.queueUrlPrefix}/${queue}`;
+          this.queueUrls.set(queue, url);
+          return url;
+        }
+        this.queueUrls.set(queue, queue);
+        return queue;
+      }
+      /**
+       * Push a job to SQS.
+       */
+      async push(queue, job) {
+        const { SendMessageCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        const payload = JSON.stringify({
+          id: job.id,
+          type: job.type,
+          data: job.data,
+          className: job.className,
+          createdAt: job.createdAt,
+          delaySeconds: job.delaySeconds,
+          attempts: job.attempts,
+          maxAttempts: job.maxAttempts
+        });
+        const delaySeconds = job.delaySeconds ? Math.min(job.delaySeconds, 900) : 0;
+        await this.client.send(
+          new SendMessageCommand({
+            QueueUrl: queueUrl,
+            MessageBody: payload,
+            DelaySeconds: delaySeconds
+          })
+        );
+      }
+      /**
+       * Pop a job (long polling).
+       */
+      async pop(queue) {
+        const { ReceiveMessageCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        const response = await this.client.send(
+          new ReceiveMessageCommand({
+            QueueUrl: queueUrl,
+            MaxNumberOfMessages: 1,
+            WaitTimeSeconds: this.waitTimeSeconds,
+            VisibilityTimeout: this.visibilityTimeout
+          })
+        );
+        if (!response.Messages || response.Messages.length === 0) {
+          return null;
+        }
+        const message = response.Messages[0];
+        const payload = JSON.parse(message.Body ?? "{}");
+        return {
+          id: payload.id ?? message.MessageId,
+          type: payload.type,
+          data: payload.data,
+          className: payload.className,
+          createdAt: payload.createdAt,
+          delaySeconds: payload.delaySeconds,
+          attempts: payload.attempts,
+          maxAttempts: payload.maxAttempts,
+          // Store ReceiptHandle for acknowledgement
+          ...message.ReceiptHandle && { receiptHandle: message.ReceiptHandle }
+        };
+      }
+      /**
+       * Get queue size (approximate).
+       */
+      async size(queue) {
+        const { GetQueueAttributesCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        try {
+          const response = await this.client.send(
+            new GetQueueAttributesCommand({
+              QueueUrl: queueUrl,
+              AttributeNames: ["ApproximateNumberOfMessages"]
+            })
+          );
+          return parseInt(response.Attributes?.ApproximateNumberOfMessages ?? "0", 10);
+        } catch (error) {
+          console.error("[SQSDriver] Error getting queue size:", error);
+          return 0;
+        }
+      }
+      /**
+       * Clear a queue by receiving and deleting messages.
+       *
+       * Note: SQS does not provide a direct "purge" API via this wrapper. This method will
+       * keep receiving and deleting messages until the queue is empty.
+       */
+      async clear(queue) {
+        const { DeleteMessageCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        while (true) {
+          const job = await this.pop(queue);
+          if (!job) {
+            break;
+          }
+          if (job.receiptHandle) {
+            await this.client.send(
+              new DeleteMessageCommand({
+                QueueUrl: queueUrl,
+                ReceiptHandle: job.receiptHandle
+              })
+            );
+          }
+        }
+      }
+      /**
+       * Push multiple jobs.
+       */
+      async pushMany(queue, jobs) {
+        if (jobs.length === 0) {
+          return;
+        }
+        const { SendMessageBatchCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        const batchSize = 10;
+        for (let i = 0; i < jobs.length; i += batchSize) {
+          const batch = jobs.slice(i, i + batchSize);
+          const entries = batch.map((job, index) => {
+            const payload = JSON.stringify({
+              id: job.id,
+              type: job.type,
+              data: job.data,
+              className: job.className,
+              createdAt: job.createdAt,
+              delaySeconds: job.delaySeconds,
+              attempts: job.attempts,
+              maxAttempts: job.maxAttempts
+            });
+            return {
+              Id: `${job.id}-${index}`,
+              MessageBody: payload,
+              DelaySeconds: job.delaySeconds ? Math.min(job.delaySeconds, 900) : 0
+            };
+          });
+          await this.client.send(
+            new SendMessageBatchCommand({
+              QueueUrl: queueUrl,
+              Entries: entries
+            })
+          );
+        }
+      }
+      /**
+       * Acknowledge is not supported via messageId.
+       */
+      async acknowledge(_messageId) {
+        throw new Error("[SQSDriver] Use deleteMessage() with ReceiptHandle instead of acknowledge().");
+      }
+      /**
+       * Delete a message (acknowledge processing completion).
+       */
+      async deleteMessage(queue, receiptHandle) {
+        const { DeleteMessageCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        await this.client.send(
+          new DeleteMessageCommand({
+            QueueUrl: queueUrl,
+            ReceiptHandle: receiptHandle
+          })
+        );
+      }
+    };
+  }
+});
+
+// src/Scheduler.ts
+var Scheduler_exports = {};
+__export(Scheduler_exports, {
+  Scheduler: () => Scheduler
+});
+import parser from "cron-parser";
+var Scheduler;
+var init_Scheduler = __esm({
+  "src/Scheduler.ts"() {
+    "use strict";
+    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 = parser.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;
+        const serializer = this.manager.getSerializer();
+        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 = parser.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/Worker.ts
+var Worker = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Process a Job.
+   * @param job - Job instance
+   */
+  async process(job) {
+    const maxAttempts = job.maxAttempts ?? this.options.maxAttempts ?? 3;
+    const timeout = this.options.timeout;
+    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();
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (job.attempts >= maxAttempts) {
+        await this.handleFailure(job, err);
+      }
+      throw err;
+    }
+  }
+  /**
+   * Handle failure.
+   */
+  async handleFailure(job, error) {
+    try {
+      await job.failed(error);
+    } catch (failedError) {
+      console.error("[Worker] Error in job.failed():", failedError);
+    }
+    if (this.options.onFailed) {
+      try {
+        await this.options.onFailed(job, error);
+      } catch (callbackError) {
+        console.error("[Worker] Error in onFailed callback:", callbackError);
+      }
+    }
+  }
+};
+
+// src/Consumer.ts
+var Consumer = class {
+  constructor(queueManager, options) {
+    this.queueManager = queueManager;
+    this.options = options;
+  }
+  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.
+   */
+  async start() {
+    if (this.running) {
+      throw new Error("Consumer is already running");
+    }
+    this.running = true;
+    this.stopRequested = false;
+    const worker = new Worker(this.options.workerOptions);
+    const pollInterval = this.options.pollInterval ?? 1e3;
+    const keepAlive = this.options.keepAlive ?? true;
+    console.log("[Consumer] Started", {
+      queues: this.options.queues,
+      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;
+            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);
+        }
+      }
+      if (!processed && !keepAlive) {
+        break;
+      }
+      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).
+   */
+  async stop() {
+    console.log("[Consumer] Stopping...");
+    this.stopRequested = true;
+    while (this.running) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  /**
+   * Check whether the consumer is running.
+   */
+  isRunning() {
+    return this.running;
+  }
+};
+
+// src/index.ts
+init_DatabaseDriver();
+init_KafkaDriver();
+
+// src/drivers/MemoryDriver.ts
+var MemoryDriver = class {
+  queues = /* @__PURE__ */ new Map();
+  /**
+   * Push a job to a queue.
+   */
+  async push(queue, job) {
+    if (!this.queues.has(queue)) {
+      this.queues.set(queue, []);
+    }
+    this.queues.get(queue)?.push(job);
+  }
+  /**
+   * Pop a job from a queue (FIFO).
+   */
+  async pop(queue) {
+    const queueJobs = this.queues.get(queue);
+    if (!queueJobs || queueJobs.length === 0) {
+      return null;
+    }
+    const now = Date.now();
+    const availableIndex = queueJobs.findIndex(
+      (job) => !job.delaySeconds || now >= job.createdAt + job.delaySeconds * 1e3
+    );
+    if (availableIndex === -1) {
+      return null;
+    }
+    return queueJobs.splice(availableIndex, 1)[0];
+  }
+  /**
+   * Get queue size.
+   */
+  async size(queue) {
+    return this.queues.get(queue)?.length ?? 0;
+  }
+  /**
+   * Clear a queue.
+   */
+  async clear(queue) {
+    this.queues.delete(queue);
+  }
+  /**
+   * Push multiple jobs.
+   */
+  async pushMany(queue, jobs) {
+    if (!this.queues.has(queue)) {
+      this.queues.set(queue, []);
+    }
+    this.queues.get(queue)?.push(...jobs);
+  }
+  /**
+   * Pop multiple jobs.
+   */
+  async popMany(queue, count) {
+    const results = [];
+    for (let i = 0; i < count; i++) {
+      const job = await this.pop(queue);
+      if (job) {
+        results.push(job);
+      } else {
+        break;
+      }
+    }
+    return results;
+  }
+};
+
+// src/index.ts
+init_RabbitMQDriver();
+init_RedisDriver();
+init_SQSDriver();
+
+// src/Job.ts
+var Job = class {
+  /**
+   * Unique job identifier.
+   */
+  id;
+  /**
+   * Queue name.
+   */
+  queueName;
+  /**
+   * Connection name.
+   */
+  connectionName;
+  /**
+   * Delay before execution (seconds).
+   */
+  delaySeconds;
+  /**
+   * Current attempt number.
+   */
+  attempts;
+  /**
+   * Maximum attempts.
+   */
+  maxAttempts;
+  /**
+   * Group ID for FIFO.
+   */
+  groupId;
+  /**
+   * Job priority.
+   */
+  priority;
+  /**
+   * Initial retry delay (seconds).
+   */
+  retryAfterSeconds;
+  /**
+   * Retry delay multiplier.
+   */
+  retryMultiplier;
+  /**
+   * Set target queue.
+   */
+  onQueue(queue) {
+    this.queueName = queue;
+    return this;
+  }
+  /**
+   * Set target connection.
+   */
+  onConnection(connection) {
+    this.connectionName = connection;
+    return this;
+  }
+  /**
+   * Set job priority.
+   * @param priority - 'high', 'low', or number
+   */
+  withPriority(priority) {
+    this.priority = priority;
+    return this;
+  }
+  /**
+   * Set delay (seconds).
+   */
+  delay(delay) {
+    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).
+   *
+   * Called when the job fails and reaches the maximum number of attempts.
+   * Subclasses can override to implement custom failure handling.
+   *
+   * @param error - Error instance
+   */
+  async failed(_error) {
+  }
+};
+
+// src/serializers/ClassNameSerializer.ts
+var ClassNameSerializer = class {
+  /**
+   * Job class registry (for resolving classes by name).
+   */
+  jobClasses = /* @__PURE__ */ new Map();
+  /**
+   * Register a Job class.
+   * @param jobClass - Job class
+   */
+  register(jobClass) {
+    this.jobClasses.set(jobClass.name, jobClass);
+  }
+  /**
+   * Register multiple Job classes.
+   * @param jobClasses - Job class array
+   */
+  registerMany(jobClasses) {
+    for (const jobClass of jobClasses) {
+      this.register(jobClass);
+    }
+  }
+  /**
+   * Serialize a Job.
+   */
+  serialize(job) {
+    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) {
+      if (Object.hasOwn(job, key) && typeof job[key] !== "function") {
+        properties[key] = job[key];
+      }
+    }
+    return {
+      id,
+      type: "class",
+      className,
+      data: JSON.stringify({
+        class: className,
+        properties
+      }),
+      createdAt: Date.now(),
+      ...job.delaySeconds !== void 0 ? { delaySeconds: job.delaySeconds } : {},
+      attempts: job.attempts ?? 0,
+      ...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 } : {}
+    };
+  }
+  /**
+   * Deserialize a Job.
+   */
+  deserialize(serialized) {
+    if (serialized.type !== "class") {
+      throw new Error('Invalid serialization type: expected "class"');
+    }
+    if (!serialized.className) {
+      throw new Error("Missing className in serialized job");
+    }
+    const JobClass = this.jobClasses.get(serialized.className);
+    if (!JobClass) {
+      throw new Error(
+        `Job class "${serialized.className}" is not registered. Please register it using serializer.register().`
+      );
+    }
+    const parsed = JSON.parse(serialized.data);
+    const job = new JobClass();
+    if (parsed.properties) {
+      Object.assign(job, parsed.properties);
+    }
+    job.id = serialized.id;
+    if (serialized.delaySeconds !== void 0) {
+      job.delaySeconds = serialized.delaySeconds;
+    }
+    if (serialized.attempts !== void 0) {
+      job.attempts = serialized.attempts;
+    }
+    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;
+  }
+};
+
+// src/serializers/JsonSerializer.ts
+var JsonSerializer = class {
+  /**
+   * Serialize a job.
+   */
+  serialize(job) {
+    const id = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    return {
+      id,
+      type: "json",
+      data: JSON.stringify({
+        job: job.constructor.name,
+        properties: { ...job }
+      }),
+      createdAt: Date.now(),
+      ...job.delaySeconds !== void 0 ? { delaySeconds: job.delaySeconds } : {},
+      attempts: job.attempts ?? 0,
+      ...job.maxAttempts !== void 0 ? { maxAttempts: job.maxAttempts } : {},
+      ...job.groupId ? { groupId: job.groupId } : {},
+      ...job.priority ? { priority: job.priority } : {}
+    };
+  }
+  /**
+   * Deserialize a job.
+   *
+   * Note: this implementation only restores properties and does not recreate class instances.
+   * For class instances, use `ClassNameSerializer`.
+   */
+  deserialize(serialized) {
+    if (serialized.type !== "json") {
+      throw new Error('Invalid serialization type: expected "json"');
+    }
+    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;
+  }
+};
+
+// src/QueueManager.ts
+var QueueManager = class {
+  drivers = /* @__PURE__ */ new Map();
+  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") {
+      this.defaultSerializer = new ClassNameSerializer();
+    } else {
+      this.defaultSerializer = new JsonSerializer();
+    }
+    if (!this.drivers.has("default")) {
+      this.drivers.set("default", new MemoryDriver());
+    }
+    if (config.connections) {
+      for (const [name, connectionConfig] of Object.entries(config.connections)) {
+        this.registerConnection(name, connectionConfig);
+      }
+    }
+  }
+  /**
+   * Register a connection.
+   * @param name - Connection name
+   * @param config - Connection config
+   */
+  registerConnection(name, config) {
+    const driverType = config.driver;
+    switch (driverType) {
+      case "memory":
+        this.drivers.set(name, new MemoryDriver());
+        break;
+      case "database": {
+        const { DatabaseDriver: DatabaseDriver2 } = (init_DatabaseDriver(), __toCommonJS(DatabaseDriver_exports));
+        const dbService = config.dbService;
+        if (!dbService) {
+          throw new Error(
+            "[QueueManager] DatabaseDriver requires dbService. Please provide a database service that implements DatabaseService interface."
+          );
+        }
+        this.drivers.set(
+          name,
+          new DatabaseDriver2({
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver loading requires type assertion
+            dbService,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            table: config.table
+          })
+        );
+        break;
+      }
+      case "redis": {
+        const { RedisDriver: RedisDriver2 } = (init_RedisDriver(), __toCommonJS(RedisDriver_exports));
+        const client = config.client;
+        if (!client) {
+          throw new Error(
+            "[QueueManager] RedisDriver requires client. Please provide Redis client in connection config."
+          );
+        }
+        this.drivers.set(
+          name,
+          new RedisDriver2({
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver loading requires type assertion
+            client,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            prefix: config.prefix
+          })
+        );
+        break;
+      }
+      case "kafka": {
+        const { KafkaDriver: KafkaDriver2 } = (init_KafkaDriver(), __toCommonJS(KafkaDriver_exports));
+        const client = config.client;
+        if (!client) {
+          throw new Error(
+            "[QueueManager] KafkaDriver requires client. Please provide Kafka client in connection config."
+          );
+        }
+        this.drivers.set(
+          name,
+          new KafkaDriver2({
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver loading requires type assertion
+            client,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            consumerGroupId: config.consumerGroupId
+          })
+        );
+        break;
+      }
+      case "sqs": {
+        const { SQSDriver: SQSDriver2 } = (init_SQSDriver(), __toCommonJS(SQSDriver_exports));
+        const client = config.client;
+        if (!client) {
+          throw new Error(
+            "[QueueManager] SQSDriver requires client. Please provide SQS client in connection config."
+          );
+        }
+        this.drivers.set(
+          name,
+          new SQSDriver2({
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver loading requires type assertion
+            client,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            queueUrlPrefix: config.queueUrlPrefix,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            visibilityTimeout: config.visibilityTimeout,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            waitTimeSeconds: config.waitTimeSeconds
+          })
+        );
+        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, rabbitmq`
+        );
+    }
+  }
+  /**
+   * Get a driver for a connection.
+   * @param connection - Connection name
+   * @returns Driver instance
+   */
+  getDriver(connection) {
+    const driver = this.drivers.get(connection);
+    if (!driver) {
+      throw new Error(`Connection "${connection}" not found`);
+    }
+    return driver;
+  }
+  /**
+   * Get the default connection name.
+   * @returns Default connection name
+   */
+  getDefaultConnection() {
+    return this.defaultConnection;
+  }
+  /**
+   * Get a serializer.
+   * @param type - Serializer type
+   * @returns Serializer instance
+   */
+  getSerializer(type) {
+    if (type) {
+      const serializer = this.serializers.get(type);
+      if (!serializer) {
+        throw new Error(`Serializer "${type}" not found`);
+      }
+      return serializer;
+    }
+    return this.defaultSerializer;
+  }
+  /**
+   * Register Job classes (used by ClassNameSerializer).
+   * @param jobClasses - Job class array
+   */
+  registerJobClasses(jobClasses) {
+    if (this.defaultSerializer instanceof ClassNameSerializer) {
+      this.defaultSerializer.registerMany(jobClasses);
+    }
+  }
+  /**
+   * Push a Job to the queue.
+   *
+   * @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
+   * ```typescript
+   * await manager.push(new SendEmailJob('user@example.com'));
+   * ```
+   */
+  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);
+    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;
+  }
+  /**
+   * Push multiple jobs to the queue.
+   *
+   * @template T - The type of the jobs.
+   * @param jobs - Array of job instances.
+   *
+   * @example
+   * ```typescript
+   * await manager.pushMany([new JobA(), new JobB()]);
+   * ```
+   */
+  async pushMany(jobs) {
+    if (jobs.length === 0) {
+      return;
+    }
+    const groups = /* @__PURE__ */ new Map();
+    const serializer = this.getSerializer();
+    for (const job of jobs) {
+      const connection = job.connectionName ?? this.defaultConnection;
+      const queue = job.queueName ?? "default";
+      const key = `${connection}:${queue}`;
+      const serialized = serializer.serialize(job);
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key)?.push(serialized);
+    }
+    for (const [key, serializedJobs] of groups.entries()) {
+      const [connection, queue] = key.split(":");
+      if (!connection || !queue) {
+        continue;
+      }
+      const driver = this.getDriver(connection);
+      if (driver.pushMany) {
+        await driver.pushMany(queue, serializedJobs);
+      } else {
+        for (const job of serializedJobs) {
+          await driver.push(queue, job);
+        }
+      }
+    }
+  }
+  /**
+   * Pop a job from the queue.
+   *
+   * @param queue - Queue name (default: 'default').
+   * @param connection - Connection name (optional).
+   * @returns Job instance or null if queue is empty.
+   *
+   * @example
+   * ```typescript
+   * const job = await manager.pop('emails');
+   * if (job) await job.handle();
+   * ```
+   */
+  async pop(queue = "default", connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    const serializer = this.getSerializer();
+    const serialized = await driver.pop(queue);
+    if (!serialized) {
+      return null;
+    }
+    try {
+      return serializer.deserialize(serialized);
+    } catch (error) {
+      console.error("[QueueManager] Failed to deserialize job:", error);
+      return null;
+    }
+  }
+  /**
+   * Get queue size.
+   *
+   * @param queue - Queue name (default: 'default').
+   * @param connection - Connection name (optional).
+   * @returns Number of jobs in the queue.
+   */
+  async size(queue = "default", connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    return driver.size(queue);
+  }
+  /**
+   * Clear all jobs from a queue.
+   *
+   * @param queue - Queue name (default: 'default').
+   * @param connection - Connection name (optional).
+   */
+  async clear(queue = "default", connection = this.defaultConnection) {
+    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
+var OrbitStream = class _OrbitStream {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  queueManager;
+  consumer;
+  /**
+   * Static configuration helper.
+   */
+  static configure(options) {
+    return new _OrbitStream(options);
+  }
+  /**
+   * Install into PlanetCore.
+   */
+  install(core) {
+    this.queueManager = new QueueManager(this.options);
+    core.adapter.use("*", async (c, next) => {
+      if (this.queueManager && this.options.connections) {
+        for (const [name, config] of Object.entries(this.options.connections)) {
+          if (config.driver === "database" && !config.dbService) {
+            try {
+              const dbService = c.get("db");
+              if (dbService) {
+                try {
+                  this.queueManager.getDriver(name);
+                } catch {
+                  this.queueManager.registerConnection(name, {
+                    ...config,
+                    dbService
+                  });
+                }
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      c.set("queue", this.queueManager);
+      await next();
+      return void 0;
+    });
+    core.logger.info("[OrbitStream] Installed");
+    if (this.options.autoStartWorker && process.env.NODE_ENV === "development" && this.options.workerOptions) {
+      this.startWorker(this.options.workerOptions);
+    }
+  }
+  /**
+   * Start embedded worker.
+   */
+  startWorker(options) {
+    if (!this.queueManager) {
+      throw new Error("QueueManager not initialized. Call install() first.");
+    }
+    if (this.consumer?.isRunning()) {
+      throw new Error("Worker is already running");
+    }
+    this.consumer = new Consumer(this.queueManager, options);
+    this.consumer.start().catch((error) => {
+      console.error("[OrbitStream] Worker error:", error);
+    });
+  }
+  /**
+   * Stop embedded worker.
+   */
+  async stopWorker() {
+    if (this.consumer) {
+      await this.consumer.stop();
+    }
+  }
+  /**
+   * Get QueueManager instance.
+   */
+  getQueueManager() {
+    return this.queueManager;
+  }
+};
+
+// src/persistence/MySQLPersistence.ts
+import { DB, Schema } from "@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 Schema.hasTable(this.table);
+    if (exists) return;
+    await 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(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 Schema.hasTable(this.logsTable);
+    if (exists) return;
+    await 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(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
+import { Schema as Schema2 } from "@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 Schema2.hasTable(this.table);
+    if (exists) return;
+    await Schema2.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 Schema2.hasTable(this.logsTable);
+    if (exists) return;
+    await Schema2.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();
+export {
+  ClassNameSerializer,
+  Consumer,
+  DatabaseDriver,
+  Job,
+  JsonSerializer,
+  KafkaDriver,
+  MemoryDriver,
+  MySQLPersistence,
+  OrbitStream,
+  QueueManager,
+  RabbitMQDriver,
+  RedisDriver,
+  SQLitePersistence,
+  SQSDriver,
+  Scheduler,
+  Worker
+};