@gravito/stream 2.0.0 → 2.0.1

package/dist/index.cjs

@@ -130,6 +130,99 @@ var init_DatabaseDriver = __esm({
         }
         return job;
       }
+      /**
+       * Pop multiple jobs from the queue.
+       */
+      async popMany(queue, count) {
+        if (count <= 1) {
+          const job = await this.pop(queue);
+          return job ? [job] : [];
+        }
+        try {
+          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 ${count}
+         FOR UPDATE SKIP LOCKED`,
+            [queue]
+          );
+          const rows = Array.isArray(result) ? result : result ? [result] : [];
+          if (!rows || rows.length === 0) {
+            return [];
+          }
+          const validRows = rows.filter((r) => r?.id);
+          if (validRows.length === 0) {
+            return [];
+          }
+          const ids = validRows.map((r) => r.id);
+          await this.dbService.execute(
+            `UPDATE ${this.tableName}
+         SET reserved_at = NOW()
+         WHERE id IN (${ids.map((_, i) => `$${i + 1}`).join(", ")})`,
+            ids
+          );
+          return validRows.map((row) => {
+            const createdAt = new Date(row.created_at).getTime();
+            try {
+              const parsed = JSON.parse(row.payload);
+              return {
+                ...parsed,
+                id: row.id,
+                attempts: row.attempts
+              };
+            } catch (_e) {
+              return {
+                id: row.id,
+                type: "class",
+                data: row.payload,
+                createdAt,
+                attempts: row.attempts
+              };
+            }
+          });
+        } catch (_e) {
+          const firstJob = await this.pop(queue);
+          return firstJob ? [firstJob] : [];
+        }
+      }
+      /**
+       * Get queue statistics.
+       */
+      async stats(queue) {
+        const failedQueue = `failed:${queue}`;
+        try {
+          const pendingRes = await this.dbService.execute(
+            `SELECT COUNT(*) as count FROM ${this.tableName} WHERE queue = $1 AND available_at <= NOW() AND reserved_at IS NULL`,
+            [queue]
+          );
+          const delayedRes = await this.dbService.execute(
+            `SELECT COUNT(*) as count FROM ${this.tableName} WHERE queue = $1 AND available_at > NOW()`,
+            [queue]
+          );
+          const reservedRes = await this.dbService.execute(
+            `SELECT COUNT(*) as count FROM ${this.tableName} WHERE queue = $1 AND reserved_at IS NOT NULL`,
+            [queue]
+          );
+          const failedRes = await this.dbService.execute(
+            `SELECT COUNT(*) as count FROM ${this.tableName} WHERE queue = $1`,
+            [failedQueue]
+          );
+          return {
+            queue,
+            size: pendingRes[0]?.count || 0,
+            delayed: delayedRes[0]?.count || 0,
+            reserved: reservedRes[0]?.count || 0,
+            failed: failedRes[0]?.count || 0
+          };
+        } catch (err) {
+          console.error("[DatabaseDriver] Failed to get stats:", err);
+          return { queue, size: 0, delayed: 0, reserved: 0, failed: 0 };
+        }
+      }
       /**
        * Get queue size.
        */
@@ -150,21 +243,44 @@ var init_DatabaseDriver = __esm({
       async clear(queue) {
         await this.dbService.execute(`DELETE FROM ${this.tableName} WHERE queue = $1`, [queue]);
       }
+      /**
+       * Pop a job from the queue (blocking).
+       * Simple polling fallback for databases.
+       */
+      async popBlocking(queue, timeout) {
+        const start = Date.now();
+        const timeoutMs = timeout * 1e3;
+        while (true) {
+          const job = await this.pop(queue);
+          if (job) {
+            return job;
+          }
+          if (timeout > 0 && Date.now() - start >= timeoutMs) {
+            return null;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+        }
+      }
       /**
        * Push multiple jobs.
+       * Optimizes by using a single multi-row insert if possible.
        */
       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()]
-            );
+          for (let i = 0; i < jobs.length; i += 100) {
+            const batch = jobs.slice(i, i + 100);
+            for (const job of batch) {
+              const availableAt = job.delaySeconds ? new Date(Date.now() + job.delaySeconds * 1e3) : /* @__PURE__ */ new Date();
+              const payload = JSON.stringify(job);
+              await tx.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()]
+              );
+            }
           }
         });
       }
@@ -340,25 +456,29 @@ var init_KafkaDriver = __esm({
         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);
+          eachBatch: async ({ batch, resolveOffset, heartbeat, isRunning }) => {
+            for (const message of batch.messages) {
+              if (!isRunning() || !message.value) {
+                continue;
+              }
+              try {
+                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
+                };
+                await callback(job);
+                resolveOffset(message.offset);
+                await heartbeat();
+              } catch (error) {
+                console.error("[KafkaDriver] Error processing message:", error);
+              }
             }
           }
         });
@@ -443,6 +563,25 @@ var init_RabbitMQDriver = __esm({
         job._raw = msg;
         return job;
       }
+      /**
+       * Pop multiple jobs.
+       * Uses channel.get() in a loop (no native batch get in AMQP).
+       */
+      async popMany(queue, count) {
+        const channel = await this.ensureChannel();
+        await channel.assertQueue(queue, { durable: true });
+        const results = [];
+        for (let i = 0; i < count; i++) {
+          const msg = await channel.get(queue, { noAck: false });
+          if (!msg) {
+            break;
+          }
+          const job = JSON.parse(msg.content.toString());
+          job._raw = msg;
+          results.push(job);
+        }
+        return results;
+      }
       /**
        * Acknowledge a message.
        */
@@ -472,6 +611,9 @@ var init_RabbitMQDriver = __esm({
       async subscribe(queue, callback, options = {}) {
         const channel = await this.ensureChannel();
         await channel.assertQueue(queue, { durable: true });
+        if (options.prefetch) {
+          await channel.prefetch(options.prefetch);
+        }
         if (this.exchange) {
           await channel.bindQueue(queue, this.exchange, "");
         }
@@ -556,6 +698,63 @@ var init_RedisDriver = __esm({
     else
       return redis.call('SREM', activeSet, groupId)
     end
+  `;
+      // Lua Logic:
+      // Iterate priorities.
+      // Check delayed.
+      // Check paused.
+      // RPOP count.
+      static POP_MANY_SCRIPT = `
+    local queue = KEYS[1]
+    local prefix = ARGV[1]
+    local count = tonumber(ARGV[2])
+    local now = tonumber(ARGV[3])
+    
+    local priorities = {'critical', 'high', 'default', 'low'}
+    local result = {}
+    
+    for _, priority in ipairs(priorities) do
+      if #result >= count then break end
+      
+      local key = prefix .. queue
+      if priority ~= 'default' then
+        key = key .. ':' .. priority
+      end
+      
+      -- Check Delayed (Move to Ready if due)
+      local delayKey = key .. ":delayed"
+      -- Optimization: Only check delayed if we need more items
+      -- Fetch up to (count - #result) delayed items
+      local needed = count - #result
+      local delayed = redis.call("ZRANGEBYSCORE", delayKey, 0, now, "LIMIT", 0, needed)
+      
+      for _, job in ipairs(delayed) do
+        redis.call("ZREM", delayKey, job)
+        -- We return it directly, assuming we want to process it now.
+        -- Alternative: LPUSH to list and RPOP? No, direct return is faster.
+        table.insert(result, job)
+        needed = needed - 1
+      end
+      
+      if #result >= count then break end
+
+      -- Check Paused
+      local isPaused = redis.call("GET", key .. ":paused")
+      if isPaused ~= "1" then
+        needed = count - #result
+        -- Loop RPOP to get items
+        for i = 1, needed do
+            local job = redis.call("RPOP", key)
+            if job then
+                table.insert(result, job)
+            else
+                break
+            end
+        end
+      end
+    end
+    
+    return result
   `;
       constructor(config) {
         this.client = config.client;
@@ -566,7 +765,6 @@ var init_RedisDriver = __esm({
           );
         }
         if (typeof this.client.defineCommand === "function") {
-          ;
           this.client.defineCommand("pushGroupJob", {
             numberOfKeys: 3,
             lua: _RedisDriver.PUSH_SCRIPT
@@ -575,6 +773,10 @@ var init_RedisDriver = __esm({
             numberOfKeys: 3,
             lua: _RedisDriver.COMPLETE_SCRIPT
           });
+          this.client.defineCommand("popMany", {
+            numberOfKeys: 1,
+            lua: _RedisDriver.POP_MANY_SCRIPT
+          });
         }
       }
       /**
@@ -641,31 +843,70 @@ var init_RedisDriver = __esm({
         }
       }
       /**
-       * Pop a job (RPOP, FIFO).
-       * Supports implicit priority polling (critical -> high -> default -> low).
+       * Pop a job from a queue (non-blocking).
+       * Optimized with Lua script for atomic priority polling.
        */
       async pop(queue) {
+        const priorities = ["critical", "high", "default", "low"];
+        const keys = [];
+        for (const p of priorities) {
+          keys.push(this.getKey(queue, p === "default" ? void 0 : p));
+        }
+        const script = `
+      local now = tonumber(ARGV[1])
+      for i, key in ipairs(KEYS) do
+        -- 1. Check delayed
+        local delayKey = key .. ":delayed"
+        local delayed = redis.call("ZRANGEBYSCORE", delayKey, 0, now, "LIMIT", 0, 1)
+        if delayed[1] then
+          redis.call("ZREM", delayKey, delayed[1])
+          return {key, delayed[1]}
+        end
+
+        -- 2. Check paused
+        local isPaused = redis.call("GET", key .. ":paused")
+        if isPaused ~= "1" then
+          -- 3. RPOP
+          local payload = redis.call("RPOP", key)
+          if payload then
+            return {key, payload}
+          end
+        end
+      end
+      return nil
+    `;
+        try {
+          const result = await this.client.eval(script, keys.length, ...keys, Date.now().toString());
+          if (result?.[1]) {
+            return this.parsePayload(result[1]);
+          }
+        } catch (err) {
+          console.error("[RedisDriver] Lua pop error:", err);
+          return this.popManualFallback(queue);
+        }
+        return null;
+      }
+      /**
+       * Manual fallback for pop if Lua fails.
+       */
+      async popManualFallback(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);
-              }
+          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 isPaused = await this.client.get?.(`${key}:paused`);
+          if (isPaused === "1") {
+            continue;
           }
           const payload = await this.client.rpop(key);
           if (payload) {
@@ -674,6 +915,31 @@ var init_RedisDriver = __esm({
         }
         return null;
       }
+      /**
+       * Pop a job from the queue (blocking).
+       * Uses BRPOP for efficiency. Supports multiple queues and priorities.
+       */
+      async popBlocking(queues, timeout) {
+        const queueList = Array.isArray(queues) ? queues : [queues];
+        const priorities = ["critical", "high", void 0, "low"];
+        const keys = [];
+        for (const q of queueList) {
+          for (const p of priorities) {
+            keys.push(this.getKey(q, p));
+          }
+        }
+        if (typeof this.client.brpop !== "function") {
+          return this.pop(queueList[0]);
+        }
+        try {
+          const result = await this.client.brpop(...keys, timeout);
+          if (result && Array.isArray(result) && result.length >= 2) {
+            return this.parsePayload(result[1]);
+          }
+        } catch (_e) {
+        }
+        return null;
+      }
       /**
        * Parse Redis payload.
        */
@@ -723,11 +989,57 @@ var init_RedisDriver = __esm({
         const delayKey = `${key}:delayed`;
         const activeSetKey = `${this.prefix}active`;
         await this.client.del(key);
-        if (typeof this.client.del === "function") {
+        if (this.client.del) {
           await this.client.del(delayKey);
           await this.client.del(activeSetKey);
         }
       }
+      /**
+       * Get queue statistics.
+       * Optimized with Redis Pipeline to fetch all priorities and DLQ stats in one trip.
+       */
+      async stats(queue) {
+        const priorities = ["critical", "high", "default", "low"];
+        const stats = {
+          queue,
+          size: 0,
+          delayed: 0,
+          failed: 0
+        };
+        const keys = [];
+        for (const p of priorities) {
+          keys.push(this.getKey(queue, p === "default" ? void 0 : p));
+        }
+        try {
+          if (typeof this.client.pipeline === "function") {
+            const pipe = this.client.pipeline();
+            for (const key of keys) {
+              pipe.llen(key);
+              pipe.zcard(`${key}:delayed`);
+            }
+            pipe.llen(`${this.getKey(queue)}:failed`);
+            const results = await pipe.exec();
+            if (results) {
+              let i = 0;
+              for (const _p of priorities) {
+                stats.size += results[i][1] || 0;
+                stats.delayed += results[i + 1][1] || 0;
+                i += 2;
+              }
+              stats.failed = results[i][1] || 0;
+            }
+          } else {
+            for (const key of keys) {
+              stats.size += await this.client.llen?.(key) || 0;
+              stats.delayed += await this.client.zcard?.(`${key}:delayed`) || 0;
+            }
+            stats.failed = await this.client.llen?.(`${this.getKey(queue)}:failed`) || 0;
+          }
+        } catch (err) {
+          console.error("[RedisDriver] Failed to get stats:", err);
+        }
+        return stats;
+      }
       /**
        * Push multiple jobs.
        */
@@ -738,6 +1050,43 @@ var init_RedisDriver = __esm({
         const hasGroup = jobs.some((j) => j.groupId);
         const hasPriority = jobs.some((j) => j.priority);
         if (hasGroup || hasPriority) {
+          if (typeof this.client.pipeline === "function") {
+            const pipe = this.client.pipeline();
+            for (const job of jobs) {
+              const priority = job.priority;
+              const key2 = this.getKey(queue, priority);
+              const groupId = job.groupId;
+              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,
+                groupId,
+                priority,
+                error: job.error,
+                failedAt: job.failedAt
+              });
+              if (groupId) {
+                const activeSetKey = `${this.prefix}active`;
+                const pendingListKey = `${this.prefix}pending:${groupId}`;
+                pipe.pushGroupJob(key2, activeSetKey, pendingListKey, groupId, payload);
+              } else {
+                if (job.delaySeconds && job.delaySeconds > 0) {
+                  const delayKey = `${key2}:delayed`;
+                  const score = Date.now() + job.delaySeconds * 1e3;
+                  pipe.zadd(delayKey, score, payload);
+                } else {
+                  pipe.lpush(key2, payload);
+                }
+              }
+            }
+            await pipe.exec();
+            return;
+          }
           for (const job of jobs) {
             await this.push(queue, job, {
               groupId: job.groupId,
@@ -765,17 +1114,80 @@ var init_RedisDriver = __esm({
       }
       /**
        * Pop multiple jobs.
+       * Atomic operation across multiple priority levels.
        */
       async popMany(queue, count) {
-        const key = this.getKey(queue);
+        if (count <= 0) {
+          return [];
+        }
+        if (count === 1) {
+          const job = await this.pop(queue);
+          return job ? [job] : [];
+        }
+        if (typeof this.client.popMany === "function") {
+          try {
+            const result = await this.client.popMany(queue, this.prefix, count, Date.now().toString());
+            if (Array.isArray(result) && result.length > 0) {
+              return result.map((p) => this.parsePayload(p));
+            } else if (Array.isArray(result) && result.length === 0) {
+            } else {
+            }
+            if (Array.isArray(result)) {
+              return result.map((p) => this.parsePayload(p));
+            }
+          } catch (err) {
+            console.error("[RedisDriver] Lua popMany error:", err);
+          }
+        }
+        const priorities = ["critical", "high", "default", "low"];
         const results = [];
-        for (let i = 0; i < count; i++) {
-          const payload = await this.client.rpop(key);
-          if (payload) {
-            results.push(this.parsePayload(payload));
-          } else {
+        let remaining = count;
+        for (const priority of priorities) {
+          if (remaining <= 0) {
             break;
           }
+          const key = this.getKey(queue, priority === "default" ? void 0 : priority);
+          const isPaused = await this.client.get?.(`${key}:paused`);
+          if (isPaused === "1") {
+            continue;
+          }
+          let fetched = [];
+          try {
+            const reply = await this.client.rpop(key, remaining);
+            if (reply) {
+              fetched = Array.isArray(reply) ? reply : [reply];
+            }
+          } catch (_e) {
+            if (typeof this.client.pipeline === "function") {
+              const pipeline = this.client.pipeline();
+              for (let i = 0; i < remaining; i++) {
+                pipeline.rpop(key);
+              }
+              const replies = await pipeline.exec();
+              if (replies) {
+                fetched = replies.map((r) => r[1]).filter((r) => r !== null);
+              }
+            } else {
+              for (let i = 0; i < remaining; i++) {
+                const res = await this.client.rpop(key);
+                if (res) {
+                  fetched.push(res);
+                } else {
+                  break;
+                }
+              }
+            }
+          }
+          if (fetched.length > 0) {
+            for (const payload of fetched) {
+              try {
+                results.push(this.parsePayload(payload));
+              } catch (e) {
+                console.error("[RedisDriver] Failed to parse job payload:", e);
+              }
+            }
+            remaining -= fetched.length;
+          }
         }
         return results;
       }
@@ -819,7 +1231,7 @@ var init_RedisDriver = __esm({
         const client = this.client;
         if (typeof client.incr === "function") {
           const current = await client.incr(windowKey);
-          if (current === 1) {
+          if (current === 1 && client.expire) {
             await client.expire(windowKey, Math.ceil(config.duration / 1e3) + 1);
           }
           return current <= config.max;
@@ -831,6 +1243,9 @@ var init_RedisDriver = __esm({
        */
       async getFailed(queue, start = 0, end = -1) {
         const key = `${this.getKey(queue)}:failed`;
+        if (typeof this.client.lrange !== "function") {
+          return [];
+        }
         const payloads = await this.client.lrange(key, start, end);
         return payloads.map((p) => this.parsePayload(p));
       }
@@ -842,6 +1257,9 @@ var init_RedisDriver = __esm({
         const failedKey = `${this.getKey(queue)}:failed`;
         let retried = 0;
         for (let i = 0; i < count; i++) {
+          if (typeof this.client.rpop !== "function") {
+            break;
+          }
           const payload = await this.client.rpop(failedKey);
           if (!payload) {
             break;
@@ -964,6 +1382,40 @@ var init_SQSDriver = __esm({
           ...message.ReceiptHandle && { receiptHandle: message.ReceiptHandle }
         };
       }
+      /**
+       * Pop multiple jobs.
+       * Leverages SQS MaxNumberOfMessages (up to 10).
+       */
+      async popMany(queue, count) {
+        const { ReceiveMessageCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        const limit = Math.min(count, 10);
+        const response = await this.client.send(
+          new ReceiveMessageCommand({
+            QueueUrl: queueUrl,
+            MaxNumberOfMessages: limit,
+            WaitTimeSeconds: this.waitTimeSeconds,
+            VisibilityTimeout: this.visibilityTimeout
+          })
+        );
+        if (!response.Messages || response.Messages.length === 0) {
+          return [];
+        }
+        return response.Messages.map((message) => {
+          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,
+            receiptHandle: message.ReceiptHandle
+          };
+        });
+      }
       /**
        * Get queue size (approximate).
        */
@@ -1067,6 +1519,1830 @@ var init_SQSDriver = __esm({
   }
 });
 
+// src/persistence/BufferedPersistence.ts
+var BufferedPersistence_exports = {};
+__export(BufferedPersistence_exports, {
+  BufferedPersistence: () => BufferedPersistence
+});
+var BufferedPersistence;
+var init_BufferedPersistence = __esm({
+  "src/persistence/BufferedPersistence.ts"() {
+    "use strict";
+    BufferedPersistence = class {
+      constructor(adapter, options = {}) {
+        this.adapter = adapter;
+        this.maxBufferSize = options.maxBufferSize ?? 50;
+        this.flushInterval = options.flushInterval ?? 5e3;
+      }
+      jobBuffer = [];
+      logBuffer = [];
+      flushTimer = null;
+      maxBufferSize;
+      flushInterval;
+      async archive(queue, job, status) {
+        this.jobBuffer.push({ queue, job, status });
+        if (this.jobBuffer.length >= this.maxBufferSize) {
+          this.flush().catch((err) => {
+            console.error("[BufferedPersistence] Auto-flush failed (jobs):", err.message || err);
+          });
+        } else {
+          this.ensureFlushTimer();
+        }
+      }
+      async find(queue, id) {
+        return this.adapter.find(queue, id);
+      }
+      async list(queue, options) {
+        return this.adapter.list(queue, options);
+      }
+      async archiveMany(jobs) {
+        if (this.adapter.archiveMany) {
+          return this.adapter.archiveMany(jobs);
+        }
+        for (const item of jobs) {
+          await this.adapter.archive(item.queue, item.job, item.status);
+        }
+      }
+      async cleanup(days) {
+        return this.adapter.cleanup(days);
+      }
+      async flush() {
+        if (this.flushTimer) {
+          clearTimeout(this.flushTimer);
+          this.flushTimer = null;
+        }
+        const jobs = [...this.jobBuffer];
+        const logs = [...this.logBuffer];
+        this.jobBuffer = [];
+        this.logBuffer = [];
+        const promises = [];
+        if (jobs.length > 0) {
+          if (this.adapter.archiveMany) {
+            promises.push(this.adapter.archiveMany(jobs));
+          } else {
+            promises.push(
+              (async () => {
+                for (const item of jobs) {
+                  await this.adapter.archive(item.queue, item.job, item.status);
+                }
+              })()
+            );
+          }
+        }
+        if (logs.length > 0) {
+          if (this.adapter.archiveLogMany) {
+            promises.push(this.adapter.archiveLogMany(logs));
+          } else {
+            promises.push(
+              (async () => {
+                for (const log of logs) {
+                  await this.adapter.archiveLog(log);
+                }
+              })()
+            );
+          }
+        }
+        await Promise.all(promises);
+      }
+      async count(queue, options) {
+        return this.adapter.count(queue, options);
+      }
+      async archiveLog(log) {
+        this.logBuffer.push(log);
+        if (this.logBuffer.length >= this.maxBufferSize) {
+          this.flush().catch((err) => {
+            console.error("[BufferedPersistence] Auto-flush failed (logs):", err.message || err);
+          });
+        } else {
+          this.ensureFlushTimer();
+        }
+      }
+      async archiveLogMany(logs) {
+        if (this.adapter.archiveLogMany) {
+          return this.adapter.archiveLogMany(logs);
+        }
+        for (const log of logs) {
+          await this.adapter.archiveLog(log);
+        }
+      }
+      async listLogs(options) {
+        return this.adapter.listLogs(options);
+      }
+      async countLogs(options) {
+        return this.adapter.countLogs(options);
+      }
+      ensureFlushTimer() {
+        if (this.flushTimer) {
+          return;
+        }
+        this.flushTimer = setTimeout(() => {
+          this.flush().catch((err) => {
+            console.error("[BufferedPersistence] Interval flush failed:", err.message || err);
+          });
+        }, this.flushInterval);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/utf8.mjs
+function utf8Count(str) {
+  const strLength = str.length;
+  let byteLength = 0;
+  let pos = 0;
+  while (pos < strLength) {
+    let value = str.charCodeAt(pos++);
+    if ((value & 4294967168) === 0) {
+      byteLength++;
+      continue;
+    } else if ((value & 4294965248) === 0) {
+      byteLength += 2;
+    } else {
+      if (value >= 55296 && value <= 56319) {
+        if (pos < strLength) {
+          const extra = str.charCodeAt(pos);
+          if ((extra & 64512) === 56320) {
+            ++pos;
+            value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+          }
+        }
+      }
+      if ((value & 4294901760) === 0) {
+        byteLength += 3;
+      } else {
+        byteLength += 4;
+      }
+    }
+  }
+  return byteLength;
+}
+function utf8EncodeJs(str, output, outputOffset) {
+  const strLength = str.length;
+  let offset = outputOffset;
+  let pos = 0;
+  while (pos < strLength) {
+    let value = str.charCodeAt(pos++);
+    if ((value & 4294967168) === 0) {
+      output[offset++] = value;
+      continue;
+    } else if ((value & 4294965248) === 0) {
+      output[offset++] = value >> 6 & 31 | 192;
+    } else {
+      if (value >= 55296 && value <= 56319) {
+        if (pos < strLength) {
+          const extra = str.charCodeAt(pos);
+          if ((extra & 64512) === 56320) {
+            ++pos;
+            value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+          }
+        }
+      }
+      if ((value & 4294901760) === 0) {
+        output[offset++] = value >> 12 & 15 | 224;
+        output[offset++] = value >> 6 & 63 | 128;
+      } else {
+        output[offset++] = value >> 18 & 7 | 240;
+        output[offset++] = value >> 12 & 63 | 128;
+        output[offset++] = value >> 6 & 63 | 128;
+      }
+    }
+    output[offset++] = value & 63 | 128;
+  }
+}
+function utf8EncodeTE(str, output, outputOffset) {
+  sharedTextEncoder.encodeInto(str, output.subarray(outputOffset));
+}
+function utf8Encode(str, output, outputOffset) {
+  if (str.length > TEXT_ENCODER_THRESHOLD) {
+    utf8EncodeTE(str, output, outputOffset);
+  } else {
+    utf8EncodeJs(str, output, outputOffset);
+  }
+}
+function utf8DecodeJs(bytes, inputOffset, byteLength) {
+  let offset = inputOffset;
+  const end = offset + byteLength;
+  const units = [];
+  let result = "";
+  while (offset < end) {
+    const byte1 = bytes[offset++];
+    if ((byte1 & 128) === 0) {
+      units.push(byte1);
+    } else if ((byte1 & 224) === 192) {
+      const byte2 = bytes[offset++] & 63;
+      units.push((byte1 & 31) << 6 | byte2);
+    } else if ((byte1 & 240) === 224) {
+      const byte2 = bytes[offset++] & 63;
+      const byte3 = bytes[offset++] & 63;
+      units.push((byte1 & 31) << 12 | byte2 << 6 | byte3);
+    } else if ((byte1 & 248) === 240) {
+      const byte2 = bytes[offset++] & 63;
+      const byte3 = bytes[offset++] & 63;
+      const byte4 = bytes[offset++] & 63;
+      let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+      if (unit > 65535) {
+        unit -= 65536;
+        units.push(unit >>> 10 & 1023 | 55296);
+        unit = 56320 | unit & 1023;
+      }
+      units.push(unit);
+    } else {
+      units.push(byte1);
+    }
+    if (units.length >= CHUNK_SIZE) {
+      result += String.fromCharCode(...units);
+      units.length = 0;
+    }
+  }
+  if (units.length > 0) {
+    result += String.fromCharCode(...units);
+  }
+  return result;
+}
+function utf8DecodeTD(bytes, inputOffset, byteLength) {
+  const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+  return sharedTextDecoder.decode(stringBytes);
+}
+function utf8Decode(bytes, inputOffset, byteLength) {
+  if (byteLength > TEXT_DECODER_THRESHOLD) {
+    return utf8DecodeTD(bytes, inputOffset, byteLength);
+  } else {
+    return utf8DecodeJs(bytes, inputOffset, byteLength);
+  }
+}
+var sharedTextEncoder, TEXT_ENCODER_THRESHOLD, CHUNK_SIZE, sharedTextDecoder, TEXT_DECODER_THRESHOLD;
+var init_utf8 = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/utf8.mjs"() {
+    "use strict";
+    sharedTextEncoder = new TextEncoder();
+    TEXT_ENCODER_THRESHOLD = 50;
+    CHUNK_SIZE = 4096;
+    sharedTextDecoder = new TextDecoder();
+    TEXT_DECODER_THRESHOLD = 200;
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/ExtData.mjs
+var ExtData;
+var init_ExtData = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/ExtData.mjs"() {
+    "use strict";
+    ExtData = class {
+      type;
+      data;
+      constructor(type, data) {
+        this.type = type;
+        this.data = data;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/DecodeError.mjs
+var DecodeError;
+var init_DecodeError = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/DecodeError.mjs"() {
+    "use strict";
+    DecodeError = class _DecodeError extends Error {
+      constructor(message) {
+        super(message);
+        const proto = Object.create(_DecodeError.prototype);
+        Object.setPrototypeOf(this, proto);
+        Object.defineProperty(this, "name", {
+          configurable: true,
+          enumerable: false,
+          value: _DecodeError.name
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/int.mjs
+function setUint64(view, offset, value) {
+  const high = value / 4294967296;
+  const low = value;
+  view.setUint32(offset, high);
+  view.setUint32(offset + 4, low);
+}
+function setInt64(view, offset, value) {
+  const high = Math.floor(value / 4294967296);
+  const low = value;
+  view.setUint32(offset, high);
+  view.setUint32(offset + 4, low);
+}
+function getInt64(view, offset) {
+  const high = view.getInt32(offset);
+  const low = view.getUint32(offset + 4);
+  return high * 4294967296 + low;
+}
+function getUint64(view, offset) {
+  const high = view.getUint32(offset);
+  const low = view.getUint32(offset + 4);
+  return high * 4294967296 + low;
+}
+var UINT32_MAX;
+var init_int = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/int.mjs"() {
+    "use strict";
+    UINT32_MAX = 4294967295;
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/timestamp.mjs
+function encodeTimeSpecToTimestamp({ sec, nsec }) {
+  if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+    if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+      const rv = new Uint8Array(4);
+      const view = new DataView(rv.buffer);
+      view.setUint32(0, sec);
+      return rv;
+    } else {
+      const secHigh = sec / 4294967296;
+      const secLow = sec & 4294967295;
+      const rv = new Uint8Array(8);
+      const view = new DataView(rv.buffer);
+      view.setUint32(0, nsec << 2 | secHigh & 3);
+      view.setUint32(4, secLow);
+      return rv;
+    }
+  } else {
+    const rv = new Uint8Array(12);
+    const view = new DataView(rv.buffer);
+    view.setUint32(0, nsec);
+    setInt64(view, 4, sec);
+    return rv;
+  }
+}
+function encodeDateToTimeSpec(date) {
+  const msec = date.getTime();
+  const sec = Math.floor(msec / 1e3);
+  const nsec = (msec - sec * 1e3) * 1e6;
+  const nsecInSec = Math.floor(nsec / 1e9);
+  return {
+    sec: sec + nsecInSec,
+    nsec: nsec - nsecInSec * 1e9
+  };
+}
+function encodeTimestampExtension(object) {
+  if (object instanceof Date) {
+    const timeSpec = encodeDateToTimeSpec(object);
+    return encodeTimeSpecToTimestamp(timeSpec);
+  } else {
+    return null;
+  }
+}
+function decodeTimestampToTimeSpec(data) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  switch (data.byteLength) {
+    case 4: {
+      const sec = view.getUint32(0);
+      const nsec = 0;
+      return { sec, nsec };
+    }
+    case 8: {
+      const nsec30AndSecHigh2 = view.getUint32(0);
+      const secLow32 = view.getUint32(4);
+      const sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
+      const nsec = nsec30AndSecHigh2 >>> 2;
+      return { sec, nsec };
+    }
+    case 12: {
+      const sec = getInt64(view, 4);
+      const nsec = view.getUint32(0);
+      return { sec, nsec };
+    }
+    default:
+      throw new DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
+  }
+}
+function decodeTimestampExtension(data) {
+  const timeSpec = decodeTimestampToTimeSpec(data);
+  return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+}
+var EXT_TIMESTAMP, TIMESTAMP32_MAX_SEC, TIMESTAMP64_MAX_SEC, timestampExtension;
+var init_timestamp = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/timestamp.mjs"() {
+    "use strict";
+    init_DecodeError();
+    init_int();
+    EXT_TIMESTAMP = -1;
+    TIMESTAMP32_MAX_SEC = 4294967296 - 1;
+    TIMESTAMP64_MAX_SEC = 17179869184 - 1;
+    timestampExtension = {
+      type: EXT_TIMESTAMP,
+      encode: encodeTimestampExtension,
+      decode: decodeTimestampExtension
+    };
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/ExtensionCodec.mjs
+var ExtensionCodec;
+var init_ExtensionCodec = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/ExtensionCodec.mjs"() {
+    "use strict";
+    init_ExtData();
+    init_timestamp();
+    ExtensionCodec = class _ExtensionCodec {
+      static defaultCodec = new _ExtensionCodec();
+      // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
+      // this will make type errors a lot more clear
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      __brand;
+      // built-in extensions
+      builtInEncoders = [];
+      builtInDecoders = [];
+      // custom extensions
+      encoders = [];
+      decoders = [];
+      constructor() {
+        this.register(timestampExtension);
+      }
+      register({ type, encode: encode2, decode: decode2 }) {
+        if (type >= 0) {
+          this.encoders[type] = encode2;
+          this.decoders[type] = decode2;
+        } else {
+          const index = -1 - type;
+          this.builtInEncoders[index] = encode2;
+          this.builtInDecoders[index] = decode2;
+        }
+      }
+      tryToEncode(object, context) {
+        for (let i = 0; i < this.builtInEncoders.length; i++) {
+          const encodeExt = this.builtInEncoders[i];
+          if (encodeExt != null) {
+            const data = encodeExt(object, context);
+            if (data != null) {
+              const type = -1 - i;
+              return new ExtData(type, data);
+            }
+          }
+        }
+        for (let i = 0; i < this.encoders.length; i++) {
+          const encodeExt = this.encoders[i];
+          if (encodeExt != null) {
+            const data = encodeExt(object, context);
+            if (data != null) {
+              const type = i;
+              return new ExtData(type, data);
+            }
+          }
+        }
+        if (object instanceof ExtData) {
+          return object;
+        }
+        return null;
+      }
+      decode(data, type, context) {
+        const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+        if (decodeExt) {
+          return decodeExt(data, type, context);
+        } else {
+          return new ExtData(type, data);
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/typedArrays.mjs
+function isArrayBufferLike(buffer) {
+  return buffer instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
+}
+function ensureUint8Array(buffer) {
+  if (buffer instanceof Uint8Array) {
+    return buffer;
+  } else if (ArrayBuffer.isView(buffer)) {
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  } else if (isArrayBufferLike(buffer)) {
+    return new Uint8Array(buffer);
+  } else {
+    return Uint8Array.from(buffer);
+  }
+}
+var init_typedArrays = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/typedArrays.mjs"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/Encoder.mjs
+var DEFAULT_MAX_DEPTH, DEFAULT_INITIAL_BUFFER_SIZE, Encoder;
+var init_Encoder = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/Encoder.mjs"() {
+    "use strict";
+    init_utf8();
+    init_ExtensionCodec();
+    init_int();
+    init_typedArrays();
+    DEFAULT_MAX_DEPTH = 100;
+    DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+    Encoder = class _Encoder {
+      extensionCodec;
+      context;
+      useBigInt64;
+      maxDepth;
+      initialBufferSize;
+      sortKeys;
+      forceFloat32;
+      ignoreUndefined;
+      forceIntegerToFloat;
+      pos;
+      view;
+      bytes;
+      entered = false;
+      constructor(options) {
+        this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+        this.context = options?.context;
+        this.useBigInt64 = options?.useBigInt64 ?? false;
+        this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+        this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;
+        this.sortKeys = options?.sortKeys ?? false;
+        this.forceFloat32 = options?.forceFloat32 ?? false;
+        this.ignoreUndefined = options?.ignoreUndefined ?? false;
+        this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
+        this.pos = 0;
+        this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+        this.bytes = new Uint8Array(this.view.buffer);
+      }
+      clone() {
+        return new _Encoder({
+          extensionCodec: this.extensionCodec,
+          context: this.context,
+          useBigInt64: this.useBigInt64,
+          maxDepth: this.maxDepth,
+          initialBufferSize: this.initialBufferSize,
+          sortKeys: this.sortKeys,
+          forceFloat32: this.forceFloat32,
+          ignoreUndefined: this.ignoreUndefined,
+          forceIntegerToFloat: this.forceIntegerToFloat
+        });
+      }
+      reinitializeState() {
+        this.pos = 0;
+      }
+      /**
+       * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+       *
+       * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+       */
+      encodeSharedRef(object) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.encodeSharedRef(object);
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.doEncode(object, 1);
+          return this.bytes.subarray(0, this.pos);
+        } finally {
+          this.entered = false;
+        }
+      }
+      /**
+       * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+       */
+      encode(object) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.encode(object);
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.doEncode(object, 1);
+          return this.bytes.slice(0, this.pos);
+        } finally {
+          this.entered = false;
+        }
+      }
+      doEncode(object, depth) {
+        if (depth > this.maxDepth) {
+          throw new Error(`Too deep objects in depth ${depth}`);
+        }
+        if (object == null) {
+          this.encodeNil();
+        } else if (typeof object === "boolean") {
+          this.encodeBoolean(object);
+        } else if (typeof object === "number") {
+          if (!this.forceIntegerToFloat) {
+            this.encodeNumber(object);
+          } else {
+            this.encodeNumberAsFloat(object);
+          }
+        } else if (typeof object === "string") {
+          this.encodeString(object);
+        } else if (this.useBigInt64 && typeof object === "bigint") {
+          this.encodeBigInt64(object);
+        } else {
+          this.encodeObject(object, depth);
+        }
+      }
+      ensureBufferSizeToWrite(sizeToWrite) {
+        const requiredSize = this.pos + sizeToWrite;
+        if (this.view.byteLength < requiredSize) {
+          this.resizeBuffer(requiredSize * 2);
+        }
+      }
+      resizeBuffer(newSize) {
+        const newBuffer = new ArrayBuffer(newSize);
+        const newBytes = new Uint8Array(newBuffer);
+        const newView = new DataView(newBuffer);
+        newBytes.set(this.bytes);
+        this.view = newView;
+        this.bytes = newBytes;
+      }
+      encodeNil() {
+        this.writeU8(192);
+      }
+      encodeBoolean(object) {
+        if (object === false) {
+          this.writeU8(194);
+        } else {
+          this.writeU8(195);
+        }
+      }
+      encodeNumber(object) {
+        if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+          if (object >= 0) {
+            if (object < 128) {
+              this.writeU8(object);
+            } else if (object < 256) {
+              this.writeU8(204);
+              this.writeU8(object);
+            } else if (object < 65536) {
+              this.writeU8(205);
+              this.writeU16(object);
+            } else if (object < 4294967296) {
+              this.writeU8(206);
+              this.writeU32(object);
+            } else if (!this.useBigInt64) {
+              this.writeU8(207);
+              this.writeU64(object);
+            } else {
+              this.encodeNumberAsFloat(object);
+            }
+          } else {
+            if (object >= -32) {
+              this.writeU8(224 | object + 32);
+            } else if (object >= -128) {
+              this.writeU8(208);
+              this.writeI8(object);
+            } else if (object >= -32768) {
+              this.writeU8(209);
+              this.writeI16(object);
+            } else if (object >= -2147483648) {
+              this.writeU8(210);
+              this.writeI32(object);
+            } else if (!this.useBigInt64) {
+              this.writeU8(211);
+              this.writeI64(object);
+            } else {
+              this.encodeNumberAsFloat(object);
+            }
+          }
+        } else {
+          this.encodeNumberAsFloat(object);
+        }
+      }
+      encodeNumberAsFloat(object) {
+        if (this.forceFloat32) {
+          this.writeU8(202);
+          this.writeF32(object);
+        } else {
+          this.writeU8(203);
+          this.writeF64(object);
+        }
+      }
+      encodeBigInt64(object) {
+        if (object >= BigInt(0)) {
+          this.writeU8(207);
+          this.writeBigUint64(object);
+        } else {
+          this.writeU8(211);
+          this.writeBigInt64(object);
+        }
+      }
+      writeStringHeader(byteLength) {
+        if (byteLength < 32) {
+          this.writeU8(160 + byteLength);
+        } else if (byteLength < 256) {
+          this.writeU8(217);
+          this.writeU8(byteLength);
+        } else if (byteLength < 65536) {
+          this.writeU8(218);
+          this.writeU16(byteLength);
+        } else if (byteLength < 4294967296) {
+          this.writeU8(219);
+          this.writeU32(byteLength);
+        } else {
+          throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
+        }
+      }
+      encodeString(object) {
+        const maxHeaderSize = 1 + 4;
+        const byteLength = utf8Count(object);
+        this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+        this.writeStringHeader(byteLength);
+        utf8Encode(object, this.bytes, this.pos);
+        this.pos += byteLength;
+      }
+      encodeObject(object, depth) {
+        const ext = this.extensionCodec.tryToEncode(object, this.context);
+        if (ext != null) {
+          this.encodeExtension(ext);
+        } else if (Array.isArray(object)) {
+          this.encodeArray(object, depth);
+        } else if (ArrayBuffer.isView(object)) {
+          this.encodeBinary(object);
+        } else if (typeof object === "object") {
+          this.encodeMap(object, depth);
+        } else {
+          throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+        }
+      }
+      encodeBinary(object) {
+        const size = object.byteLength;
+        if (size < 256) {
+          this.writeU8(196);
+          this.writeU8(size);
+        } else if (size < 65536) {
+          this.writeU8(197);
+          this.writeU16(size);
+        } else if (size < 4294967296) {
+          this.writeU8(198);
+          this.writeU32(size);
+        } else {
+          throw new Error(`Too large binary: ${size}`);
+        }
+        const bytes = ensureUint8Array(object);
+        this.writeU8a(bytes);
+      }
+      encodeArray(object, depth) {
+        const size = object.length;
+        if (size < 16) {
+          this.writeU8(144 + size);
+        } else if (size < 65536) {
+          this.writeU8(220);
+          this.writeU16(size);
+        } else if (size < 4294967296) {
+          this.writeU8(221);
+          this.writeU32(size);
+        } else {
+          throw new Error(`Too large array: ${size}`);
+        }
+        for (const item of object) {
+          this.doEncode(item, depth + 1);
+        }
+      }
+      countWithoutUndefined(object, keys) {
+        let count = 0;
+        for (const key of keys) {
+          if (object[key] !== void 0) {
+            count++;
+          }
+        }
+        return count;
+      }
+      encodeMap(object, depth) {
+        const keys = Object.keys(object);
+        if (this.sortKeys) {
+          keys.sort();
+        }
+        const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+        if (size < 16) {
+          this.writeU8(128 + size);
+        } else if (size < 65536) {
+          this.writeU8(222);
+          this.writeU16(size);
+        } else if (size < 4294967296) {
+          this.writeU8(223);
+          this.writeU32(size);
+        } else {
+          throw new Error(`Too large map object: ${size}`);
+        }
+        for (const key of keys) {
+          const value = object[key];
+          if (!(this.ignoreUndefined && value === void 0)) {
+            this.encodeString(key);
+            this.doEncode(value, depth + 1);
+          }
+        }
+      }
+      encodeExtension(ext) {
+        if (typeof ext.data === "function") {
+          const data = ext.data(this.pos + 6);
+          const size2 = data.length;
+          if (size2 >= 4294967296) {
+            throw new Error(`Too large extension object: ${size2}`);
+          }
+          this.writeU8(201);
+          this.writeU32(size2);
+          this.writeI8(ext.type);
+          this.writeU8a(data);
+          return;
+        }
+        const size = ext.data.length;
+        if (size === 1) {
+          this.writeU8(212);
+        } else if (size === 2) {
+          this.writeU8(213);
+        } else if (size === 4) {
+          this.writeU8(214);
+        } else if (size === 8) {
+          this.writeU8(215);
+        } else if (size === 16) {
+          this.writeU8(216);
+        } else if (size < 256) {
+          this.writeU8(199);
+          this.writeU8(size);
+        } else if (size < 65536) {
+          this.writeU8(200);
+          this.writeU16(size);
+        } else if (size < 4294967296) {
+          this.writeU8(201);
+          this.writeU32(size);
+        } else {
+          throw new Error(`Too large extension object: ${size}`);
+        }
+        this.writeI8(ext.type);
+        this.writeU8a(ext.data);
+      }
+      writeU8(value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setUint8(this.pos, value);
+        this.pos++;
+      }
+      writeU8a(values) {
+        const size = values.length;
+        this.ensureBufferSizeToWrite(size);
+        this.bytes.set(values, this.pos);
+        this.pos += size;
+      }
+      writeI8(value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setInt8(this.pos, value);
+        this.pos++;
+      }
+      writeU16(value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setUint16(this.pos, value);
+        this.pos += 2;
+      }
+      writeI16(value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setInt16(this.pos, value);
+        this.pos += 2;
+      }
+      writeU32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setUint32(this.pos, value);
+        this.pos += 4;
+      }
+      writeI32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setInt32(this.pos, value);
+        this.pos += 4;
+      }
+      writeF32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setFloat32(this.pos, value);
+        this.pos += 4;
+      }
+      writeF64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setFloat64(this.pos, value);
+        this.pos += 8;
+      }
+      writeU64(value) {
+        this.ensureBufferSizeToWrite(8);
+        setUint64(this.view, this.pos, value);
+        this.pos += 8;
+      }
+      writeI64(value) {
+        this.ensureBufferSizeToWrite(8);
+        setInt64(this.view, this.pos, value);
+        this.pos += 8;
+      }
+      writeBigUint64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setBigUint64(this.pos, value);
+        this.pos += 8;
+      }
+      writeBigInt64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setBigInt64(this.pos, value);
+        this.pos += 8;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/encode.mjs
+function encode(value, options) {
+  const encoder = new Encoder(options);
+  return encoder.encodeSharedRef(value);
+}
+var init_encode = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/encode.mjs"() {
+    "use strict";
+    init_Encoder();
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/prettyByte.mjs
+function prettyByte(byte) {
+  return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
+}
+var init_prettyByte = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/prettyByte.mjs"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/CachedKeyDecoder.mjs
+var DEFAULT_MAX_KEY_LENGTH, DEFAULT_MAX_LENGTH_PER_KEY, CachedKeyDecoder;
+var init_CachedKeyDecoder = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/CachedKeyDecoder.mjs"() {
+    "use strict";
+    init_utf8();
+    DEFAULT_MAX_KEY_LENGTH = 16;
+    DEFAULT_MAX_LENGTH_PER_KEY = 16;
+    CachedKeyDecoder = class {
+      hit = 0;
+      miss = 0;
+      caches;
+      maxKeyLength;
+      maxLengthPerKey;
+      constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+        this.maxKeyLength = maxKeyLength;
+        this.maxLengthPerKey = maxLengthPerKey;
+        this.caches = [];
+        for (let i = 0; i < this.maxKeyLength; i++) {
+          this.caches.push([]);
+        }
+      }
+      canBeCached(byteLength) {
+        return byteLength > 0 && byteLength <= this.maxKeyLength;
+      }
+      find(bytes, inputOffset, byteLength) {
+        const records = this.caches[byteLength - 1];
+        FIND_CHUNK: for (const record of records) {
+          const recordBytes = record.bytes;
+          for (let j = 0; j < byteLength; j++) {
+            if (recordBytes[j] !== bytes[inputOffset + j]) {
+              continue FIND_CHUNK;
+            }
+          }
+          return record.str;
+        }
+        return null;
+      }
+      store(bytes, value) {
+        const records = this.caches[bytes.length - 1];
+        const record = { bytes, str: value };
+        if (records.length >= this.maxLengthPerKey) {
+          records[Math.random() * records.length | 0] = record;
+        } else {
+          records.push(record);
+        }
+      }
+      decode(bytes, inputOffset, byteLength) {
+        const cachedValue = this.find(bytes, inputOffset, byteLength);
+        if (cachedValue != null) {
+          this.hit++;
+          return cachedValue;
+        }
+        this.miss++;
+        const str = utf8DecodeJs(bytes, inputOffset, byteLength);
+        const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+        this.store(slicedCopyOfBytes, str);
+        return str;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/Decoder.mjs
+var STATE_ARRAY, STATE_MAP_KEY, STATE_MAP_VALUE, mapKeyConverter, StackPool, HEAD_BYTE_REQUIRED, EMPTY_VIEW, EMPTY_BYTES, MORE_DATA, sharedCachedKeyDecoder, Decoder;
+var init_Decoder = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/Decoder.mjs"() {
+    "use strict";
+    init_prettyByte();
+    init_ExtensionCodec();
+    init_int();
+    init_utf8();
+    init_typedArrays();
+    init_CachedKeyDecoder();
+    init_DecodeError();
+    STATE_ARRAY = "array";
+    STATE_MAP_KEY = "map_key";
+    STATE_MAP_VALUE = "map_value";
+    mapKeyConverter = (key) => {
+      if (typeof key === "string" || typeof key === "number") {
+        return key;
+      }
+      throw new DecodeError("The type of key must be string or number but " + typeof key);
+    };
+    StackPool = class {
+      stack = [];
+      stackHeadPosition = -1;
+      get length() {
+        return this.stackHeadPosition + 1;
+      }
+      top() {
+        return this.stack[this.stackHeadPosition];
+      }
+      pushArrayState(size) {
+        const state = this.getUninitializedStateFromPool();
+        state.type = STATE_ARRAY;
+        state.position = 0;
+        state.size = size;
+        state.array = new Array(size);
+      }
+      pushMapState(size) {
+        const state = this.getUninitializedStateFromPool();
+        state.type = STATE_MAP_KEY;
+        state.readCount = 0;
+        state.size = size;
+        state.map = {};
+      }
+      getUninitializedStateFromPool() {
+        this.stackHeadPosition++;
+        if (this.stackHeadPosition === this.stack.length) {
+          const partialState = {
+            type: void 0,
+            size: 0,
+            array: void 0,
+            position: 0,
+            readCount: 0,
+            map: void 0,
+            key: null
+          };
+          this.stack.push(partialState);
+        }
+        return this.stack[this.stackHeadPosition];
+      }
+      release(state) {
+        const topStackState = this.stack[this.stackHeadPosition];
+        if (topStackState !== state) {
+          throw new Error("Invalid stack state. Released state is not on top of the stack.");
+        }
+        if (state.type === STATE_ARRAY) {
+          const partialState = state;
+          partialState.size = 0;
+          partialState.array = void 0;
+          partialState.position = 0;
+          partialState.type = void 0;
+        }
+        if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
+          const partialState = state;
+          partialState.size = 0;
+          partialState.map = void 0;
+          partialState.readCount = 0;
+          partialState.type = void 0;
+        }
+        this.stackHeadPosition--;
+      }
+      reset() {
+        this.stack.length = 0;
+        this.stackHeadPosition = -1;
+      }
+    };
+    HEAD_BYTE_REQUIRED = -1;
+    EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+    EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+    try {
+      EMPTY_VIEW.getInt8(0);
+    } catch (e) {
+      if (!(e instanceof RangeError)) {
+        throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+      }
+    }
+    MORE_DATA = new RangeError("Insufficient data");
+    sharedCachedKeyDecoder = new CachedKeyDecoder();
+    Decoder = class _Decoder {
+      extensionCodec;
+      context;
+      useBigInt64;
+      rawStrings;
+      maxStrLength;
+      maxBinLength;
+      maxArrayLength;
+      maxMapLength;
+      maxExtLength;
+      keyDecoder;
+      mapKeyConverter;
+      totalPos = 0;
+      pos = 0;
+      view = EMPTY_VIEW;
+      bytes = EMPTY_BYTES;
+      headByte = HEAD_BYTE_REQUIRED;
+      stack = new StackPool();
+      entered = false;
+      constructor(options) {
+        this.extensionCodec = options?.extensionCodec ?? ExtensionCodec.defaultCodec;
+        this.context = options?.context;
+        this.useBigInt64 = options?.useBigInt64 ?? false;
+        this.rawStrings = options?.rawStrings ?? false;
+        this.maxStrLength = options?.maxStrLength ?? UINT32_MAX;
+        this.maxBinLength = options?.maxBinLength ?? UINT32_MAX;
+        this.maxArrayLength = options?.maxArrayLength ?? UINT32_MAX;
+        this.maxMapLength = options?.maxMapLength ?? UINT32_MAX;
+        this.maxExtLength = options?.maxExtLength ?? UINT32_MAX;
+        this.keyDecoder = options?.keyDecoder !== void 0 ? options.keyDecoder : sharedCachedKeyDecoder;
+        this.mapKeyConverter = options?.mapKeyConverter ?? mapKeyConverter;
+      }
+      clone() {
+        return new _Decoder({
+          extensionCodec: this.extensionCodec,
+          context: this.context,
+          useBigInt64: this.useBigInt64,
+          rawStrings: this.rawStrings,
+          maxStrLength: this.maxStrLength,
+          maxBinLength: this.maxBinLength,
+          maxArrayLength: this.maxArrayLength,
+          maxMapLength: this.maxMapLength,
+          maxExtLength: this.maxExtLength,
+          keyDecoder: this.keyDecoder
+        });
+      }
+      reinitializeState() {
+        this.totalPos = 0;
+        this.headByte = HEAD_BYTE_REQUIRED;
+        this.stack.reset();
+      }
+      setBuffer(buffer) {
+        const bytes = ensureUint8Array(buffer);
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        this.pos = 0;
+      }
+      appendBuffer(buffer) {
+        if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
+          this.setBuffer(buffer);
+        } else {
+          const remainingData = this.bytes.subarray(this.pos);
+          const newData = ensureUint8Array(buffer);
+          const newBuffer = new Uint8Array(remainingData.length + newData.length);
+          newBuffer.set(remainingData);
+          newBuffer.set(newData, remainingData.length);
+          this.setBuffer(newBuffer);
+        }
+      }
+      hasRemaining(size) {
+        return this.view.byteLength - this.pos >= size;
+      }
+      createExtraByteError(posToShow) {
+        const { view, pos } = this;
+        return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);
+      }
+      /**
+       * @throws {@link DecodeError}
+       * @throws {@link RangeError}
+       */
+      decode(buffer) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.decode(buffer);
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.setBuffer(buffer);
+          const object = this.doDecodeSync();
+          if (this.hasRemaining(1)) {
+            throw this.createExtraByteError(this.pos);
+          }
+          return object;
+        } finally {
+          this.entered = false;
+        }
+      }
+      *decodeMulti(buffer) {
+        if (this.entered) {
+          const instance = this.clone();
+          yield* instance.decodeMulti(buffer);
+          return;
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.setBuffer(buffer);
+          while (this.hasRemaining(1)) {
+            yield this.doDecodeSync();
+          }
+        } finally {
+          this.entered = false;
+        }
+      }
+      async decodeAsync(stream) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.decodeAsync(stream);
+        }
+        try {
+          this.entered = true;
+          let decoded = false;
+          let object;
+          for await (const buffer of stream) {
+            if (decoded) {
+              this.entered = false;
+              throw this.createExtraByteError(this.totalPos);
+            }
+            this.appendBuffer(buffer);
+            try {
+              object = this.doDecodeSync();
+              decoded = true;
+            } catch (e) {
+              if (!(e instanceof RangeError)) {
+                throw e;
+              }
+            }
+            this.totalPos += this.pos;
+          }
+          if (decoded) {
+            if (this.hasRemaining(1)) {
+              throw this.createExtraByteError(this.totalPos);
+            }
+            return object;
+          }
+          const { headByte, pos, totalPos } = this;
+          throw new RangeError(`Insufficient data in parsing ${prettyByte(headByte)} at ${totalPos} (${pos} in the current buffer)`);
+        } finally {
+          this.entered = false;
+        }
+      }
+      decodeArrayStream(stream) {
+        return this.decodeMultiAsync(stream, true);
+      }
+      decodeStream(stream) {
+        return this.decodeMultiAsync(stream, false);
+      }
+      async *decodeMultiAsync(stream, isArray) {
+        if (this.entered) {
+          const instance = this.clone();
+          yield* instance.decodeMultiAsync(stream, isArray);
+          return;
+        }
+        try {
+          this.entered = true;
+          let isArrayHeaderRequired = isArray;
+          let arrayItemsLeft = -1;
+          for await (const buffer of stream) {
+            if (isArray && arrayItemsLeft === 0) {
+              throw this.createExtraByteError(this.totalPos);
+            }
+            this.appendBuffer(buffer);
+            if (isArrayHeaderRequired) {
+              arrayItemsLeft = this.readArraySize();
+              isArrayHeaderRequired = false;
+              this.complete();
+            }
+            try {
+              while (true) {
+                yield this.doDecodeSync();
+                if (--arrayItemsLeft === 0) {
+                  break;
+                }
+              }
+            } catch (e) {
+              if (!(e instanceof RangeError)) {
+                throw e;
+              }
+            }
+            this.totalPos += this.pos;
+          }
+        } finally {
+          this.entered = false;
+        }
+      }
+      doDecodeSync() {
+        DECODE: while (true) {
+          const headByte = this.readHeadByte();
+          let object;
+          if (headByte >= 224) {
+            object = headByte - 256;
+          } else if (headByte < 192) {
+            if (headByte < 128) {
+              object = headByte;
+            } else if (headByte < 144) {
+              const size = headByte - 128;
+              if (size !== 0) {
+                this.pushMapState(size);
+                this.complete();
+                continue DECODE;
+              } else {
+                object = {};
+              }
+            } else if (headByte < 160) {
+              const size = headByte - 144;
+              if (size !== 0) {
+                this.pushArrayState(size);
+                this.complete();
+                continue DECODE;
+              } else {
+                object = [];
+              }
+            } else {
+              const byteLength = headByte - 160;
+              object = this.decodeString(byteLength, 0);
+            }
+          } else if (headByte === 192) {
+            object = null;
+          } else if (headByte === 194) {
+            object = false;
+          } else if (headByte === 195) {
+            object = true;
+          } else if (headByte === 202) {
+            object = this.readF32();
+          } else if (headByte === 203) {
+            object = this.readF64();
+          } else if (headByte === 204) {
+            object = this.readU8();
+          } else if (headByte === 205) {
+            object = this.readU16();
+          } else if (headByte === 206) {
+            object = this.readU32();
+          } else if (headByte === 207) {
+            if (this.useBigInt64) {
+              object = this.readU64AsBigInt();
+            } else {
+              object = this.readU64();
+            }
+          } else if (headByte === 208) {
+            object = this.readI8();
+          } else if (headByte === 209) {
+            object = this.readI16();
+          } else if (headByte === 210) {
+            object = this.readI32();
+          } else if (headByte === 211) {
+            if (this.useBigInt64) {
+              object = this.readI64AsBigInt();
+            } else {
+              object = this.readI64();
+            }
+          } else if (headByte === 217) {
+            const byteLength = this.lookU8();
+            object = this.decodeString(byteLength, 1);
+          } else if (headByte === 218) {
+            const byteLength = this.lookU16();
+            object = this.decodeString(byteLength, 2);
+          } else if (headByte === 219) {
+            const byteLength = this.lookU32();
+            object = this.decodeString(byteLength, 4);
+          } else if (headByte === 220) {
+            const size = this.readU16();
+            if (size !== 0) {
+              this.pushArrayState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = [];
+            }
+          } else if (headByte === 221) {
+            const size = this.readU32();
+            if (size !== 0) {
+              this.pushArrayState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = [];
+            }
+          } else if (headByte === 222) {
+            const size = this.readU16();
+            if (size !== 0) {
+              this.pushMapState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = {};
+            }
+          } else if (headByte === 223) {
+            const size = this.readU32();
+            if (size !== 0) {
+              this.pushMapState(size);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = {};
+            }
+          } else if (headByte === 196) {
+            const size = this.lookU8();
+            object = this.decodeBinary(size, 1);
+          } else if (headByte === 197) {
+            const size = this.lookU16();
+            object = this.decodeBinary(size, 2);
+          } else if (headByte === 198) {
+            const size = this.lookU32();
+            object = this.decodeBinary(size, 4);
+          } else if (headByte === 212) {
+            object = this.decodeExtension(1, 0);
+          } else if (headByte === 213) {
+            object = this.decodeExtension(2, 0);
+          } else if (headByte === 214) {
+            object = this.decodeExtension(4, 0);
+          } else if (headByte === 215) {
+            object = this.decodeExtension(8, 0);
+          } else if (headByte === 216) {
+            object = this.decodeExtension(16, 0);
+          } else if (headByte === 199) {
+            const size = this.lookU8();
+            object = this.decodeExtension(size, 1);
+          } else if (headByte === 200) {
+            const size = this.lookU16();
+            object = this.decodeExtension(size, 2);
+          } else if (headByte === 201) {
+            const size = this.lookU32();
+            object = this.decodeExtension(size, 4);
+          } else {
+            throw new DecodeError(`Unrecognized type byte: ${prettyByte(headByte)}`);
+          }
+          this.complete();
+          const stack = this.stack;
+          while (stack.length > 0) {
+            const state = stack.top();
+            if (state.type === STATE_ARRAY) {
+              state.array[state.position] = object;
+              state.position++;
+              if (state.position === state.size) {
+                object = state.array;
+                stack.release(state);
+              } else {
+                continue DECODE;
+              }
+            } else if (state.type === STATE_MAP_KEY) {
+              if (object === "__proto__") {
+                throw new DecodeError("The key __proto__ is not allowed");
+              }
+              state.key = this.mapKeyConverter(object);
+              state.type = STATE_MAP_VALUE;
+              continue DECODE;
+            } else {
+              state.map[state.key] = object;
+              state.readCount++;
+              if (state.readCount === state.size) {
+                object = state.map;
+                stack.release(state);
+              } else {
+                state.key = null;
+                state.type = STATE_MAP_KEY;
+                continue DECODE;
+              }
+            }
+          }
+          return object;
+        }
+      }
+      readHeadByte() {
+        if (this.headByte === HEAD_BYTE_REQUIRED) {
+          this.headByte = this.readU8();
+        }
+        return this.headByte;
+      }
+      complete() {
+        this.headByte = HEAD_BYTE_REQUIRED;
+      }
+      readArraySize() {
+        const headByte = this.readHeadByte();
+        switch (headByte) {
+          case 220:
+            return this.readU16();
+          case 221:
+            return this.readU32();
+          default: {
+            if (headByte < 160) {
+              return headByte - 144;
+            } else {
+              throw new DecodeError(`Unrecognized array type byte: ${prettyByte(headByte)}`);
+            }
+          }
+        }
+      }
+      pushMapState(size) {
+        if (size > this.maxMapLength) {
+          throw new DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`);
+        }
+        this.stack.pushMapState(size);
+      }
+      pushArrayState(size) {
+        if (size > this.maxArrayLength) {
+          throw new DecodeError(`Max length exceeded: array length (${size}) > maxArrayLength (${this.maxArrayLength})`);
+        }
+        this.stack.pushArrayState(size);
+      }
+      decodeString(byteLength, headerOffset) {
+        if (!this.rawStrings || this.stateIsMapKey()) {
+          return this.decodeUtf8String(byteLength, headerOffset);
+        }
+        return this.decodeBinary(byteLength, headerOffset);
+      }
+      /**
+       * @throws {@link RangeError}
+       */
+      decodeUtf8String(byteLength, headerOffset) {
+        if (byteLength > this.maxStrLength) {
+          throw new DecodeError(`Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`);
+        }
+        if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
+          throw MORE_DATA;
+        }
+        const offset = this.pos + headerOffset;
+        let object;
+        if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
+          object = this.keyDecoder.decode(this.bytes, offset, byteLength);
+        } else {
+          object = utf8Decode(this.bytes, offset, byteLength);
+        }
+        this.pos += headerOffset + byteLength;
+        return object;
+      }
+      stateIsMapKey() {
+        if (this.stack.length > 0) {
+          const state = this.stack.top();
+          return state.type === STATE_MAP_KEY;
+        }
+        return false;
+      }
+      /**
+       * @throws {@link RangeError}
+       */
+      decodeBinary(byteLength, headOffset) {
+        if (byteLength > this.maxBinLength) {
+          throw new DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`);
+        }
+        if (!this.hasRemaining(byteLength + headOffset)) {
+          throw MORE_DATA;
+        }
+        const offset = this.pos + headOffset;
+        const object = this.bytes.subarray(offset, offset + byteLength);
+        this.pos += headOffset + byteLength;
+        return object;
+      }
+      decodeExtension(size, headOffset) {
+        if (size > this.maxExtLength) {
+          throw new DecodeError(`Max length exceeded: ext length (${size}) > maxExtLength (${this.maxExtLength})`);
+        }
+        const extType = this.view.getInt8(this.pos + headOffset);
+        const data = this.decodeBinary(
+          size,
+          headOffset + 1
+          /* extType */
+        );
+        return this.extensionCodec.decode(data, extType, this.context);
+      }
+      lookU8() {
+        return this.view.getUint8(this.pos);
+      }
+      lookU16() {
+        return this.view.getUint16(this.pos);
+      }
+      lookU32() {
+        return this.view.getUint32(this.pos);
+      }
+      readU8() {
+        const value = this.view.getUint8(this.pos);
+        this.pos++;
+        return value;
+      }
+      readI8() {
+        const value = this.view.getInt8(this.pos);
+        this.pos++;
+        return value;
+      }
+      readU16() {
+        const value = this.view.getUint16(this.pos);
+        this.pos += 2;
+        return value;
+      }
+      readI16() {
+        const value = this.view.getInt16(this.pos);
+        this.pos += 2;
+        return value;
+      }
+      readU32() {
+        const value = this.view.getUint32(this.pos);
+        this.pos += 4;
+        return value;
+      }
+      readI32() {
+        const value = this.view.getInt32(this.pos);
+        this.pos += 4;
+        return value;
+      }
+      readU64() {
+        const value = getUint64(this.view, this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readI64() {
+        const value = getInt64(this.view, this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readU64AsBigInt() {
+        const value = this.view.getBigUint64(this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readI64AsBigInt() {
+        const value = this.view.getBigInt64(this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readF32() {
+        const value = this.view.getFloat32(this.pos);
+        this.pos += 4;
+        return value;
+      }
+      readF64() {
+        const value = this.view.getFloat64(this.pos);
+        this.pos += 8;
+        return value;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/decode.mjs
+function decode(buffer, options) {
+  const decoder = new Decoder(options);
+  return decoder.decode(buffer);
+}
+function decodeMulti(buffer, options) {
+  const decoder = new Decoder(options);
+  return decoder.decodeMulti(buffer);
+}
+var init_decode = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/decode.mjs"() {
+    "use strict";
+    init_Decoder();
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/stream.mjs
+function isAsyncIterable(object) {
+  return object[Symbol.asyncIterator] != null;
+}
+async function* asyncIterableFromStream(stream) {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        return;
+      }
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function ensureAsyncIterable(streamLike) {
+  if (isAsyncIterable(streamLike)) {
+    return streamLike;
+  } else {
+    return asyncIterableFromStream(streamLike);
+  }
+}
+var init_stream = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/utils/stream.mjs"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/decodeAsync.mjs
+async function decodeAsync(streamLike, options) {
+  const stream = ensureAsyncIterable(streamLike);
+  const decoder = new Decoder(options);
+  return decoder.decodeAsync(stream);
+}
+function decodeArrayStream(streamLike, options) {
+  const stream = ensureAsyncIterable(streamLike);
+  const decoder = new Decoder(options);
+  return decoder.decodeArrayStream(stream);
+}
+function decodeMultiStream(streamLike, options) {
+  const stream = ensureAsyncIterable(streamLike);
+  const decoder = new Decoder(options);
+  return decoder.decodeStream(stream);
+}
+var init_decodeAsync = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/decodeAsync.mjs"() {
+    "use strict";
+    init_Decoder();
+    init_stream();
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/index.mjs
+var dist_exports = {};
+__export(dist_exports, {
+  DecodeError: () => DecodeError,
+  Decoder: () => Decoder,
+  EXT_TIMESTAMP: () => EXT_TIMESTAMP,
+  Encoder: () => Encoder,
+  ExtData: () => ExtData,
+  ExtensionCodec: () => ExtensionCodec,
+  decode: () => decode,
+  decodeArrayStream: () => decodeArrayStream,
+  decodeAsync: () => decodeAsync,
+  decodeMulti: () => decodeMulti,
+  decodeMultiStream: () => decodeMultiStream,
+  decodeTimestampExtension: () => decodeTimestampExtension,
+  decodeTimestampToTimeSpec: () => decodeTimestampToTimeSpec,
+  encode: () => encode,
+  encodeDateToTimeSpec: () => encodeDateToTimeSpec,
+  encodeTimeSpecToTimestamp: () => encodeTimeSpecToTimestamp,
+  encodeTimestampExtension: () => encodeTimestampExtension
+});
+var init_dist = __esm({
+  "../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.esm/index.mjs"() {
+    "use strict";
+    init_encode();
+    init_decode();
+    init_decodeAsync();
+    init_Decoder();
+    init_DecodeError();
+    init_Encoder();
+    init_ExtensionCodec();
+    init_ExtData();
+    init_timestamp();
+  }
+});
+
+// src/serializers/MessagePackSerializer.ts
+var MessagePackSerializer_exports = {};
+__export(MessagePackSerializer_exports, {
+  MessagePackSerializer: () => MessagePackSerializer
+});
+var MessagePackSerializer;
+var init_MessagePackSerializer = __esm({
+  "src/serializers/MessagePackSerializer.ts"() {
+    "use strict";
+    MessagePackSerializer = class {
+      msgpack;
+      constructor() {
+        try {
+          this.msgpack = (init_dist(), __toCommonJS(dist_exports));
+        } catch (_e) {
+          throw new Error(
+            "MessagePackSerializer requires @msgpack/msgpack. Please install it: bun add @msgpack/msgpack"
+          );
+        }
+      }
+      serialize(job) {
+        const id = job.id || `${Date.now()}-${crypto.randomUUID()}`;
+        const properties = {};
+        for (const key in job) {
+          if (Object.hasOwn(job, key) && typeof job[key] !== "function") {
+            properties[key] = job[key];
+          }
+        }
+        const encoded = this.msgpack.encode(properties);
+        const data = Buffer.from(encoded).toString("base64");
+        return {
+          id,
+          type: "msgpack",
+          data,
+          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(serialized) {
+        if (serialized.type !== "msgpack") {
+          throw new Error('Invalid serialization type: expected "msgpack"');
+        }
+        const buffer = Buffer.from(serialized.data, "base64");
+        const properties = this.msgpack.decode(buffer);
+        const job = /* @__PURE__ */ Object.create({});
+        Object.assign(job, properties);
+        job.id = serialized.id;
+        if (serialized.groupId) {
+          job.groupId = serialized.groupId;
+        }
+        if (serialized.priority) {
+          job.priority = serialized.priority;
+        }
+        if (serialized.delaySeconds !== void 0) {
+          job.delaySeconds = serialized.delaySeconds;
+        }
+        if (serialized.attempts !== void 0) {
+          job.attempts = serialized.attempts;
+        }
+        return job;
+      }
+    };
+  }
+});
+
 // src/Scheduler.ts
 var Scheduler_exports = {};
 __export(Scheduler_exports, {
@@ -1085,6 +3361,9 @@ var init_Scheduler = __esm({
       prefix;
       get client() {
         const driver = this.manager.getDriver(this.manager.getDefaultConnection());
+        if (!driver || !("client" in driver)) {
+          throw new Error("[Scheduler] Driver does not support Redis client access");
+        }
         return driver.client;
       }
       /**
@@ -1097,7 +3376,11 @@ var init_Scheduler = __esm({
           nextRun,
           enabled: true
         };
-        const pipe = this.client.pipeline();
+        const client = this.client;
+        if (typeof client.pipeline !== "function") {
+          throw new Error("[Scheduler] Redis client does not support pipeline");
+        }
+        const pipe = client.pipeline();
         pipe.hset(`${this.prefix}schedule:${config.id}`, {
           ...fullConfig,
           job: JSON.stringify(fullConfig.job)
@@ -1109,7 +3392,11 @@ var init_Scheduler = __esm({
        * Remove a scheduled job.
        */
       async remove(id) {
-        const pipe = this.client.pipeline();
+        const client = this.client;
+        if (typeof client.pipeline !== "function") {
+          throw new Error("[Scheduler] Redis client does not support pipeline");
+        }
+        const pipe = client.pipeline();
         pipe.del(`${this.prefix}schedule:${id}`);
         pipe.zrem(`${this.prefix}schedules`, id);
         await pipe.exec();
@@ -1118,10 +3405,14 @@ var init_Scheduler = __esm({
        * List all scheduled jobs.
        */
       async list() {
-        const ids = await this.client.zrange(`${this.prefix}schedules`, 0, -1);
+        const client = this.client;
+        if (typeof client.zrange !== "function") {
+          throw new Error("[Scheduler] Redis client does not support zrange");
+        }
+        const ids = await client.zrange(`${this.prefix}schedules`, 0, -1);
         const configs = [];
         for (const id of ids) {
-          const data = await this.client.hgetall(`${this.prefix}schedule:${id}`);
+          const data = await client.hgetall?.(`${this.prefix}schedule:${id}`);
           if (data?.id) {
             configs.push({
               ...data,
@@ -1138,7 +3429,8 @@ var init_Scheduler = __esm({
        * Run a scheduled job immediately (out of schedule).
        */
       async runNow(id) {
-        const data = await this.client.hgetall(`${this.prefix}schedule:${id}`);
+        const client = this.client;
+        const data = await client.hgetall?.(`${this.prefix}schedule:${id}`);
         if (data?.id) {
           const serialized = JSON.parse(data.job);
           const serializer = this.manager.getSerializer();
@@ -1151,14 +3443,21 @@ var init_Scheduler = __esm({
        * This should be called periodically (e.g. every minute).
        */
       async tick() {
+        const client = this.client;
+        if (typeof client.zrangebyscore !== "function") {
+          throw new Error("[Scheduler] Redis client does not support zrangebyscore");
+        }
         const now = Date.now();
-        const dueIds = await this.client.zrangebyscore(`${this.prefix}schedules`, 0, now);
+        const dueIds = await 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 (typeof client.set !== "function") {
+            continue;
+          }
+          const lock = await client.set(lockKey, "1", "EX", 10, "NX");
           if (lock === "OK") {
-            const data = await this.client.hgetall(`${this.prefix}schedule:${id}`);
+            const data = await client.hgetall?.(`${this.prefix}schedule:${id}`);
             if (data?.id && data.enabled === "true") {
               try {
                 const serializedJob = JSON.parse(data.job);
@@ -1166,16 +3465,19 @@ var init_Scheduler = __esm({
                 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();
+                if (typeof client.pipeline === "function") {
+                  const pipe = 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);
+                const error = err instanceof Error ? err : new Error(String(err));
+                console.error(`[Scheduler] Failed to process schedule ${id}:`, error.message);
               }
             }
           }
@@ -1189,6 +3491,7 @@ var init_Scheduler = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BufferedPersistence: () => BufferedPersistence,
   ClassNameSerializer: () => ClassNameSerializer,
   Consumer: () => Consumer,
   DatabaseDriver: () => DatabaseDriver,
@@ -1208,6 +3511,10 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/Consumer.ts
+var import_node_events = require("events");
+var import_p_limit = __toESM(require("p-limit"), 1);
+
 // src/Worker.ts
 var Worker = class {
   constructor(options = {}) {
@@ -1265,18 +3572,40 @@ var Worker = class {
 };
 
 // src/Consumer.ts
-var Consumer = class {
+var Consumer = class extends import_node_events.EventEmitter {
   constructor(queueManager, options) {
+    super();
     this.queueManager = queueManager;
     this.options = options;
   }
   running = false;
   stopRequested = false;
-  workerId = `worker-${Math.random().toString(36).substring(2, 8)}`;
+  workerId = `worker-${crypto.randomUUID()}`;
   heartbeatTimer = null;
+  groupLimiters = /* @__PURE__ */ new Map();
+  stats = {
+    processed: 0,
+    failed: 0,
+    retried: 0,
+    active: 0
+  };
   get connectionName() {
     return this.options.connection ?? this.queueManager.getDefaultConnection();
   }
+  /**
+   * Log debug message.
+   */
+  log(message, data) {
+    if (this.options.debug) {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const prefix = `[Consumer:${this.workerId}] [${timestamp}]`;
+      if (data) {
+        console.log(prefix, message, data);
+      } else {
+        console.log(prefix, message);
+      }
+    }
+  }
   /**
    * Start the consumer loop.
    */
@@ -1287,19 +3616,36 @@ var Consumer = class {
     this.running = true;
     this.stopRequested = false;
     const worker = new Worker(this.options.workerOptions);
-    const pollInterval = this.options.pollInterval ?? 1e3;
+    let currentPollInterval = this.options.pollInterval ?? 1e3;
+    const minPollInterval = this.options.minPollInterval ?? 100;
+    const maxPollInterval = this.options.maxPollInterval ?? 5e3;
+    const backoffMultiplier = this.options.backoffMultiplier ?? 1.5;
     const keepAlive = this.options.keepAlive ?? true;
-    console.log("[Consumer] Started", {
+    const concurrency = this.options.concurrency ?? 1;
+    const batchSize = this.options.batchSize ?? 1;
+    const useBlocking = this.options.useBlocking ?? true;
+    const blockingTimeout = this.options.blockingTimeout ?? 5;
+    this.log("Started", {
       queues: this.options.queues,
       connection: this.options.connection,
-      workerId: this.workerId
+      workerId: this.workerId,
+      concurrency,
+      batchSize
     });
     if (this.options.monitor) {
       this.startHeartbeat();
-      await this.publishLog("info", `Consumer started on [${this.options.queues.join(", ")}]`);
+      await this.publishLog(
+        "info",
+        `Consumer started on [${this.options.queues.join(", ")}] with concurrency ${concurrency}`
+      );
     }
     while (this.running && !this.stopRequested) {
-      let processed = false;
+      const capacity = concurrency - this.stats.active;
+      if (capacity <= 0) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        continue;
+      }
+      const eligibleQueues = [];
       for (const queue of this.options.queues) {
         if (this.options.rateLimits?.[queue]) {
           const limit = this.options.rateLimits[queue];
@@ -1315,60 +3661,74 @@ var Consumer = class {
             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);
+        eligibleQueues.push(queue);
+      }
+      if (eligibleQueues.length === 0) {
+        await new Promise((resolve) => setTimeout(resolve, currentPollInterval));
+        continue;
+      }
+      let jobs = [];
+      let didBlock = false;
+      try {
+        const currentBatchSize = Math.min(batchSize, capacity);
+        const driver = this.queueManager.getDriver(this.connectionName);
+        if (currentBatchSize > 1) {
+          for (const queue of eligibleQueues) {
+            const fetched = await this.queueManager.popMany(
+              queue,
+              currentBatchSize,
+              this.connectionName
+            );
+            if (fetched.length > 0) {
+              jobs = fetched;
+              break;
             }
-            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);
-                });
+          }
+        } else {
+          if (useBlocking && driver.popBlocking) {
+            didBlock = true;
+            const job = await this.queueManager.popBlocking(
+              eligibleQueues,
+              blockingTimeout,
+              this.connectionName
+            );
+            if (job) {
+              jobs.push(job);
+            }
+          } else {
+            for (const queue of eligibleQueues) {
+              const job = await this.queueManager.pop(queue, this.connectionName);
+              if (job) {
+                jobs.push(job);
+                break;
               }
-            } 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 (jobs.length > 0) {
+          this.stats.active += jobs.length;
+          currentPollInterval = minPollInterval;
+          for (const job of jobs) {
+            this.runJob(job, worker).finally(() => {
+              this.stats.active--;
+            });
+          }
+          await new Promise((resolve) => setTimeout(resolve, 0));
+          continue;
+        }
+      } catch (error) {
+        console.error("[Consumer] Loop error:", error);
       }
-      if (!processed && !keepAlive) {
+      if (this.stats.active === 0 && !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));
+      if (!this.stopRequested) {
+        if (!didBlock) {
+          await new Promise((resolve) => setTimeout(resolve, currentPollInterval));
+          currentPollInterval = Math.min(currentPollInterval * backoffMultiplier, maxPollInterval);
+        }
+      } else {
+        await new Promise((resolve) => setTimeout(resolve, 50));
       }
     }
     this.running = false;
@@ -1376,7 +3736,89 @@ var Consumer = class {
     if (this.options.monitor) {
       await this.publishLog("info", "Consumer stopped");
     }
-    console.log("[Consumer] Stopped");
+    this.log("Stopped");
+  }
+  /**
+   * Run a job with concurrency controls.
+   */
+  async runJob(job, worker) {
+    if (!job.groupId || this.options.groupJobsSequential === false) {
+      return this.handleJob(job, worker);
+    }
+    let limiter = this.groupLimiters.get(job.groupId);
+    if (!limiter) {
+      limiter = (0, import_p_limit.default)(1);
+      this.groupLimiters.set(job.groupId, limiter);
+    }
+    if (limiter.pendingCount > 0) {
+      this.log(`Job ${job.id} queued behind group ${job.groupId}`);
+    }
+    await limiter(async () => {
+      await this.handleJob(job, worker);
+    });
+    if (limiter.activeCount === 0 && limiter.pendingCount === 0) {
+      this.groupLimiters.delete(job.groupId);
+    }
+  }
+  /**
+   * Handle a single job.
+   */
+  async handleJob(job, worker) {
+    const currentQueue = job.queueName || "default";
+    const startTime = Date.now();
+    this.log(`Processing job ${job.id} from ${currentQueue}`);
+    this.emit("job:started", { job, queue: currentQueue });
+    if (this.options.monitor) {
+      await this.publishLog("info", `Processing job: ${job.id}`, job.id);
+    }
+    try {
+      await worker.process(job);
+      const duration = Date.now() - startTime;
+      this.stats.processed++;
+      this.emit("job:processed", { job, duration, queue: currentQueue });
+      this.log(`Completed job ${job.id} in ${duration}ms`);
+      if (this.options.monitor) {
+        await this.publishLog("success", `Completed job: ${job.id}`, job.id);
+      }
+    } catch (err) {
+      const error = err;
+      const duration = Date.now() - startTime;
+      this.emit("job:failed", { job, error, duration, queue: currentQueue });
+      this.log(`Failed job ${job.id} in ${duration}ms`, { error: error.message });
+      this.stats.failed++;
+      if (this.options.monitor) {
+        await this.publishLog("error", `Job failed: ${job.id} - ${error.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);
+        this.log(`Retrying job ${job.id} in ${delaySec}s (Attempt ${job.attempts}/${maxAttempts})`);
+        this.stats.retried++;
+        this.emit("job:retried", { job, attempt: job.attempts, delay: delaySec });
+        if (this.options.monitor) {
+          await this.publishLog(
+            "warning",
+            `Job retrying in ${delaySec}s (Attempt ${job.attempts}/${maxAttempts})`,
+            job.id
+          );
+        }
+      } else {
+        this.emit("job:failed_permanently", { job, error });
+        this.log(`Job ${job.id} failed permanently`);
+        await this.queueManager.fail(job, error).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 "${currentQueue}":`, err);
+      });
+    }
   }
   startHeartbeat() {
     const interval = typeof this.options.monitor === "object" ? this.options.monitor.interval ?? 5e3 : 5e3;
@@ -1396,7 +3838,8 @@ var Consumer = class {
               rss: Math.floor(mem.rss / 1024 / 1024),
               heapUsed: Math.floor(mem.heapUsed / 1024 / 1024),
               total: Math.floor(os.totalmem() / 1024 / 1024)
-            }
+            },
+            stats: this.stats
           };
           await driver.reportHeartbeat(
             {
@@ -1446,7 +3889,7 @@ var Consumer = class {
    * Stop the consumer loop (graceful shutdown).
    */
   async stop() {
-    console.log("[Consumer] Stopping...");
+    this.log("Stopping...");
     this.stopRequested = true;
     while (this.running) {
       await new Promise((resolve) => setTimeout(resolve, 100));
@@ -1458,6 +3901,20 @@ var Consumer = class {
   isRunning() {
     return this.running;
   }
+  /**
+   * Get current consumer statistics.
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Reset statistics counters.
+   */
+  resetStats() {
+    this.stats.processed = 0;
+    this.stats.failed = 0;
+    this.stats.retried = 0;
+  }
 };
 
 // src/index.ts
@@ -1467,6 +3924,10 @@ init_KafkaDriver();
 // src/drivers/MemoryDriver.ts
 var MemoryDriver = class {
   queues = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(config = {}) {
+    this.maxSize = config.maxSize ?? Infinity;
+  }
   /**
    * Push a job to a queue.
    */
@@ -1474,7 +3935,11 @@ var MemoryDriver = class {
     if (!this.queues.has(queue)) {
       this.queues.set(queue, []);
     }
-    this.queues.get(queue)?.push(job);
+    const q = this.queues.get(queue);
+    if (q.length >= this.maxSize) {
+      throw new Error(`[MemoryDriver] Queue '${queue}' is full (max size: ${this.maxSize})`);
+    }
+    q.push(job);
   }
   /**
    * Pop a job from a queue (FIFO).
@@ -1505,6 +3970,39 @@ var MemoryDriver = class {
   async clear(queue) {
     this.queues.delete(queue);
   }
+  /**
+   * Mark a job as permanently failed.
+   */
+  async fail(queue, job) {
+    const failedQueue = `failed:${queue}`;
+    if (!this.queues.has(failedQueue)) {
+      this.queues.set(failedQueue, []);
+    }
+    this.queues.get(failedQueue)?.push(job);
+  }
+  /**
+   * Get queue statistics.
+   */
+  async stats(queue) {
+    const jobs = this.queues.get(queue) || [];
+    const now = Date.now();
+    let pending = 0;
+    let delayed = 0;
+    for (const job of jobs) {
+      const isDelayed = job.delaySeconds && now < job.createdAt + job.delaySeconds * 1e3;
+      if (isDelayed) {
+        delayed++;
+      } else {
+        pending++;
+      }
+    }
+    return {
+      queue,
+      size: pending,
+      delayed,
+      failed: this.queues.get(`failed:${queue}`)?.length || 0
+    };
+  }
   /**
    * Push multiple jobs.
    */
@@ -1639,6 +4137,35 @@ var Job = class {
   }
 };
 
+// src/serializers/CachedSerializer.ts
+var CachedSerializer = class {
+  /**
+   * @param delegate - The actual serializer to use for the first serialization
+   */
+  constructor(delegate) {
+    this.delegate = delegate;
+  }
+  cache = /* @__PURE__ */ new WeakMap();
+  /**
+   * Serialize a job with caching.
+   */
+  serialize(job) {
+    if (this.cache.has(job)) {
+      return this.cache.get(job);
+    }
+    const serialized = this.delegate.serialize(job);
+    this.cache.set(job, serialized);
+    return serialized;
+  }
+  /**
+   * Deserialize a job.
+   * No caching for deserialization as we get new objects each time from the driver.
+   */
+  deserialize(serialized) {
+    return this.delegate.deserialize(serialized);
+  }
+};
+
 // src/serializers/ClassNameSerializer.ts
 var ClassNameSerializer = class {
   /**
@@ -1665,7 +4192,7 @@ var ClassNameSerializer = class {
    * Serialize a Job.
    */
   serialize(job) {
-    const id = job.id || `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const id = job.id || `${Date.now()}-${crypto.randomUUID()}`;
     const className = job.constructor.name;
     const properties = {};
     for (const key in job) {
@@ -1677,10 +4204,7 @@ var ClassNameSerializer = class {
       id,
       type: "class",
       className,
-      data: JSON.stringify({
-        class: className,
-        properties
-      }),
+      data: JSON.stringify(properties),
       createdAt: Date.now(),
       ...job.delaySeconds !== void 0 ? { delaySeconds: job.delaySeconds } : {},
       attempts: job.attempts ?? 0,
@@ -1707,10 +4231,10 @@ var ClassNameSerializer = class {
         `Job class "${serialized.className}" is not registered. Please register it using serializer.register().`
       );
     }
-    const parsed = JSON.parse(serialized.data);
+    const properties = JSON.parse(serialized.data);
     const job = new JobClass();
-    if (parsed.properties) {
-      Object.assign(job, parsed.properties);
+    if (properties) {
+      Object.assign(job, properties);
     }
     job.id = serialized.id;
     if (serialized.delaySeconds !== void 0) {
@@ -1744,14 +4268,17 @@ var JsonSerializer = class {
    * Serialize a job.
    */
   serialize(job) {
-    const id = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const id = job.id || `${Date.now()}-${crypto.randomUUID()}`;
+    const properties = {};
+    for (const key in job) {
+      if (Object.hasOwn(job, key) && typeof job[key] !== "function") {
+        properties[key] = job[key];
+      }
+    }
     return {
       id,
       type: "json",
-      data: JSON.stringify({
-        job: job.constructor.name,
-        properties: { ...job }
-      }),
+      data: JSON.stringify(properties),
       createdAt: Date.now(),
       ...job.delaySeconds !== void 0 ? { delaySeconds: job.delaySeconds } : {},
       attempts: job.attempts ?? 0,
@@ -1762,23 +4289,27 @@ var JsonSerializer = class {
   }
   /**
    * 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 properties = JSON.parse(serialized.data);
     const job = /* @__PURE__ */ Object.create({});
-    Object.assign(job, parsed.properties);
+    Object.assign(job, properties);
+    job.id = serialized.id;
     if (serialized.groupId) {
       job.groupId = serialized.groupId;
     }
     if (serialized.priority) {
       job.priority = serialized.priority;
     }
+    if (serialized.delaySeconds !== void 0) {
+      job.delaySeconds = serialized.delaySeconds;
+    }
+    if (serialized.attempts !== void 0) {
+      job.attempts = serialized.attempts;
+    }
     return job;
   }
 };
@@ -1791,16 +4322,30 @@ var QueueManager = class {
   defaultSerializer;
   persistence;
   scheduler;
-  // Using any to avoid circular dependency or import issues for now
+  debug;
   constructor(config = {}) {
     this.persistence = config.persistence;
     this.defaultConnection = config.default ?? "default";
+    this.debug = config.debug ?? false;
+    if (this.persistence && (this.persistence.bufferSize || this.persistence.flushInterval)) {
+      const { BufferedPersistence: BufferedPersistence2 } = (init_BufferedPersistence(), __toCommonJS(BufferedPersistence_exports));
+      this.persistence.adapter = new BufferedPersistence2(this.persistence.adapter, {
+        maxBufferSize: this.persistence.bufferSize,
+        flushInterval: this.persistence.flushInterval
+      });
+    }
     const serializerType = config.defaultSerializer ?? "class";
     if (serializerType === "class") {
       this.defaultSerializer = new ClassNameSerializer();
+    } else if (serializerType === "msgpack") {
+      const { MessagePackSerializer: MessagePackSerializer2 } = (init_MessagePackSerializer(), __toCommonJS(MessagePackSerializer_exports));
+      this.defaultSerializer = new MessagePackSerializer2();
     } else {
       this.defaultSerializer = new JsonSerializer();
     }
+    if (config.useSerializationCache) {
+      this.defaultSerializer = new CachedSerializer(this.defaultSerializer);
+    }
     if (!this.drivers.has("default")) {
       this.drivers.set("default", new MemoryDriver());
     }
@@ -1810,6 +4355,20 @@ var QueueManager = class {
       }
     }
   }
+  /**
+   * Log debug message.
+   */
+  log(message, data) {
+    if (this.debug) {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const prefix = `[QueueManager] [${timestamp}]`;
+      if (data) {
+        console.log(prefix, message, data);
+      } else {
+        console.log(prefix, message);
+      }
+    }
+  }
   /**
    * Register a connection.
    * @param name - Connection name
@@ -1823,8 +4382,7 @@ var QueueManager = class {
         break;
       case "database": {
         const { DatabaseDriver: DatabaseDriver2 } = (init_DatabaseDriver(), __toCommonJS(DatabaseDriver_exports));
-        const dbService = config.dbService;
-        if (!dbService) {
+        if (!config.dbService) {
           throw new Error(
             "[QueueManager] DatabaseDriver requires dbService. Please provide a database service that implements DatabaseService interface."
           );
@@ -1832,9 +4390,7 @@ var QueueManager = class {
         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
+            dbService: config.dbService,
             table: config.table
           })
         );
@@ -1842,8 +4398,7 @@ var QueueManager = class {
       }
       case "redis": {
         const { RedisDriver: RedisDriver2 } = (init_RedisDriver(), __toCommonJS(RedisDriver_exports));
-        const client = config.client;
-        if (!client) {
+        if (!config.client) {
           throw new Error(
             "[QueueManager] RedisDriver requires client. Please provide Redis client in connection config."
           );
@@ -1851,9 +4406,7 @@ var QueueManager = class {
         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
+            client: config.client,
             prefix: config.prefix
           })
         );
@@ -1861,8 +4414,7 @@ var QueueManager = class {
       }
       case "kafka": {
         const { KafkaDriver: KafkaDriver2 } = (init_KafkaDriver(), __toCommonJS(KafkaDriver_exports));
-        const client = config.client;
-        if (!client) {
+        if (!config.client) {
           throw new Error(
             "[QueueManager] KafkaDriver requires client. Please provide Kafka client in connection config."
           );
@@ -1870,9 +4422,7 @@ var QueueManager = class {
         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
+            client: config.client,
             consumerGroupId: config.consumerGroupId
           })
         );
@@ -1880,8 +4430,7 @@ var QueueManager = class {
       }
       case "sqs": {
         const { SQSDriver: SQSDriver2 } = (init_SQSDriver(), __toCommonJS(SQSDriver_exports));
-        const client = config.client;
-        if (!client) {
+        if (!config.client) {
           throw new Error(
             "[QueueManager] SQSDriver requires client. Please provide SQS client in connection config."
           );
@@ -1889,13 +4438,9 @@ var QueueManager = class {
         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
+            client: config.client,
             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
           })
         );
@@ -1903,8 +4448,7 @@ var QueueManager = class {
       }
       case "rabbitmq": {
         const { RabbitMQDriver: RabbitMQDriver2 } = (init_RabbitMQDriver(), __toCommonJS(RabbitMQDriver_exports));
-        const client = config.client;
-        if (!client) {
+        if (!config.client) {
           throw new Error(
             "[QueueManager] RabbitMQDriver requires client. Please provide RabbitMQ connection/channel in connection config."
           );
@@ -1912,11 +4456,8 @@ var QueueManager = class {
         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
+            client: config.client,
             exchange: config.exchange,
-            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
             exchangeType: config.exchangeType
           })
         );
@@ -1995,6 +4536,11 @@ var QueueManager = class {
       pushOptions.priority = job.priority;
     }
     await driver.push(queue, serialized, pushOptions);
+    this.log(`Pushed job to ${queue} (${connection})`, {
+      id: serialized.id,
+      job: serialized.className ?? "json",
+      options: pushOptions
+    });
     if (this.persistence?.archiveEnqueued) {
       this.persistence.adapter.archive(queue, serialized, "waiting").catch((err) => {
         console.error("[QueueManager] Persistence archive failed (waiting):", err);
@@ -2007,16 +4553,19 @@ var QueueManager = class {
    *
    * @template T - The type of the jobs.
    * @param jobs - Array of job instances.
+   * @param options - Bulk push options.
    *
    * @example
    * ```typescript
-   * await manager.pushMany([new JobA(), new JobB()]);
+   * await manager.pushMany(jobs, { batchSize: 500, concurrency: 2 });
    * ```
    */
-  async pushMany(jobs) {
+  async pushMany(jobs, options = {}) {
     if (jobs.length === 0) {
       return;
     }
+    const batchSize = options.batchSize ?? 100;
+    const concurrency = options.concurrency ?? 1;
     const groups = /* @__PURE__ */ new Map();
     const serializer = this.getSerializer();
     for (const job of jobs) {
@@ -2029,17 +4578,42 @@ var QueueManager = class {
       }
       groups.get(key)?.push(serialized);
     }
+    const processBatch = async (driver, queue, batch) => {
+      if (driver.pushMany) {
+        await driver.pushMany(queue, batch);
+      } else {
+        for (const job of batch) {
+          await driver.push(queue, job);
+        }
+      }
+    };
     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);
+      this.log(`Pushing ${serializedJobs.length} jobs to ${queue} (${connection})`);
+      const chunks = [];
+      for (let i = 0; i < serializedJobs.length; i += batchSize) {
+        chunks.push(serializedJobs.slice(i, i + batchSize));
+      }
+      if (concurrency > 1) {
+        const activePromises = [];
+        for (const chunk of chunks) {
+          const promise = processBatch(driver, queue, chunk);
+          activePromises.push(promise);
+          if (activePromises.length >= concurrency) {
+            await Promise.race(activePromises);
+          }
+        }
+        for (let i = 0; i < chunks.length; i += concurrency) {
+          const batchPromises = chunks.slice(i, i + concurrency).map((chunk) => processBatch(driver, queue, chunk));
+          await Promise.all(batchPromises);
+        }
       } else {
-        for (const job of serializedJobs) {
-          await driver.push(queue, job);
+        for (const chunk of chunks) {
+          await processBatch(driver, queue, chunk);
         }
       }
     }
@@ -2064,6 +4638,7 @@ var QueueManager = class {
     if (!serialized) {
       return null;
     }
+    this.log(`Popped job from ${queue} (${connection})`, { id: serialized.id });
     try {
       return serializer.deserialize(serialized);
     } catch (error) {
@@ -2071,6 +4646,42 @@ var QueueManager = class {
       return null;
     }
   }
+  /**
+   * Pop multiple jobs from the queue.
+   *
+   * @param queue - Queue name (default: 'default').
+   * @param count - Number of jobs to pop (default: 10).
+   * @param connection - Connection name (optional).
+   * @returns Array of Job instances.
+   */
+  async popMany(queue = "default", count = 10, connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    const serializer = this.getSerializer();
+    const results = [];
+    if (driver.popMany) {
+      const serializedJobs = await driver.popMany(queue, count);
+      if (serializedJobs.length > 0) {
+        this.log(`Popped ${serializedJobs.length} jobs from ${queue} (${connection})`);
+      }
+      for (const serialized of serializedJobs) {
+        try {
+          results.push(serializer.deserialize(serialized));
+        } catch (error) {
+          console.error("[QueueManager] Failed to deserialize job:", error);
+        }
+      }
+    } else {
+      for (let i = 0; i < count; i++) {
+        const job = await this.pop(queue, connection);
+        if (job) {
+          results.push(job);
+        } else {
+          break;
+        }
+      }
+    }
+    return results;
+  }
   /**
    * Get queue size.
    *
@@ -2082,6 +4693,35 @@ var QueueManager = class {
     const driver = this.getDriver(connection);
     return driver.size(queue);
   }
+  /**
+   * Pop a job from the queue (blocking).
+   *
+   * @param queue - Queue name (default: 'default').
+   * @param timeout - Timeout in seconds (default: 0, wait forever).
+   * @param connection - Connection name (optional).
+   */
+  async popBlocking(queues = "default", timeout = 0, connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    const serializer = this.getSerializer();
+    if (!driver.popBlocking) {
+      const q = Array.isArray(queues) ? queues[0] : queues;
+      return this.pop(q, connection);
+    }
+    const serialized = await driver.popBlocking(queues, timeout);
+    if (!serialized) {
+      return null;
+    }
+    this.log(
+      `Popped job (blocking) from ${Array.isArray(queues) ? queues.join(",") : queues} (${connection})`,
+      { id: serialized.id }
+    );
+    try {
+      return serializer.deserialize(serialized);
+    } catch (error) {
+      console.error("[QueueManager] Failed to deserialize job:", error);
+      return null;
+    }
+  }
   /**
    * Clear all jobs from a queue.
    *
@@ -2092,6 +4732,23 @@ var QueueManager = class {
     const driver = this.getDriver(connection);
     await driver.clear(queue);
   }
+  /**
+   * Get queue statistics including size, delayed, and failed job counts.
+   *
+   * @param queue - Queue name (default: 'default').
+   * @param connection - Connection name (optional).
+   * @returns Queue statistics object.
+   */
+  async stats(queue = "default", connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    if (driver.stats) {
+      return await driver.stats(queue);
+    }
+    return {
+      queue,
+      size: await driver.size(queue)
+    };
+  }
   /**
    * Mark a job as completed.
    * @param job - Job instance
@@ -2104,6 +4761,7 @@ var QueueManager = class {
     if (driver.complete) {
       const serialized = serializer.serialize(job);
       await driver.complete(queue, serialized);
+      this.log(`Completed job ${job.id} in ${queue}`);
       if (this.persistence?.archiveCompleted) {
         await this.persistence.adapter.archive(queue, serialized, "completed").catch((err) => {
           console.error("[QueueManager] Persistence archive failed (completed):", err);
@@ -2126,6 +4784,7 @@ var QueueManager = class {
       serialized.error = error.message;
       serialized.failedAt = Date.now();
       await driver.fail(queue, serialized);
+      this.log(`Failed job ${job.id} in ${queue}`, { error: error.message });
       if (this.persistence?.archiveFailed) {
         await this.persistence.adapter.archive(queue, serialized, "failed").catch((err) => {
           console.error("[QueueManager] Persistence archive failed (failed):", err);
@@ -2259,39 +4918,51 @@ var OrbitStream = class _OrbitStream {
   }
 };
 
+// src/index.ts
+init_BufferedPersistence();
+
 // 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.
+   * @param logsTable - The name of the table to store system logs.
+   * @param options - Buffering options (Deprecated: Use BufferedPersistence wrapper instead).
    */
-  constructor(db, table = "flux_job_archive", logsTable = "flux_system_logs") {
+  constructor(db, table = "flux_job_archive", logsTable = "flux_system_logs", _options = {}) {
     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);
+    await this.archiveMany([{ queue, job, status }]);
+  }
+  async archiveMany(jobs) {
+    if (jobs.length === 0) {
+      return;
+    }
+    const batchSize = 500;
+    for (let i = 0; i < jobs.length; i += batchSize) {
+      const chunk = jobs.slice(i, i + batchSize);
+      try {
+        const records = chunk.map((item) => ({
+          job_id: item.job.id,
+          queue: item.queue,
+          status: item.status,
+          payload: JSON.stringify(item.job),
+          error: item.job.error || null,
+          created_at: new Date(item.job.createdAt),
+          archived_at: /* @__PURE__ */ new Date()
+        }));
+        await this.db.table(this.table).insert(records);
+      } catch (err) {
+        console.error(`[MySQLPersistence] Failed to archive ${chunk.length} jobs:`, err);
+      }
     }
   }
-  /**
-   * Find a specific job in the archive.
-   */
+  async flush() {
+  }
   async find(queue, id) {
     const row = await this.db.table(this.table).where("queue", queue).where("job_id", id).first();
     if (!row) {
@@ -2329,7 +5000,9 @@ var MySQLPersistence = class {
       } catch (_e) {
         return null;
       }
-    }).filter(Boolean);
+    }).filter(
+      (item) => !!item
+    );
   }
   /**
    * Search jobs from the archive.
@@ -2349,22 +5022,35 @@ var MySQLPersistence = class {
       } catch (_e) {
         return null;
       }
-    }).filter(Boolean);
+    }).filter(
+      (item) => !!item
+    );
   }
   /**
-   * Archive a system log message.
+   * Archive a system log message (buffered).
    */
   async archiveLog(log) {
+    await this.archiveLogMany([log]);
+  }
+  /**
+   * Archive multiple log messages (direct batch write).
+   */
+  async archiveLogMany(logs) {
+    if (logs.length === 0) {
+      return;
+    }
     try {
-      await this.db.table(this.logsTable).insert({
+      const records = logs.map((log) => ({
         level: log.level,
         message: log.message,
         worker_id: log.workerId,
         queue: log.queue || null,
         timestamp: log.timestamp
-      });
+      }));
+      await this.db.table(this.logsTable).insert(records);
     } catch (err) {
-      console.error(`[MySQLPersistence] Failed to archive log:`, err.message);
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error(`[MySQLPersistence] Failed to archive ${logs.length} logs:`, error.message);
     }
   }
   /**
@@ -2415,8 +5101,8 @@ var MySQLPersistence = class {
     if (options.endTime) {
       query = query.where("timestamp", "<=", options.endTime);
     }
-    const result = await query.count("id as total").first();
-    return result?.total || 0;
+    const result = await query.count();
+    return Number(result) || 0;
   }
   /**
    * Remove old records from the archive.
@@ -2428,7 +5114,7 @@ var MySQLPersistence = class {
       this.db.table(this.table).where("archived_at", "<", threshold).delete(),
       this.db.table(this.logsTable).where("timestamp", "<", threshold).delete()
     ]);
-    return (jobsDeleted || 0) + (logsDeleted || 0);
+    return (Number(jobsDeleted) || 0) + (Number(logsDeleted) || 0);
   }
   /**
    * Count jobs in the archive.
@@ -2447,8 +5133,8 @@ var MySQLPersistence = class {
     if (options.endTime) {
       query = query.where("archived_at", "<=", options.endTime);
     }
-    const result = await query.count("id as total").first();
-    return result?.total || 0;
+    const result = await query.count();
+    return Number(result) || 0;
   }
   /**
    * Help script to create the necessary table.
@@ -2504,33 +5190,49 @@ var SQLitePersistence = class {
   /**
    * @param db - An Atlas DB instance (SQLite driver).
    * @param table - The name of the table to store archived jobs.
+   * @param logsTable - The name of the table to store system logs.
+   * @param options - Buffering options (Deprecated: Use BufferedPersistence wrapper instead).
    */
-  constructor(db, table = "flux_job_archive", logsTable = "flux_system_logs") {
+  constructor(db, table = "flux_job_archive", logsTable = "flux_system_logs", _options = {}) {
     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);
+    await this.archiveMany([{ queue, job, status }]);
+  }
+  async archiveMany(jobs) {
+    if (jobs.length === 0) {
+      return;
+    }
+    const batchSize = 200;
+    for (let i = 0; i < jobs.length; i += batchSize) {
+      const chunk = jobs.slice(i, i + batchSize);
+      try {
+        const records = chunk.map((item) => ({
+          job_id: item.job.id,
+          queue: item.queue,
+          status: item.status,
+          payload: JSON.stringify(item.job),
+          error: item.job.error || null,
+          created_at: new Date(item.job.createdAt),
+          archived_at: /* @__PURE__ */ new Date()
+        }));
+        if (typeof this.db.transaction === "function") {
+          await this.db.transaction(async (trx) => {
+            await trx.table(this.table).insert(records);
+          });
+        } else {
+          await this.db.table(this.table).insert(records);
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        console.error(`[SQLitePersistence] Failed to archive ${chunk.length} jobs:`, error.message);
+      }
     }
   }
-  /**
-   * Find a specific job in the archive.
-   */
+  async flush() {
+  }
   async find(queue, id) {
     const row = await this.db.table(this.table).where("queue", queue).where("job_id", id).first();
     if (!row) {
@@ -2568,7 +5270,9 @@ var SQLitePersistence = class {
       } catch (_e) {
         return null;
       }
-    }).filter(Boolean);
+    }).filter(
+      (item) => !!item
+    );
   }
   /**
    * Search jobs from the archive.
@@ -2588,22 +5292,35 @@ var SQLitePersistence = class {
       } catch (_e) {
         return null;
       }
-    }).filter(Boolean);
+    }).filter(
+      (item) => !!item
+    );
   }
   /**
-   * Archive a system log message.
+   * Archive a system log message (buffered).
    */
   async archiveLog(log) {
+    await this.archiveLogMany([log]);
+  }
+  /**
+   * Archive multiple log messages (direct batch write).
+   */
+  async archiveLogMany(logs) {
+    if (logs.length === 0) {
+      return;
+    }
     try {
-      await this.db.table(this.logsTable).insert({
+      const records = logs.map((log) => ({
         level: log.level,
         message: log.message,
         worker_id: log.workerId,
         queue: log.queue || null,
         timestamp: log.timestamp
-      });
+      }));
+      await this.db.table(this.logsTable).insert(records);
     } catch (err) {
-      console.error(`[SQLitePersistence] Failed to archive log:`, err.message);
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error(`[SQLitePersistence] Failed to archive ${logs.length} logs:`, error.message);
     }
   }
   /**
@@ -2654,8 +5371,8 @@ var SQLitePersistence = class {
     if (options.endTime) {
       query = query.where("timestamp", "<=", options.endTime);
     }
-    const result = await query.count("id as total").first();
-    return result?.total || 0;
+    const result = await query.count();
+    return Number(result) || 0;
   }
   /**
    * Remove old records from the archive.
@@ -2667,7 +5384,7 @@ var SQLitePersistence = class {
       this.db.table(this.table).where("archived_at", "<", threshold).delete(),
       this.db.table(this.logsTable).where("timestamp", "<", threshold).delete()
     ]);
-    return (jobsDeleted || 0) + (logsDeleted || 0);
+    return (Number(jobsDeleted) || 0) + (Number(logsDeleted) || 0);
   }
   /**
    * Count jobs in the archive.
@@ -2686,8 +5403,8 @@ var SQLitePersistence = class {
     if (options.endTime) {
       query = query.where("archived_at", "<=", options.endTime);
     }
-    const result = await query.count("id as total").first();
-    return result?.total || 0;
+    const result = await query.count();
+    return Number(result) || 0;
   }
   /**
    * Setup table for SQLite.
@@ -2739,6 +5456,7 @@ var SQLitePersistence = class {
 init_Scheduler();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BufferedPersistence,
   ClassNameSerializer,
   Consumer,
   DatabaseDriver,