@gravito/zenith 1.1.1 → 1.1.2

package/dist/server/index.js

@@ -78092,6 +78092,75 @@ class DatabaseDriver {
     }
     return job;
   }
+  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] : [];
+    }
+  }
+  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 };
+    }
+  }
   async size(queue) {
     const result = await this.dbService.execute(`SELECT COUNT(*) as count
        FROM ${this.tableName}
@@ -78103,15 +78172,33 @@ class DatabaseDriver {
   async clear(queue) {
     await this.dbService.execute(`DELETE FROM ${this.tableName} WHERE queue = $1`, [queue]);
   }
+  async popBlocking(queue, timeout) {
+    const start = Date.now();
+    const timeoutMs = timeout * 1000;
+    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, 1000));
+    }
+  }
   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 * 1000) : 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(), 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 * 1000) : 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(), new Date().toISOString()]);
+        }
       }
     });
   }
@@ -78239,25 +78326,29 @@ class KafkaDriver {
     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);
+          }
         }
       }
     });
@@ -78323,6 +78414,21 @@ class RabbitMQDriver {
     job._raw = msg;
     return job;
   }
+  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;
+  }
   async acknowledge(messageId) {
     const channel = await this.ensureChannel();
     if (typeof messageId === "object") {
@@ -78340,6 +78446,9 @@ class RabbitMQDriver {
   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, "");
     }
@@ -78403,6 +78512,58 @@ class RedisDriver2 {
       return redis.call('SREM', activeSet, groupId)
     end
   `;
+  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;
     this.prefix = config.prefix ?? "queue:";
@@ -78418,6 +78579,10 @@ class RedisDriver2 {
         numberOfKeys: 3,
         lua: RedisDriver2.COMPLETE_SCRIPT
       });
+      this.client.defineCommand("popMany", {
+        numberOfKeys: 1,
+        lua: RedisDriver2.POP_MANY_SCRIPT
+      });
     }
   }
   getKey(queue, priority) {
@@ -78474,27 +78639,63 @@ class RedisDriver2 {
     }
   }
   async pop(queue) {
+    const priorities = ["critical", "high", "default", "low"];
+    const keys = [];
+    for (const p of priorities) {
+      keys.push(this.getKey(queue, p === "default" ? undefined : 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;
+  }
+  async popManualFallback(queue) {
     const priorities = ["critical", "high", undefined, "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) {
@@ -78503,6 +78704,26 @@ class RedisDriver2 {
     }
     return null;
   }
+  async popBlocking(queues, timeout) {
+    const queueList = Array.isArray(queues) ? queues : [queues];
+    const priorities = ["critical", "high", undefined, "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;
+  }
   parsePayload(payload) {
     const parsed = JSON.parse(payload);
     return {
@@ -78540,11 +78761,53 @@ class RedisDriver2 {
     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);
     }
   }
+  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" ? undefined : 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;
+  }
   async pushMany(queue, jobs) {
     if (jobs.length === 0) {
       return;
@@ -78552,6 +78815,43 @@ class RedisDriver2 {
     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 * 1000;
+              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,
@@ -78576,15 +78876,75 @@ class RedisDriver2 {
     await this.client.lpush(key, ...payloads);
   }
   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" ? undefined : 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;
   }
@@ -78618,7 +78978,7 @@ class RedisDriver2 {
     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 / 1000) + 1);
       }
       return current <= config.max;
@@ -78627,6 +78987,9 @@ class RedisDriver2 {
   }
   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));
   }
@@ -78634,6 +78997,9 @@ class RedisDriver2 {
     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;
@@ -102358,6 +102724,34 @@ class SQSDriver {
       ...message.ReceiptHandle && { receiptHandle: message.ReceiptHandle }
     };
   }
+  async popMany(queue, count) {
+    const { ReceiveMessageCommand: ReceiveMessageCommand3 } = await Promise.resolve().then(() => (init_dist_es13(), exports_dist_es8));
+    const queueUrl = await this.getQueueUrl(queue);
+    const limit = Math.min(count, 10);
+    const response = await this.client.send(new ReceiveMessageCommand3({
+      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
+      };
+    });
+  }
   async size(queue) {
     const { GetQueueAttributesCommand: GetQueueAttributesCommand3 } = await Promise.resolve().then(() => (init_dist_es13(), exports_dist_es8));
     const queueUrl = await this.getQueueUrl(queue);
@@ -102433,6 +102827,1829 @@ class SQSDriver {
   }
 }
 
+// ../stream/src/persistence/BufferedPersistence.ts
+var exports_BufferedPersistence = {};
+__export(exports_BufferedPersistence, {
+  BufferedPersistence: () => BufferedPersistence
+});
+
+class BufferedPersistence {
+  adapter;
+  jobBuffer = [];
+  logBuffer = [];
+  flushTimer = null;
+  maxBufferSize;
+  flushInterval;
+  constructor(adapter, options = {}) {
+    this.adapter = adapter;
+    this.maxBufferSize = options.maxBufferSize ?? 50;
+    this.flushInterval = options.flushInterval ?? 5000;
+  }
+  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.cjs/utils/utf8.cjs
+var require_utf8 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.utf8Count = utf8Count;
+  exports.utf8EncodeJs = utf8EncodeJs;
+  exports.utf8EncodeTE = utf8EncodeTE;
+  exports.utf8Encode = utf8Encode;
+  exports.utf8DecodeJs = utf8DecodeJs;
+  exports.utf8DecodeTD = utf8DecodeTD;
+  exports.utf8Decode = utf8Decode;
+  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;
+    }
+  }
+  var sharedTextEncoder = new TextEncoder;
+  var TEXT_ENCODER_THRESHOLD = 50;
+  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);
+    }
+  }
+  var CHUNK_SIZE = 4096;
+  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;
+  }
+  var sharedTextDecoder = new TextDecoder;
+  var TEXT_DECODER_THRESHOLD = 200;
+  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);
+    }
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/ExtData.cjs
+var require_ExtData = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ExtData = undefined;
+
+  class ExtData {
+    type;
+    data;
+    constructor(type, data) {
+      this.type = type;
+      this.data = data;
+    }
+  }
+  exports.ExtData = ExtData;
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/DecodeError.cjs
+var require_DecodeError = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.DecodeError = undefined;
+
+  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
+      });
+    }
+  }
+  exports.DecodeError = DecodeError;
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/int.cjs
+var require_int = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.UINT32_MAX = undefined;
+  exports.setUint64 = setUint64;
+  exports.setInt64 = setInt64;
+  exports.getInt64 = getInt64;
+  exports.getUint64 = getUint64;
+  exports.UINT32_MAX = 4294967295;
+  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;
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/timestamp.cjs
+var require_timestamp = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.timestampExtension = exports.EXT_TIMESTAMP = undefined;
+  exports.encodeTimeSpecToTimestamp = encodeTimeSpecToTimestamp;
+  exports.encodeDateToTimeSpec = encodeDateToTimeSpec;
+  exports.encodeTimestampExtension = encodeTimestampExtension;
+  exports.decodeTimestampToTimeSpec = decodeTimestampToTimeSpec;
+  exports.decodeTimestampExtension = decodeTimestampExtension;
+  var DecodeError_ts_1 = require_DecodeError();
+  var int_ts_1 = require_int();
+  exports.EXT_TIMESTAMP = -1;
+  var TIMESTAMP32_MAX_SEC = 4294967296 - 1;
+  var TIMESTAMP64_MAX_SEC = 17179869184 - 1;
+  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);
+      (0, int_ts_1.setInt64)(view, 4, sec);
+      return rv;
+    }
+  }
+  function encodeDateToTimeSpec(date) {
+    const msec = date.getTime();
+    const sec = Math.floor(msec / 1000);
+    const nsec = (msec - sec * 1000) * 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 = (0, int_ts_1.getInt64)(view, 4);
+        const nsec = view.getUint32(0);
+        return { sec, nsec };
+      }
+      default:
+        throw new DecodeError_ts_1.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 * 1000 + timeSpec.nsec / 1e6);
+  }
+  exports.timestampExtension = {
+    type: exports.EXT_TIMESTAMP,
+    encode: encodeTimestampExtension,
+    decode: decodeTimestampExtension
+  };
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/ExtensionCodec.cjs
+var require_ExtensionCodec = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ExtensionCodec = undefined;
+  var ExtData_ts_1 = require_ExtData();
+  var timestamp_ts_1 = require_timestamp();
+
+  class ExtensionCodec {
+    static defaultCodec = new ExtensionCodec;
+    __brand;
+    builtInEncoders = [];
+    builtInDecoders = [];
+    encoders = [];
+    decoders = [];
+    constructor() {
+      this.register(timestamp_ts_1.timestampExtension);
+    }
+    register({ type, encode, decode }) {
+      if (type >= 0) {
+        this.encoders[type] = encode;
+        this.decoders[type] = decode;
+      } else {
+        const index = -1 - type;
+        this.builtInEncoders[index] = encode;
+        this.builtInDecoders[index] = decode;
+      }
+    }
+    tryToEncode(object, context) {
+      for (let i3 = 0;i3 < this.builtInEncoders.length; i3++) {
+        const encodeExt = this.builtInEncoders[i3];
+        if (encodeExt != null) {
+          const data = encodeExt(object, context);
+          if (data != null) {
+            const type = -1 - i3;
+            return new ExtData_ts_1.ExtData(type, data);
+          }
+        }
+      }
+      for (let i3 = 0;i3 < this.encoders.length; i3++) {
+        const encodeExt = this.encoders[i3];
+        if (encodeExt != null) {
+          const data = encodeExt(object, context);
+          if (data != null) {
+            const type = i3;
+            return new ExtData_ts_1.ExtData(type, data);
+          }
+        }
+      }
+      if (object instanceof ExtData_ts_1.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_ts_1.ExtData(type, data);
+      }
+    }
+  }
+  exports.ExtensionCodec = ExtensionCodec;
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/typedArrays.cjs
+var require_typedArrays = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ensureUint8Array = ensureUint8Array;
+  function isArrayBufferLike(buffer2) {
+    return buffer2 instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && buffer2 instanceof SharedArrayBuffer;
+  }
+  function ensureUint8Array(buffer2) {
+    if (buffer2 instanceof Uint8Array) {
+      return buffer2;
+    } else if (ArrayBuffer.isView(buffer2)) {
+      return new Uint8Array(buffer2.buffer, buffer2.byteOffset, buffer2.byteLength);
+    } else if (isArrayBufferLike(buffer2)) {
+      return new Uint8Array(buffer2);
+    } else {
+      return Uint8Array.from(buffer2);
+    }
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/Encoder.cjs
+var require_Encoder = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Encoder = exports.DEFAULT_INITIAL_BUFFER_SIZE = exports.DEFAULT_MAX_DEPTH = undefined;
+  var utf8_ts_1 = require_utf8();
+  var ExtensionCodec_ts_1 = require_ExtensionCodec();
+  var int_ts_1 = require_int();
+  var typedArrays_ts_1 = require_typedArrays();
+  exports.DEFAULT_MAX_DEPTH = 100;
+  exports.DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+
+  class Encoder {
+    extensionCodec;
+    context;
+    useBigInt64;
+    maxDepth;
+    initialBufferSize;
+    sortKeys;
+    forceFloat32;
+    ignoreUndefined;
+    forceIntegerToFloat;
+    pos;
+    view;
+    bytes;
+    entered = false;
+    constructor(options) {
+      this.extensionCodec = options?.extensionCodec ?? ExtensionCodec_ts_1.ExtensionCodec.defaultCodec;
+      this.context = options?.context;
+      this.useBigInt64 = options?.useBigInt64 ?? false;
+      this.maxDepth = options?.maxDepth ?? exports.DEFAULT_MAX_DEPTH;
+      this.initialBufferSize = options?.initialBufferSize ?? exports.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;
+    }
+    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;
+      }
+    }
+    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 = (0, utf8_ts_1.utf8Count)(object);
+      this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+      this.writeStringHeader(byteLength);
+      (0, utf8_ts_1.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 = (0, typedArrays_ts_1.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] !== undefined) {
+          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 === undefined)) {
+          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);
+      (0, int_ts_1.setUint64)(this.view, this.pos, value);
+      this.pos += 8;
+    }
+    writeI64(value) {
+      this.ensureBufferSizeToWrite(8);
+      (0, int_ts_1.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;
+    }
+  }
+  exports.Encoder = Encoder;
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/encode.cjs
+var require_encode = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.encode = encode;
+  var Encoder_ts_1 = require_Encoder();
+  function encode(value, options) {
+    const encoder = new Encoder_ts_1.Encoder(options);
+    return encoder.encodeSharedRef(value);
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/prettyByte.cjs
+var require_prettyByte = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.prettyByte = prettyByte;
+  function prettyByte(byte) {
+    return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/CachedKeyDecoder.cjs
+var require_CachedKeyDecoder = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.CachedKeyDecoder = undefined;
+  var utf8_ts_1 = require_utf8();
+  var DEFAULT_MAX_KEY_LENGTH = 16;
+  var DEFAULT_MAX_LENGTH_PER_KEY = 16;
+
+  class CachedKeyDecoder {
+    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 i3 = 0;i3 < this.maxKeyLength; i3++) {
+        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 j3 = 0;j3 < byteLength; j3++) {
+            if (recordBytes[j3] !== bytes[inputOffset + j3]) {
+              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 = (0, utf8_ts_1.utf8DecodeJs)(bytes, inputOffset, byteLength);
+      const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+      this.store(slicedCopyOfBytes, str);
+      return str;
+    }
+  }
+  exports.CachedKeyDecoder = CachedKeyDecoder;
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/Decoder.cjs
+var require_Decoder = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Decoder = undefined;
+  var prettyByte_ts_1 = require_prettyByte();
+  var ExtensionCodec_ts_1 = require_ExtensionCodec();
+  var int_ts_1 = require_int();
+  var utf8_ts_1 = require_utf8();
+  var typedArrays_ts_1 = require_typedArrays();
+  var CachedKeyDecoder_ts_1 = require_CachedKeyDecoder();
+  var DecodeError_ts_1 = require_DecodeError();
+  var STATE_ARRAY = "array";
+  var STATE_MAP_KEY = "map_key";
+  var STATE_MAP_VALUE = "map_value";
+  var mapKeyConverter = (key) => {
+    if (typeof key === "string" || typeof key === "number") {
+      return key;
+    }
+    throw new DecodeError_ts_1.DecodeError("The type of key must be string or number but " + typeof key);
+  };
+
+  class StackPool {
+    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: undefined,
+          size: 0,
+          array: undefined,
+          position: 0,
+          readCount: 0,
+          map: undefined,
+          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 = undefined;
+        partialState.position = 0;
+        partialState.type = undefined;
+      }
+      if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
+        const partialState = state;
+        partialState.size = 0;
+        partialState.map = undefined;
+        partialState.readCount = 0;
+        partialState.type = undefined;
+      }
+      this.stackHeadPosition--;
+    }
+    reset() {
+      this.stack.length = 0;
+      this.stackHeadPosition = -1;
+    }
+  }
+  var HEAD_BYTE_REQUIRED = -1;
+  var EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+  var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+  try {
+    EMPTY_VIEW.getInt8(0);
+  } catch (e3) {
+    if (!(e3 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");
+    }
+  }
+  var MORE_DATA = new RangeError("Insufficient data");
+  var sharedCachedKeyDecoder = new CachedKeyDecoder_ts_1.CachedKeyDecoder;
+
+  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_ts_1.ExtensionCodec.defaultCodec;
+      this.context = options?.context;
+      this.useBigInt64 = options?.useBigInt64 ?? false;
+      this.rawStrings = options?.rawStrings ?? false;
+      this.maxStrLength = options?.maxStrLength ?? int_ts_1.UINT32_MAX;
+      this.maxBinLength = options?.maxBinLength ?? int_ts_1.UINT32_MAX;
+      this.maxArrayLength = options?.maxArrayLength ?? int_ts_1.UINT32_MAX;
+      this.maxMapLength = options?.maxMapLength ?? int_ts_1.UINT32_MAX;
+      this.maxExtLength = options?.maxExtLength ?? int_ts_1.UINT32_MAX;
+      this.keyDecoder = options?.keyDecoder !== undefined ? 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(buffer2) {
+      const bytes = (0, typedArrays_ts_1.ensureUint8Array)(buffer2);
+      this.bytes = bytes;
+      this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      this.pos = 0;
+    }
+    appendBuffer(buffer2) {
+      if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
+        this.setBuffer(buffer2);
+      } else {
+        const remainingData = this.bytes.subarray(this.pos);
+        const newData = (0, typedArrays_ts_1.ensureUint8Array)(buffer2);
+        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}]`);
+    }
+    decode(buffer2) {
+      if (this.entered) {
+        const instance = this.clone();
+        return instance.decode(buffer2);
+      }
+      try {
+        this.entered = true;
+        this.reinitializeState();
+        this.setBuffer(buffer2);
+        const object = this.doDecodeSync();
+        if (this.hasRemaining(1)) {
+          throw this.createExtraByteError(this.pos);
+        }
+        return object;
+      } finally {
+        this.entered = false;
+      }
+    }
+    *decodeMulti(buffer2) {
+      if (this.entered) {
+        const instance = this.clone();
+        yield* instance.decodeMulti(buffer2);
+        return;
+      }
+      try {
+        this.entered = true;
+        this.reinitializeState();
+        this.setBuffer(buffer2);
+        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 buffer2 of stream) {
+          if (decoded) {
+            this.entered = false;
+            throw this.createExtraByteError(this.totalPos);
+          }
+          this.appendBuffer(buffer2);
+          try {
+            object = this.doDecodeSync();
+            decoded = true;
+          } catch (e3) {
+            if (!(e3 instanceof RangeError)) {
+              throw e3;
+            }
+          }
+          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 ${(0, prettyByte_ts_1.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 buffer2 of stream) {
+          if (isArray && arrayItemsLeft === 0) {
+            throw this.createExtraByteError(this.totalPos);
+          }
+          this.appendBuffer(buffer2);
+          if (isArrayHeaderRequired) {
+            arrayItemsLeft = this.readArraySize();
+            isArrayHeaderRequired = false;
+            this.complete();
+          }
+          try {
+            while (true) {
+              yield this.doDecodeSync();
+              if (--arrayItemsLeft === 0) {
+                break;
+              }
+            }
+          } catch (e3) {
+            if (!(e3 instanceof RangeError)) {
+              throw e3;
+            }
+          }
+          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_ts_1.DecodeError(`Unrecognized type byte: ${(0, prettyByte_ts_1.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_ts_1.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_ts_1.DecodeError(`Unrecognized array type byte: ${(0, prettyByte_ts_1.prettyByte)(headByte)}`);
+          }
+        }
+      }
+    }
+    pushMapState(size) {
+      if (size > this.maxMapLength) {
+        throw new DecodeError_ts_1.DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`);
+      }
+      this.stack.pushMapState(size);
+    }
+    pushArrayState(size) {
+      if (size > this.maxArrayLength) {
+        throw new DecodeError_ts_1.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);
+    }
+    decodeUtf8String(byteLength, headerOffset) {
+      if (byteLength > this.maxStrLength) {
+        throw new DecodeError_ts_1.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 = (0, utf8_ts_1.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;
+    }
+    decodeBinary(byteLength, headOffset) {
+      if (byteLength > this.maxBinLength) {
+        throw new DecodeError_ts_1.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_ts_1.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);
+      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 = (0, int_ts_1.getUint64)(this.view, this.pos);
+      this.pos += 8;
+      return value;
+    }
+    readI64() {
+      const value = (0, int_ts_1.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;
+    }
+  }
+  exports.Decoder = Decoder;
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/decode.cjs
+var require_decode = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.decode = decode;
+  exports.decodeMulti = decodeMulti;
+  var Decoder_ts_1 = require_Decoder();
+  function decode(buffer2, options) {
+    const decoder = new Decoder_ts_1.Decoder(options);
+    return decoder.decode(buffer2);
+  }
+  function decodeMulti(buffer2, options) {
+    const decoder = new Decoder_ts_1.Decoder(options);
+    return decoder.decodeMulti(buffer2);
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/utils/stream.cjs
+var require_stream2 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isAsyncIterable = isAsyncIterable;
+  exports.asyncIterableFromStream = asyncIterableFromStream;
+  exports.ensureAsyncIterable = ensureAsyncIterable;
+  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);
+    }
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/decodeAsync.cjs
+var require_decodeAsync = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.decodeAsync = decodeAsync;
+  exports.decodeArrayStream = decodeArrayStream;
+  exports.decodeMultiStream = decodeMultiStream;
+  var Decoder_ts_1 = require_Decoder();
+  var stream_ts_1 = require_stream2();
+  async function decodeAsync(streamLike, options) {
+    const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+    const decoder = new Decoder_ts_1.Decoder(options);
+    return decoder.decodeAsync(stream);
+  }
+  function decodeArrayStream(streamLike, options) {
+    const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+    const decoder = new Decoder_ts_1.Decoder(options);
+    return decoder.decodeArrayStream(stream);
+  }
+  function decodeMultiStream(streamLike, options) {
+    const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+    const decoder = new Decoder_ts_1.Decoder(options);
+    return decoder.decodeStream(stream);
+  }
+});
+
+// ../../node_modules/.bun/@msgpack+msgpack@3.1.3/node_modules/@msgpack/msgpack/dist.cjs/index.cjs
+var require_dist6 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.decodeTimestampExtension = exports.encodeTimestampExtension = exports.decodeTimestampToTimeSpec = exports.encodeTimeSpecToTimestamp = exports.encodeDateToTimeSpec = exports.EXT_TIMESTAMP = exports.ExtData = exports.ExtensionCodec = exports.Encoder = exports.DecodeError = exports.Decoder = exports.decodeMultiStream = exports.decodeArrayStream = exports.decodeAsync = exports.decodeMulti = exports.decode = exports.encode = undefined;
+  var encode_ts_1 = require_encode();
+  Object.defineProperty(exports, "encode", { enumerable: true, get: function() {
+    return encode_ts_1.encode;
+  } });
+  var decode_ts_1 = require_decode();
+  Object.defineProperty(exports, "decode", { enumerable: true, get: function() {
+    return decode_ts_1.decode;
+  } });
+  Object.defineProperty(exports, "decodeMulti", { enumerable: true, get: function() {
+    return decode_ts_1.decodeMulti;
+  } });
+  var decodeAsync_ts_1 = require_decodeAsync();
+  Object.defineProperty(exports, "decodeAsync", { enumerable: true, get: function() {
+    return decodeAsync_ts_1.decodeAsync;
+  } });
+  Object.defineProperty(exports, "decodeArrayStream", { enumerable: true, get: function() {
+    return decodeAsync_ts_1.decodeArrayStream;
+  } });
+  Object.defineProperty(exports, "decodeMultiStream", { enumerable: true, get: function() {
+    return decodeAsync_ts_1.decodeMultiStream;
+  } });
+  var Decoder_ts_1 = require_Decoder();
+  Object.defineProperty(exports, "Decoder", { enumerable: true, get: function() {
+    return Decoder_ts_1.Decoder;
+  } });
+  var DecodeError_ts_1 = require_DecodeError();
+  Object.defineProperty(exports, "DecodeError", { enumerable: true, get: function() {
+    return DecodeError_ts_1.DecodeError;
+  } });
+  var Encoder_ts_1 = require_Encoder();
+  Object.defineProperty(exports, "Encoder", { enumerable: true, get: function() {
+    return Encoder_ts_1.Encoder;
+  } });
+  var ExtensionCodec_ts_1 = require_ExtensionCodec();
+  Object.defineProperty(exports, "ExtensionCodec", { enumerable: true, get: function() {
+    return ExtensionCodec_ts_1.ExtensionCodec;
+  } });
+  var ExtData_ts_1 = require_ExtData();
+  Object.defineProperty(exports, "ExtData", { enumerable: true, get: function() {
+    return ExtData_ts_1.ExtData;
+  } });
+  var timestamp_ts_1 = require_timestamp();
+  Object.defineProperty(exports, "EXT_TIMESTAMP", { enumerable: true, get: function() {
+    return timestamp_ts_1.EXT_TIMESTAMP;
+  } });
+  Object.defineProperty(exports, "encodeDateToTimeSpec", { enumerable: true, get: function() {
+    return timestamp_ts_1.encodeDateToTimeSpec;
+  } });
+  Object.defineProperty(exports, "encodeTimeSpecToTimestamp", { enumerable: true, get: function() {
+    return timestamp_ts_1.encodeTimeSpecToTimestamp;
+  } });
+  Object.defineProperty(exports, "decodeTimestampToTimeSpec", { enumerable: true, get: function() {
+    return timestamp_ts_1.decodeTimestampToTimeSpec;
+  } });
+  Object.defineProperty(exports, "encodeTimestampExtension", { enumerable: true, get: function() {
+    return timestamp_ts_1.encodeTimestampExtension;
+  } });
+  Object.defineProperty(exports, "decodeTimestampExtension", { enumerable: true, get: function() {
+    return timestamp_ts_1.decodeTimestampExtension;
+  } });
+});
+
+// ../stream/src/serializers/MessagePackSerializer.ts
+var exports_MessagePackSerializer = {};
+__export(exports_MessagePackSerializer, {
+  MessagePackSerializer: () => MessagePackSerializer
+});
+
+class MessagePackSerializer {
+  msgpack;
+  constructor() {
+    try {
+      this.msgpack = require_dist6();
+    } catch (_e3) {
+      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 !== undefined ? { delaySeconds: job.delaySeconds } : {},
+      attempts: job.attempts ?? 0,
+      ...job.maxAttempts !== undefined ? { 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 buffer2 = Buffer.from(serialized.data, "base64");
+    const properties = this.msgpack.decode(buffer2);
+    const job = 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 !== undefined) {
+      job.delaySeconds = serialized.delaySeconds;
+    }
+    if (serialized.attempts !== undefined) {
+      job.attempts = serialized.attempts;
+    }
+    return job;
+  }
+}
+
 // ../../node_modules/.bun/cron-parser@5.4.0/node_modules/cron-parser/dist/fields/types.js
 var require_types2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -108756,7 +110973,7 @@ var require_CronFileParser = __commonJS((exports) => {
 });
 
 // ../../node_modules/.bun/cron-parser@5.4.0/node_modules/cron-parser/dist/index.js
-var require_dist6 = __commonJS((exports) => {
+var require_dist7 = __commonJS((exports) => {
   var __createBinding = exports && exports.__createBinding || (Object.create ? function(o3, m3, k3, k22) {
     if (k22 === undefined)
       k22 = k3;
@@ -108819,6 +111036,9 @@ class Scheduler {
   }
   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;
   }
   async register(config) {
@@ -108828,7 +111048,11 @@ class Scheduler {
       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)
@@ -108837,16 +111061,24 @@ class Scheduler {
     await pipe.exec();
   }
   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();
   }
   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,
@@ -108860,7 +111092,8 @@ class Scheduler {
     return configs;
   }
   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();
@@ -108869,14 +111102,21 @@ class Scheduler {
     }
   }
   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 / 1000)}`;
-      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);
@@ -108884,16 +111124,19 @@ class Scheduler {
             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);
           }
         }
       }
@@ -108903,7 +111146,7 @@ class Scheduler {
 }
 var import_cron_parser;
 var init_Scheduler = __esm(() => {
-  import_cron_parser = __toESM(require_dist6(), 1);
+  import_cron_parser = __toESM(require_dist7(), 1);
 });
 
 // ../../node_modules/.bun/hono@4.11.4/node_modules/hono/dist/utils/url.js
@@ -115596,7 +117839,7 @@ var require_mail_message = __commonJS((exports, module) => {
 
 // ../../node_modules/.bun/nodemailer@7.0.12/node_modules/nodemailer/lib/mailer/index.js
 var require_mailer = __commonJS((exports, module) => {
-  var EventEmitter = __require("events");
+  var EventEmitter2 = __require("events");
   var shared = require_shared2();
   var mimeTypes = require_mime_types();
   var MailComposer = require_mail_composer();
@@ -115610,7 +117853,7 @@ var require_mailer = __commonJS((exports, module) => {
   var dns = __require("dns");
   var crypto2 = __require("crypto");
 
-  class Mail extends EventEmitter {
+  class Mail extends EventEmitter2 {
     constructor(transporter, options, defaults2) {
       super();
       this.options = options || {};
@@ -115999,7 +118242,7 @@ var require_data_stream = __commonJS((exports, module) => {
 // ../../node_modules/.bun/nodemailer@7.0.12/node_modules/nodemailer/lib/smtp-connection/index.js
 var require_smtp_connection = __commonJS((exports, module) => {
   var packageInfo = require_package5();
-  var EventEmitter = __require("events").EventEmitter;
+  var EventEmitter2 = __require("events").EventEmitter;
   var net = __require("net");
   var tls = __require("tls");
   var os2 = __require("os");
@@ -116012,7 +118255,7 @@ var require_smtp_connection = __commonJS((exports, module) => {
   var GREETING_TIMEOUT = 30 * 1000;
   var DNS_TIMEOUT = 30 * 1000;
 
-  class SMTPConnection extends EventEmitter {
+  class SMTPConnection extends EventEmitter2 {
     constructor(options) {
       super(options);
       this.id = crypto2.randomBytes(8).toString("base64").replace(/\W/g, "");
@@ -117394,9 +119637,9 @@ var require_pool_resource = __commonJS((exports, module) => {
   var SMTPConnection = require_smtp_connection();
   var assign = require_shared2().assign;
   var XOAuth2 = require_xoauth2();
-  var EventEmitter = __require("events");
+  var EventEmitter2 = __require("events");
 
-  class PoolResource extends EventEmitter {
+  class PoolResource extends EventEmitter2 {
     constructor(pool) {
       super();
       this.pool = pool;
@@ -118149,14 +120392,14 @@ var require_well_known = __commonJS((exports, module) => {
 
 // ../../node_modules/.bun/nodemailer@7.0.12/node_modules/nodemailer/lib/smtp-pool/index.js
 var require_smtp_pool = __commonJS((exports, module) => {
-  var EventEmitter = __require("events");
+  var EventEmitter2 = __require("events");
   var PoolResource = require_pool_resource();
   var SMTPConnection = require_smtp_connection();
   var wellKnown = require_well_known();
   var shared = require_shared2();
   var packageData = require_package5();
 
-  class SMTPPool extends EventEmitter {
+  class SMTPPool extends EventEmitter2 {
     constructor(options) {
       super();
       options = options || {};
@@ -118568,14 +120811,14 @@ var require_smtp_pool = __commonJS((exports, module) => {
 
 // ../../node_modules/.bun/nodemailer@7.0.12/node_modules/nodemailer/lib/smtp-transport/index.js
 var require_smtp_transport = __commonJS((exports, module) => {
-  var EventEmitter = __require("events");
+  var EventEmitter2 = __require("events");
   var SMTPConnection = require_smtp_connection();
   var wellKnown = require_well_known();
   var shared = require_shared2();
   var XOAuth2 = require_xoauth2();
   var packageData = require_package5();
 
-  class SMTPTransport extends EventEmitter {
+  class SMTPTransport extends EventEmitter2 {
     constructor(options) {
       super();
       options = options || {};
@@ -119140,13 +121383,13 @@ var require_json_transport = __commonJS((exports, module) => {
 
 // ../../node_modules/.bun/nodemailer@7.0.12/node_modules/nodemailer/lib/ses-transport/index.js
 var require_ses_transport = __commonJS((exports, module) => {
-  var EventEmitter = __require("events");
+  var EventEmitter2 = __require("events");
   var packageData = require_package5();
   var shared = require_shared2();
   var LeWindows = require_le_windows();
   var MimeNode = require_mime_node();
 
-  class SESTransport extends EventEmitter {
+  class SESTransport extends EventEmitter2 {
     constructor(options) {
       super();
       options = options || {};
@@ -123894,6 +126137,127 @@ class QuasarAgent {
     }
   }
 }
+// ../stream/src/Consumer.ts
+import { EventEmitter } from "events";
+
+// ../../node_modules/.bun/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
+class Node3 {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Queue {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node3(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    if (!this.#head) {
+      this.#tail = undefined;
+    }
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = undefined;
+    this.#tail = undefined;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+}
+
+// ../../node_modules/.bun/p-limit@5.0.0/node_modules/p-limit/index.js
+import { AsyncResource } from "node:async_hooks";
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue;
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (function_, resolve, arguments_) => {
+    activeCount++;
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {}
+    next();
+  };
+  const enqueue = (function_, resolve, arguments_) => {
+    queue.enqueue(AsyncResource.bind(run.bind(undefined, function_, resolve, arguments_)));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve) => {
+    enqueue(function_, resolve, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
 // ../stream/src/Worker.ts
 class Worker {
   options;
@@ -123940,20 +126304,39 @@ class Worker {
 }
 
 // ../stream/src/Consumer.ts
-class Consumer {
+class Consumer extends EventEmitter {
   queueManager;
   options;
   running = false;
   stopRequested = false;
-  workerId = `worker-${Math.random().toString(36).substring(2, 8)}`;
+  workerId = `worker-${crypto.randomUUID()}`;
   heartbeatTimer = null;
+  groupLimiters = new Map;
+  stats = {
+    processed: 0,
+    failed: 0,
+    retried: 0,
+    active: 0
+  };
   constructor(queueManager, options) {
+    super();
     this.queueManager = queueManager;
     this.options = options;
   }
   get connectionName() {
     return this.options.connection ?? this.queueManager.getDefaultConnection();
   }
+  log(message, data) {
+    if (this.options.debug) {
+      const timestamp = new Date().toISOString();
+      const prefix = `[Consumer:${this.workerId}] [${timestamp}]`;
+      if (data) {
+        console.log(prefix, message, data);
+      } else {
+        console.log(prefix, message);
+      }
+    }
+  }
   async start() {
     if (this.running) {
       throw new Error("Consumer is already running");
@@ -123961,19 +126344,33 @@ class Consumer {
     this.running = true;
     this.stopRequested = false;
     const worker = new Worker(this.options.workerOptions);
-    const pollInterval = this.options.pollInterval ?? 1000;
+    let currentPollInterval = this.options.pollInterval ?? 1000;
+    const minPollInterval = this.options.minPollInterval ?? 100;
+    const maxPollInterval = this.options.maxPollInterval ?? 5000;
+    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];
@@ -123989,56 +126386,66 @@ class Consumer {
             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 / 1000);
-                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;
@@ -124046,7 +126453,79 @@ class Consumer {
     if (this.options.monitor) {
       await this.publishLog("info", "Consumer stopped");
     }
-    console.log("[Consumer] Stopped");
+    this.log("Stopped");
+  }
+  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 = pLimit(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);
+    }
+  }
+  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 / 1000);
+        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 ?? 5000 : 5000;
@@ -124065,7 +126544,8 @@ class Consumer {
               rss: Math.floor(mem.rss / 1024 / 1024),
               heapUsed: Math.floor(mem.heapUsed / 1024 / 1024),
               total: Math.floor(os2.totalmem() / 1024 / 1024)
-            }
+            },
+            stats: this.stats
           };
           await driver.reportHeartbeat({
             id: this.workerId,
@@ -124104,7 +126584,7 @@ class Consumer {
     } catch (_e) {}
   }
   async stop() {
-    console.log("[Consumer] Stopping...");
+    this.log("Stopping...");
     this.stopRequested = true;
     while (this.running) {
       await new Promise((resolve) => setTimeout(resolve, 100));
@@ -124113,15 +126593,31 @@ class Consumer {
   isRunning() {
     return this.running;
   }
+  getStats() {
+    return { ...this.stats };
+  }
+  resetStats() {
+    this.stats.processed = 0;
+    this.stats.failed = 0;
+    this.stats.retried = 0;
+  }
 }
 // ../stream/src/drivers/MemoryDriver.ts
 class MemoryDriver {
   queues = new Map;
+  maxSize;
+  constructor(config = {}) {
+    this.maxSize = config.maxSize ?? Infinity;
+  }
   async push(queue, job) {
     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);
   }
   async pop(queue) {
     const queueJobs = this.queues.get(queue);
@@ -124141,6 +126637,33 @@ class MemoryDriver {
   async clear(queue) {
     this.queues.delete(queue);
   }
+  async fail(queue, job) {
+    const failedQueue = `failed:${queue}`;
+    if (!this.queues.has(failedQueue)) {
+      this.queues.set(failedQueue, []);
+    }
+    this.queues.get(failedQueue)?.push(job);
+  }
+  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 * 1000;
+      if (isDelayed) {
+        delayed++;
+      } else {
+        pending++;
+      }
+    }
+    return {
+      queue,
+      size: pending,
+      delayed,
+      failed: this.queues.get(`failed:${queue}`)?.length || 0
+    };
+  }
   async pushMany(queue, jobs) {
     if (!this.queues.has(queue)) {
       this.queues.set(queue, []);
@@ -124160,6 +126683,26 @@ class MemoryDriver {
     return results;
   }
 }
+// ../stream/src/serializers/CachedSerializer.ts
+class CachedSerializer {
+  delegate;
+  cache = new WeakMap;
+  constructor(delegate) {
+    this.delegate = delegate;
+  }
+  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(serialized) {
+    return this.delegate.deserialize(serialized);
+  }
+}
+
 // ../stream/src/serializers/ClassNameSerializer.ts
 class ClassNameSerializer {
   jobClasses = new Map;
@@ -124172,7 +126715,7 @@ class ClassNameSerializer {
     }
   }
   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) {
@@ -124184,10 +126727,7 @@ class ClassNameSerializer {
       id,
       type: "class",
       className,
-      data: JSON.stringify({
-        class: className,
-        properties
-      }),
+      data: JSON.stringify(properties),
       createdAt: Date.now(),
       ...job.delaySeconds !== undefined ? { delaySeconds: job.delaySeconds } : {},
       attempts: job.attempts ?? 0,
@@ -124209,10 +126749,10 @@ class ClassNameSerializer {
     if (!JobClass) {
       throw new Error(`Job class "${serialized.className}" is not registered. Please register it using serializer.register().`);
     }
-    const parsed = JSON.parse(serialized.data);
+    const 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 !== undefined) {
@@ -124243,14 +126783,17 @@ class ClassNameSerializer {
 // ../stream/src/serializers/JsonSerializer.ts
 class JsonSerializer {
   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 !== undefined ? { delaySeconds: job.delaySeconds } : {},
       attempts: job.attempts ?? 0,
@@ -124263,15 +126806,22 @@ class JsonSerializer {
     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 = 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 !== undefined) {
+      job.delaySeconds = serialized.delaySeconds;
+    }
+    if (serialized.attempts !== undefined) {
+      job.attempts = serialized.attempts;
+    }
     return job;
   }
 }
@@ -124284,15 +126834,30 @@ class QueueManager {
   defaultSerializer;
   persistence;
   scheduler;
+  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 } = __toCommonJS(exports_BufferedPersistence);
+      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 } = __toCommonJS(exports_MessagePackSerializer);
+      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);
     }
@@ -124302,6 +126867,17 @@ class QueueManager {
       }
     }
   }
+  log(message, data) {
+    if (this.debug) {
+      const timestamp = new Date().toISOString();
+      const prefix = `[QueueManager] [${timestamp}]`;
+      if (data) {
+        console.log(prefix, message, data);
+      } else {
+        console.log(prefix, message);
+      }
+    }
+  }
   registerConnection(name, config) {
     const driverType = config.driver;
     switch (driverType) {
@@ -124310,48 +126886,44 @@ class QueueManager {
         break;
       case "database": {
         const { DatabaseDriver: DatabaseDriver2 } = __toCommonJS(exports_DatabaseDriver);
-        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.");
         }
         this.drivers.set(name, new DatabaseDriver2({
-          dbService,
+          dbService: config.dbService,
           table: config.table
         }));
         break;
       }
       case "redis": {
         const { RedisDriver: RedisDriver3 } = __toCommonJS(exports_RedisDriver);
-        const client = config.client;
-        if (!client) {
+        if (!config.client) {
           throw new Error("[QueueManager] RedisDriver requires client. Please provide Redis client in connection config.");
         }
         this.drivers.set(name, new RedisDriver3({
-          client,
+          client: config.client,
           prefix: config.prefix
         }));
         break;
       }
       case "kafka": {
         const { KafkaDriver: KafkaDriver2 } = __toCommonJS(exports_KafkaDriver);
-        const client = config.client;
-        if (!client) {
+        if (!config.client) {
           throw new Error("[QueueManager] KafkaDriver requires client. Please provide Kafka client in connection config.");
         }
         this.drivers.set(name, new KafkaDriver2({
-          client,
+          client: config.client,
           consumerGroupId: config.consumerGroupId
         }));
         break;
       }
       case "sqs": {
         const { SQSDriver: SQSDriver2 } = __toCommonJS(exports_SQSDriver);
-        const client = config.client;
-        if (!client) {
+        if (!config.client) {
           throw new Error("[QueueManager] SQSDriver requires client. Please provide SQS client in connection config.");
         }
         this.drivers.set(name, new SQSDriver2({
-          client,
+          client: config.client,
           queueUrlPrefix: config.queueUrlPrefix,
           visibilityTimeout: config.visibilityTimeout,
           waitTimeSeconds: config.waitTimeSeconds
@@ -124360,12 +126932,11 @@ class QueueManager {
       }
       case "rabbitmq": {
         const { RabbitMQDriver: RabbitMQDriver2 } = __toCommonJS(exports_RabbitMQDriver);
-        const client = config.client;
-        if (!client) {
+        if (!config.client) {
           throw new Error("[QueueManager] RabbitMQDriver requires client. Please provide RabbitMQ connection/channel in connection config.");
         }
         this.drivers.set(name, new RabbitMQDriver2({
-          client,
+          client: config.client,
           exchange: config.exchange,
           exchangeType: config.exchangeType
         }));
@@ -124411,6 +126982,11 @@ class QueueManager {
       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);
@@ -124418,10 +126994,12 @@ class QueueManager {
     }
     return job;
   }
-  async pushMany(jobs) {
+  async pushMany(jobs, options = {}) {
     if (jobs.length === 0) {
       return;
     }
+    const batchSize = options.batchSize ?? 100;
+    const concurrency = options.concurrency ?? 1;
     const groups = new Map;
     const serializer = this.getSerializer();
     for (const job of jobs) {
@@ -124434,17 +127012,42 @@ class QueueManager {
       }
       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 i3 = 0;i3 < serializedJobs.length; i3 += batchSize) {
+        chunks.push(serializedJobs.slice(i3, i3 + 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 i3 = 0;i3 < chunks.length; i3 += concurrency) {
+          const batchPromises = chunks.slice(i3, i3 + 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);
         }
       }
     }
@@ -124456,6 +127059,7 @@ class QueueManager {
     if (!serialized) {
       return null;
     }
+    this.log(`Popped job from ${queue} (${connection})`, { id: serialized.id });
     try {
       return serializer.deserialize(serialized);
     } catch (error) {
@@ -124463,14 +127067,71 @@ class QueueManager {
       return null;
     }
   }
+  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 i3 = 0;i3 < count; i3++) {
+        const job = await this.pop(queue, connection);
+        if (job) {
+          results.push(job);
+        } else {
+          break;
+        }
+      }
+    }
+    return results;
+  }
   async size(queue = "default", connection = this.defaultConnection) {
     const driver = this.getDriver(connection);
     return driver.size(queue);
   }
+  async popBlocking(queues = "default", timeout = 0, connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    const serializer = this.getSerializer();
+    if (!driver.popBlocking) {
+      const q3 = Array.isArray(queues) ? queues[0] : queues;
+      return this.pop(q3, 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;
+    }
+  }
   async clear(queue = "default", connection = this.defaultConnection) {
     const driver = this.getDriver(connection);
     await driver.clear(queue);
   }
+  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)
+    };
+  }
   async complete(job) {
     const connection = job.connectionName ?? this.defaultConnection;
     const queue = job.queueName ?? "default";
@@ -124479,6 +127140,7 @@ class QueueManager {
     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);
@@ -124496,6 +127158,7 @@ class QueueManager {
       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);
@@ -124539,26 +127202,38 @@ class MySQLPersistence {
   db;
   table;
   logsTable;
-  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;
   }
   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: 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 i3 = 0;i3 < jobs.length; i3 += batchSize) {
+      const chunk = jobs.slice(i3, i3 + 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: new Date
+        }));
+        await this.db.table(this.table).insert(records);
+      } catch (err) {
+        console.error(`[MySQLPersistence] Failed to archive ${chunk.length} jobs:`, err);
+      }
     }
   }
+  async flush() {}
   async find(queue, id) {
     const row = await this.db.table(this.table).where("queue", queue).where("job_id", id).first();
     if (!row) {
@@ -124593,7 +127268,7 @@ class MySQLPersistence {
       } catch (_e3) {
         return null;
       }
-    }).filter(Boolean);
+    }).filter((item) => !!item);
   }
   async search(query, options = {}) {
     let q3 = this.db.table(this.table);
@@ -124610,19 +127285,27 @@ class MySQLPersistence {
       } catch (_e3) {
         return null;
       }
-    }).filter(Boolean);
+    }).filter((item) => !!item);
   }
   async archiveLog(log) {
+    await this.archiveLogMany([log]);
+  }
+  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);
     }
   }
   async listLogs(options = {}) {
@@ -124667,8 +127350,8 @@ class MySQLPersistence {
     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;
   }
   async cleanup(days) {
     const threshold = new Date;
@@ -124677,7 +127360,7 @@ class MySQLPersistence {
       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);
   }
   async count(queue, options = {}) {
     let query = this.db.table(this.table).where("queue", queue);
@@ -124693,8 +127376,8 @@ class MySQLPersistence {
     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;
   }
   async setupTable() {
     await Promise.all([this.setupJobsTable(), this.setupLogsTable()]);
@@ -124745,26 +127428,45 @@ class SQLitePersistence {
   db;
   table;
   logsTable;
-  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;
   }
   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: 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 i3 = 0;i3 < jobs.length; i3 += batchSize) {
+      const chunk = jobs.slice(i3, i3 + 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: 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);
+      }
     }
   }
+  async flush() {}
   async find(queue, id) {
     const row = await this.db.table(this.table).where("queue", queue).where("job_id", id).first();
     if (!row) {
@@ -124799,7 +127501,7 @@ class SQLitePersistence {
       } catch (_e3) {
         return null;
       }
-    }).filter(Boolean);
+    }).filter((item) => !!item);
   }
   async search(query, options = {}) {
     let q3 = this.db.table(this.table);
@@ -124816,19 +127518,27 @@ class SQLitePersistence {
       } catch (_e3) {
         return null;
       }
-    }).filter(Boolean);
+    }).filter((item) => !!item);
   }
   async archiveLog(log) {
+    await this.archiveLogMany([log]);
+  }
+  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);
     }
   }
   async listLogs(options = {}) {
@@ -124873,8 +127583,8 @@ class SQLitePersistence {
     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;
   }
   async cleanup(days) {
     const threshold = new Date;
@@ -124883,7 +127593,7 @@ class SQLitePersistence {
       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);
   }
   async count(queue, options = {}) {
     let query = this.db.table(this.table).where("queue", queue);
@@ -124899,8 +127609,8 @@ class SQLitePersistence {
     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;
   }
   async setupTable() {
     await Promise.all([this.setupJobsTable(), this.setupLogsTable()]);
@@ -125872,20 +128582,20 @@ class PulseService {
 }
 
 // src/server/services/QueueService.ts
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 var import_ioredis5 = __toESM(require_built4(), 1);
 
 // src/server/services/AlertService.ts
 var import_ioredis4 = __toESM(require_built4(), 1);
 var import_nodemailer = __toESM(require_nodemailer(), 1);
-import { EventEmitter } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
 
 class AlertService {
   redis;
   rules = [];
   config = { channels: {} };
   cooldowns = new Map;
-  emitter = new EventEmitter;
+  emitter = new EventEmitter2;
   RULES_KEY = "gravito:zenith:alerts:rules";
   CONFIG_KEY = "gravito:zenith:alerts:config";
   constructor(redisUrl) {
@@ -126132,13 +128842,13 @@ Severity: ${event.severity}`,
 }
 
 // src/server/services/LogStreamProcessor.ts
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 
 class LogStreamProcessor {
   redis;
   subRedis;
   static MAX_LOGS_PER_SEC = 50;
-  logEmitter = new EventEmitter2;
+  logEmitter = new EventEmitter3;
   logThrottleCount = 0;
   logThrottleReset = Date.now();
   constructor(redis, subRedis) {
@@ -126341,7 +129051,7 @@ class QueueService {
   redis;
   subRedis;
   prefix;
-  logEmitter = new EventEmitter3;
+  logEmitter = new EventEmitter4;
   manager;
   alerts;
   logProcessor;
@@ -126776,7 +129486,7 @@ if (dbDriver === "sqlite" || process.env.DB_HOST) {
       password: process.env.DB_PASSWORD || ""
     });
   }
-  const adapter = dbDriver === "sqlite" ? new SQLitePersistence(DB) : new MySQLPersistence(DB);
+  const adapter = dbDriver === "sqlite" ? new SQLitePersistence(DB.connection()) : new MySQLPersistence(DB.connection());
   adapter.setupTable().catch((err) => console.error("[FluxConsole] SQL Archive Setup Error:", err));
   persistence = {
     adapter,