gramobase 1.0.0

package/dist/index.js

@@ -0,0 +1,1611 @@
+import { z } from 'zod';
+import TelegramBot from 'node-telegram-bot-api';
+import PQueue from 'p-queue';
+import pRetry, { AbortError } from 'p-retry';
+import EventEmitter from 'eventemitter3';
+import { LRUCache } from 'lru-cache';
+import { randomUUID, createHash, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
+import * as jwt from 'jsonwebtoken';
+import * as bcrypt from 'bcryptjs';
+import { existsSync, readFileSync } from 'fs';
+
+// gramobase — Telegram as your free, infinite backend
+
+var BotWorkerPool = class extends EventEmitter {
+  bots = [];
+  queues = [];
+  stats = [];
+  currentIndex = 0;
+  debug;
+  constructor(tokens, concurrency = 25, debug = false) {
+    super();
+    this.debug = debug;
+    if (tokens.length === 0) throw new Error("[gramobase] At least one bot token required");
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      this.bots.push(new TelegramBot(token, { polling: false }));
+      this.queues.push(new PQueue({ concurrency, intervalCap: 25, interval: 1e3 }));
+      this.stats.push({
+        tokenIndex: i,
+        requestCount: 0,
+        errorCount: 0,
+        lastUsed: 0,
+        rateLimitHits: 0
+      });
+    }
+  }
+  /**
+   * Execute a Telegram API call through the pool with automatic retry
+   * and token rotation on rate limits.
+   */
+  async execute(fn, priority = 5) {
+    const idx = this.pickWorker();
+    const queue = this.queues[idx];
+    const bot = this.bots[idx];
+    const stat = this.stats[idx];
+    return queue.add(
+      () => pRetry(
+        async () => {
+          stat.requestCount++;
+          stat.lastUsed = Date.now();
+          try {
+            const result = await fn(bot);
+            return result;
+          } catch (err) {
+            stat.errorCount++;
+            if (this.isFloodError(err)) {
+              stat.rateLimitHits++;
+              this.emit("worker:rotate", idx);
+              const retryAfter = this.extractRetryAfter(err) * 1e3;
+              if (this.debug) {
+                console.warn(`[gramobase] Worker ${idx} flood limited, retrying after ${retryAfter}ms`);
+              }
+              await this.sleep(retryAfter);
+              throw err;
+            }
+            if (this.isRetryableError(err)) {
+              throw err;
+            }
+            throw new AbortError(err instanceof Error ? err : new Error(String(err)));
+          }
+        },
+        {
+          retries: 5,
+          factor: 2,
+          minTimeout: 1e3,
+          maxTimeout: 3e4,
+          onFailedAttempt: (error) => {
+            if (this.debug) {
+              console.warn(`[gramobase] Attempt ${error.attemptNumber} failed:`, error.message);
+            }
+          }
+        }
+      ),
+      { priority }
+    );
+  }
+  /**
+   * Round-robin with recency bias — prefer the worker that was least recently used.
+   */
+  pickWorker() {
+    if (this.bots.length === 1) return 0;
+    let bestIdx = 0;
+    let oldestTime = Infinity;
+    for (let i = 0; i < this.stats.length; i++) {
+      const stat = this.stats[i];
+      if (stat.lastUsed < oldestTime) {
+        oldestTime = stat.lastUsed;
+        bestIdx = i;
+      }
+    }
+    this.currentIndex = bestIdx;
+    return bestIdx;
+  }
+  isFloodError(err) {
+    if (err && typeof err === "object") {
+      const e = err;
+      return e.code === "ETELEGRAM" && e.response?.statusCode === 429;
+    }
+    return false;
+  }
+  isRetryableError(err) {
+    if (!err) return false;
+    if (err instanceof Error) {
+      if (err.name === "TypeError" || err.name === "ReferenceError" || err.name === "ValidationError") {
+        return false;
+      }
+    }
+    if (typeof err === "object") {
+      const e = err;
+      if (e.code === "ETELEGRAM" && e.response?.statusCode === 429) {
+        return true;
+      }
+      if (e.response?.statusCode && e.response.statusCode >= 500) {
+        return true;
+      }
+      const retryableCodes = ["ETIMEDOUT", "ECONNRESET", "ENOTFOUND", "EAI_AGAIN", "ECONNREFUSED"];
+      if (e.code && retryableCodes.includes(e.code)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  extractRetryAfter(err) {
+    if (err && typeof err === "object") {
+      const e = err;
+      return e.response?.body?.parameters?.retry_after ?? 5;
+    }
+    return 5;
+  }
+  getBot(index = 0) {
+    return this.bots[index] ?? this.bots[0];
+  }
+  getStats() {
+    return [...this.stats];
+  }
+  getQueueSizes() {
+    return this.queues.map((q) => q.size);
+  }
+  sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+  async destroy() {
+    await Promise.all(this.queues.map((q) => q.onIdle()));
+    for (const bot of this.bots) {
+      await bot.stopPolling();
+    }
+  }
+};
+var HotCache = class extends EventEmitter {
+  cache;
+  collectionIndexes = /* @__PURE__ */ new Map();
+  stats = { hits: 0, misses: 0, evictions: 0 };
+  constructor(maxBytes = 64 * 1024 * 1024, ttlMs = 6e4) {
+    super();
+    this.cache = new LRUCache({
+      maxSize: maxBytes,
+      sizeCalculation: (val) => JSON.stringify(val).length * 2,
+      // rough UTF-16 byte estimate
+      ttl: ttlMs,
+      dispose: () => {
+        this.stats.evictions++;
+      }
+    });
+  }
+  // ─── Document cache ──────────────────────────────────────────────────────
+  get(collection, id) {
+    const key = this.docKey(collection, id);
+    const entry = this.cache.get(key);
+    if (entry) {
+      this.stats.hits++;
+      this.emit("cache:hit", { collection, key: id });
+      return entry.data;
+    }
+    this.stats.misses++;
+    this.emit("cache:miss", { collection, key: id });
+    return void 0;
+  }
+  set(collection, id, data) {
+    const key = this.docKey(collection, id);
+    this.cache.set(key, { data, collection, cachedAt: Date.now() });
+  }
+  delete(collection, id) {
+    this.cache.delete(this.docKey(collection, id));
+  }
+  invalidateCollection(collection) {
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(`doc:${collection}:`)) {
+        this.cache.delete(key);
+      }
+    }
+    this.collectionIndexes.delete(collection);
+  }
+  // ─── Query cache ─────────────────────────────────────────────────────────
+  getQuery(queryHash) {
+    const entry = this.cache.get(`query:${queryHash}`);
+    return entry?.data;
+  }
+  setQuery(queryHash, results) {
+    this.cache.set(`query:${queryHash}`, {
+      data: results,
+      collection: "__query__",
+      cachedAt: Date.now()
+    });
+  }
+  invalidateQuery(collection) {
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(`query:${collection}:`)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  // ─── Collection index ─────────────────────────────────────────────────────
+  // Maps document _id → Telegram message ID for O(1) lookup
+  getIndex(collection) {
+    return this.collectionIndexes.get(collection);
+  }
+  setIndex(collection, index) {
+    this.collectionIndexes.set(collection, index);
+  }
+  updateIndexEntry(collection, id, msgId) {
+    const idx = this.collectionIndexes.get(collection);
+    if (idx) {
+      idx.set(id, msgId);
+    } else {
+      this.collectionIndexes.set(collection, /* @__PURE__ */ new Map([[id, msgId]]));
+    }
+  }
+  deleteIndexEntry(collection, id) {
+    this.collectionIndexes.get(collection)?.delete(id);
+  }
+  getMsgId(collection, id) {
+    return this.collectionIndexes.get(collection)?.get(id);
+  }
+  // ─── Bulk read ────────────────────────────────────────────────────────────
+  getMany(collection, ids) {
+    const result = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      const val = this.get(collection, id);
+      if (val !== void 0) result.set(id, val);
+    }
+    return result;
+  }
+  // ─── Stats ────────────────────────────────────────────────────────────────
+  getStats() {
+    return {
+      ...this.stats,
+      size: this.cache.size,
+      hitRate: this.stats.hits + this.stats.misses > 0 ? this.stats.hits / (this.stats.hits + this.stats.misses) : 0
+    };
+  }
+  clear() {
+    this.cache.clear();
+    this.collectionIndexes.clear();
+  }
+  docKey(collection, id) {
+    return `doc:${collection}:${id}`;
+  }
+};
+var INDEX_TAG = "__GRAMOBASE_INDEX__";
+var DOC_TAG = "__GRAMOBASE_DOC__";
+var MAX_MSG_BYTES = 4e3;
+var TelegramStorage = class {
+  constructor(pool, defaultChannelId, encryptionKey, debug = false) {
+    this.pool = pool;
+    this.defaultChannelId = defaultChannelId;
+    this.debug = debug;
+    if (encryptionKey) {
+      this.encryptionKey = createHash("sha256").update(encryptionKey).digest();
+    }
+  }
+  pool;
+  defaultChannelId;
+  debug;
+  encryptionKey = null;
+  // collection → pinned index message ID
+  indexMsgIds = /* @__PURE__ */ new Map();
+  // ─── Index management ─────────────────────────────────────────────────────
+  async loadIndex(collection, channelId) {
+    const channel = channelId ?? this.defaultChannelId;
+    try {
+      const chat = await this.pool.execute((bot) => bot.getChat(channel));
+      if (chat.pinned_message?.text?.startsWith(INDEX_TAG)) {
+        const json = chat.pinned_message.text.replace(INDEX_TAG + "\n", "");
+        const parsed = JSON.parse(json);
+        this.indexMsgIds.set(collection, chat.pinned_message.message_id);
+        return parsed;
+      }
+    } catch {
+    }
+    return {
+      collection,
+      entries: {},
+      walSeq: 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async saveIndex(index, channelId) {
+    const channel = channelId ?? this.defaultChannelId;
+    const text = `${INDEX_TAG}
+${JSON.stringify(index)}`;
+    const existingMsgId = this.indexMsgIds.get(index.collection);
+    if (existingMsgId) {
+      try {
+        await this.pool.execute(
+          (bot) => bot.editMessageText(text, {
+            chat_id: channel,
+            message_id: existingMsgId
+          })
+        );
+        return;
+      } catch {
+      }
+    }
+    const msg = await this.pool.execute(
+      (bot) => bot.sendMessage(channel, text, { disable_notification: true })
+    );
+    this.indexMsgIds.set(index.collection, msg.message_id);
+    await this.pool.execute(
+      (bot) => bot.pinChatMessage(channel, msg.message_id, { disable_notification: true })
+    );
+  }
+  // ─── Document CRUD ────────────────────────────────────────────────────────
+  async writeDocument(doc, channelId) {
+    const channel = channelId ?? this.defaultChannelId;
+    let text = JSON.stringify({ [DOC_TAG]: true, ...doc });
+    if (this.encryptionKey) {
+      text = this.encrypt(text);
+    }
+    if (Buffer.byteLength(text, "utf8") > MAX_MSG_BYTES) {
+      return this.writeChunked(text, channel);
+    }
+    const msg = await this.pool.execute(
+      (bot) => bot.sendMessage(channel, text, { disable_notification: true })
+    );
+    return msg.message_id;
+  }
+  async readDocument(msgId, channelId) {
+    const channel = channelId ?? this.defaultChannelId;
+    try {
+      const msgs = await this.pool.execute(
+        (bot) => bot.forwardMessages(channel, channel, [msgId])
+      );
+      const msg = Array.isArray(msgs) ? msgs[0] : msgs;
+      if (!msg?.text) return null;
+      let text = msg.text;
+      if (this.encryptionKey && text.startsWith("ENC:")) {
+        text = this.decrypt(text);
+      }
+      if (text.startsWith("CHUNK:")) {
+        text = await this.readChunked(text, channel);
+      }
+      const parsed = JSON.parse(text);
+      delete parsed[DOC_TAG];
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  async deleteDocument(msgId, channelId) {
+    const channel = channelId ?? this.defaultChannelId;
+    await this.pool.execute(
+      (bot) => bot.deleteMessage(channel, msgId)
+    );
+  }
+  async updateDocument(msgId, doc, channelId) {
+    await this.deleteDocument(msgId, channelId);
+    return this.writeDocument(doc, channelId);
+  }
+  // ─── Chunked large documents ──────────────────────────────────────────────
+  async writeChunked(text, channel) {
+    const chunks = [];
+    for (let i = 0; i < text.length; i += MAX_MSG_BYTES) {
+      chunks.push(text.slice(i, i + MAX_MSG_BYTES));
+    }
+    const msgIds = [];
+    for (const chunk of chunks) {
+      const msg = await this.pool.execute(
+        (bot) => bot.sendMessage(channel, chunk, { disable_notification: true })
+      );
+      msgIds.push(msg.message_id);
+    }
+    const header = `CHUNK:${JSON.stringify(msgIds)}`;
+    const headerMsg = await this.pool.execute(
+      (bot) => bot.sendMessage(channel, header, { disable_notification: true })
+    );
+    return headerMsg.message_id;
+  }
+  async readChunked(headerText, channel) {
+    const msgIds = JSON.parse(headerText.replace("CHUNK:", ""));
+    const parts = [];
+    for (const id of msgIds) {
+      const msgs = await this.pool.execute(
+        (bot) => bot.forwardMessages(channel, channel, [id])
+      );
+      const msg = Array.isArray(msgs) ? msgs[0] : msgs;
+      if (msg?.text) parts.push(msg.text);
+    }
+    return parts.join("");
+  }
+  // ─── File storage ─────────────────────────────────────────────────────────
+  async uploadFile(data, fileName, mimeType, channelId) {
+    const channel = channelId ?? this.defaultChannelId;
+    const isImage = mimeType.startsWith("image/");
+    let msg;
+    if (isImage) {
+      msg = await this.pool.execute(
+        (bot) => bot.sendPhoto(channel, data, {
+          caption: fileName,
+          disable_notification: true
+        })
+      );
+    } else {
+      msg = await this.pool.execute(
+        (bot) => bot.sendDocument(channel, data, {
+          caption: fileName,
+          disable_notification: true
+        })
+      );
+    }
+    const fileId = isImage ? msg.photo?.[msg.photo.length - 1]?.file_id : msg.document?.file_id;
+    return { fileId, msgId: msg.message_id };
+  }
+  async getFileUrl(fileId) {
+    return this.pool.execute((bot) => bot.getFileLink(fileId));
+  }
+  // ─── Encryption ───────────────────────────────────────────────────────────
+  encrypt(text) {
+    if (!this.encryptionKey) return text;
+    const iv = randomBytes(16);
+    const cipher = createCipheriv("aes-256-cbc", this.encryptionKey, iv);
+    const encrypted = Buffer.concat([
+      cipher.update(text, "utf8"),
+      cipher.final()
+    ]);
+    return `ENC:${iv.toString("hex")}:${encrypted.toString("base64")}`;
+  }
+  decrypt(text) {
+    if (!this.encryptionKey) return text;
+    const [, ivHex, encB64] = text.split(":");
+    if (!ivHex || !encB64) throw new Error("Invalid encrypted payload");
+    const iv = Buffer.from(ivHex, "hex");
+    const encBuf = Buffer.from(encB64, "base64");
+    const decipher = createDecipheriv("aes-256-cbc", this.encryptionKey, iv);
+    return Buffer.concat([decipher.update(encBuf), decipher.final()]).toString("utf8");
+  }
+};
+var WAL_HEADER = "__WAL__";
+var WAL_SEQ_TAG = "__WAL_SEQ__";
+var WriteAheadLog = class {
+  constructor(pool, walChannelId, debug = false) {
+    this.pool = pool;
+    this.walChannelId = walChannelId;
+    this.debug = debug;
+  }
+  pool;
+  walChannelId;
+  debug;
+  seq = 0;
+  buffer = [];
+  flushTimer = null;
+  FLUSH_INTERVAL_MS = 2e3;
+  BUFFER_LIMIT = 50;
+  async init() {
+    try {
+      const msgs = await this.pool.execute(
+        (bot) => bot.getChatHistory(this.walChannelId, { limit: 10 })
+      );
+      for (const msg of msgs.reverse()) {
+        if (msg.text?.includes(WAL_SEQ_TAG)) {
+          const match = msg.text.match(/__WAL_SEQ__:(\d+)/);
+          if (match) {
+            this.seq = parseInt(match[1], 10);
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+    if (this.debug) console.log(`[WAL] Initialized at seq=${this.seq}`);
+  }
+  /**
+   * Append an entry to the WAL buffer. Flushes immediately if buffer is full.
+   */
+  async append(op, collection, id, data) {
+    this.seq++;
+    const entry = {
+      seq: this.seq,
+      op,
+      collection,
+      id,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      checksum: ""
+    };
+    entry.checksum = this.checksum(entry);
+    this.buffer.push(entry);
+    if (this.buffer.length >= this.BUFFER_LIMIT) {
+      await this.flush();
+    } else {
+      this.scheduleFlush();
+    }
+    return entry;
+  }
+  /**
+   * Flush buffered WAL entries to Telegram.
+   */
+  async flush() {
+    if (this.buffer.length === 0) return;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    const batch = [...this.buffer];
+    this.buffer = [];
+    const payload = JSON.stringify({
+      __wal: true,
+      [WAL_SEQ_TAG]: batch[batch.length - 1].seq,
+      entries: batch
+    });
+    const chunks = this.chunk(payload, 4e3);
+    for (const chunk of chunks) {
+      await this.pool.execute(
+        (bot) => bot.sendMessage(this.walChannelId, `${WAL_HEADER}
+${chunk}`, {
+          disable_notification: true
+        })
+      );
+    }
+    if (this.debug) console.log(`[WAL] Flushed ${batch.length} entries`);
+    this.pool.emit("wal:flush", batch.length);
+  }
+  /**
+   * Replay all WAL entries since a given sequence number.
+   * Returns entries in order — the caller applies them to restore state.
+   */
+  async replay(sinceSeq = 0) {
+    const entries = [];
+    try {
+      const msgs = await this.pool.execute(
+        (bot) => bot.getChatHistory(this.walChannelId, { limit: 100 })
+      );
+      for (const msg of msgs) {
+        if (!msg.text?.startsWith(WAL_HEADER)) continue;
+        const jsonStr = msg.text.replace(WAL_HEADER + "\n", "");
+        try {
+          const parsed = JSON.parse(jsonStr);
+          if (parsed.__wal && Array.isArray(parsed.entries)) {
+            for (const e of parsed.entries) {
+              if (e.seq > sinceSeq && this.verifyChecksum(e)) {
+                entries.push(e);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return entries.sort((a, b) => a.seq - b.seq);
+  }
+  scheduleFlush() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => this.flush(), this.FLUSH_INTERVAL_MS);
+  }
+  checksum(entry) {
+    const str = `${entry.seq}:${entry.op}:${entry.collection}:${entry.id}:${JSON.stringify(entry.data)}`;
+    return createHash("sha256").update(str).digest("hex").slice(0, 16);
+  }
+  verifyChecksum(entry) {
+    const { checksum, ...rest } = entry;
+    return checksum === this.checksum(rest);
+  }
+  chunk(str, size) {
+    const chunks = [];
+    for (let i = 0; i < str.length; i += size) {
+      chunks.push(str.slice(i, i + size));
+    }
+    return chunks;
+  }
+  getCurrentSeq() {
+    return this.seq;
+  }
+};
+var REGISTRY_TAG = "__GRAMOBASE_REGISTRY__";
+var LEASE_TTL_MS = 3e4;
+var HEARTBEAT_MS = 1e4;
+var Registry = class {
+  constructor(pool, channelId, debug = false) {
+    this.pool = pool;
+    this.channelId = channelId;
+    this.debug = debug;
+    this.instanceId = randomUUID();
+    this.state = {
+      activeLease: null,
+      instanceId: this.instanceId,
+      registryMsgId: null
+    };
+  }
+  pool;
+  channelId;
+  debug;
+  state;
+  instanceId;
+  async acquireWriteLease() {
+    const existing = await this.readRegistryMessage();
+    if (existing?.activeLease) {
+      const lease2 = existing.activeLease;
+      if (lease2.instanceId !== this.instanceId && Date.now() < lease2.expiresAt) {
+        throw new Error(
+          `[gramobase Registry] Another instance (${lease2.instanceId}) holds the write lease until ${new Date(lease2.expiresAt).toISOString()}. Use Registry.forceRelease() to break a stale lease.`
+        );
+      }
+    }
+    const lease = {
+      instanceId: this.instanceId,
+      acquiredAt: Date.now(),
+      expiresAt: Date.now() + LEASE_TTL_MS,
+      heartbeatInterval: null
+    };
+    await this.writeRegistryMessage({ activeLease: lease });
+    this.state.activeLease = lease;
+    lease.heartbeatInterval = setInterval(
+      () => this.heartbeat(),
+      HEARTBEAT_MS
+    );
+    if (this.debug) console.log(`[Registry] Acquired write lease: ${this.instanceId}`);
+    return lease;
+  }
+  async releaseWriteLease() {
+    if (!this.state.activeLease) return;
+    if (this.state.activeLease.heartbeatInterval) {
+      clearInterval(this.state.activeLease.heartbeatInterval);
+    }
+    await this.writeRegistryMessage({ activeLease: null });
+    this.state.activeLease = null;
+    if (this.debug) console.log(`[Registry] Released write lease: ${this.instanceId}`);
+  }
+  async forceRelease() {
+    await this.writeRegistryMessage({ activeLease: null });
+    this.state.activeLease = null;
+    if (this.debug) console.log("[Registry] Forced lease release");
+  }
+  async isWriteLeaseHeld() {
+    const state = await this.readRegistryMessage();
+    if (!state?.activeLease) return false;
+    const { activeLease } = state;
+    return activeLease.instanceId === this.instanceId && Date.now() < activeLease.expiresAt;
+  }
+  async heartbeat() {
+    if (!this.state.activeLease) return;
+    this.state.activeLease.expiresAt = Date.now() + LEASE_TTL_MS;
+    await this.writeRegistryMessage({ activeLease: this.state.activeLease });
+    if (this.debug) console.log("[Registry] Heartbeat sent");
+  }
+  async readRegistryMessage() {
+    try {
+      const chat = await this.pool.execute(
+        (bot) => bot.getChat(this.channelId)
+      );
+      if (chat.pinned_message?.text?.startsWith(REGISTRY_TAG)) {
+        this.state.registryMsgId = chat.pinned_message.message_id;
+        const json = chat.pinned_message.text.replace(REGISTRY_TAG + "\n", "");
+        return JSON.parse(json);
+      }
+    } catch {
+    }
+    return null;
+  }
+  async writeRegistryMessage(data) {
+    const text = `${REGISTRY_TAG}
+${JSON.stringify(data, null, 0)}`;
+    if (this.state.registryMsgId) {
+      try {
+        await this.pool.execute(
+          (bot) => bot.editMessageText(text, {
+            chat_id: this.channelId,
+            message_id: this.state.registryMsgId
+          })
+        );
+        return;
+      } catch {
+      }
+    }
+    const msg = await this.pool.execute(
+      (bot) => bot.sendMessage(this.channelId, text, { disable_notification: true })
+    );
+    this.state.registryMsgId = msg.message_id;
+    await this.pool.execute(
+      (bot) => bot.pinChatMessage(this.channelId, msg.message_id, {
+        disable_notification: true
+      })
+    );
+  }
+  getInstanceId() {
+    return this.instanceId;
+  }
+  getCurrentLease() {
+    return this.state.activeLease;
+  }
+};
+var Collection = class {
+  name;
+  config;
+  cache;
+  storage;
+  wal;
+  channelId;
+  indexLoaded = false;
+  constructor(name, config, cache, storage, wal, defaultChannelId) {
+    this.name = name;
+    this.config = config;
+    this.cache = cache;
+    this.storage = storage;
+    this.wal = wal;
+    this.channelId = config.channelId ?? defaultChannelId;
+  }
+  // ─── Init ──────────────────────────────────────────────────────────────
+  async ensureIndexLoaded() {
+    if (this.indexLoaded) return;
+    const idx = await this.storage.loadIndex(this.name, this.channelId);
+    this.cache.setIndex(this.name, new Map(Object.entries(idx.entries).map(([k, v]) => [k, v])));
+    this.indexLoaded = true;
+  }
+  // ─── Insert ────────────────────────────────────────────────────────────
+  async insertOne(data) {
+    const validated = this.config.schema.parse(data);
+    const doc = {
+      ...validated,
+      _id: randomUUID(),
+      _collection: this.name,
+      _msgId: 0,
+      _createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      _updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.wal.append("INSERT", this.name, doc._id, doc);
+    const msgId = await this.storage.writeDocument(doc, this.channelId);
+    doc._msgId = msgId;
+    this.cache.set(this.name, doc._id, doc);
+    this.cache.updateIndexEntry(this.name, doc._id, msgId);
+    this.cache.invalidateQuery(this.name);
+    await this.flushIndex();
+    return doc;
+  }
+  async insertMany(items) {
+    return Promise.all(items.map((item) => this.insertOne(item)));
+  }
+  // ─── Find ──────────────────────────────────────────────────────────────
+  async findById(id) {
+    const cached = this.cache.get(this.name, id);
+    if (cached) return cached;
+    await this.ensureIndexLoaded();
+    const msgId = this.cache.getMsgId(this.name, id);
+    if (!msgId) return null;
+    const doc = await this.storage.readDocument(msgId, this.channelId);
+    if (!doc) return null;
+    this.cache.set(this.name, id, doc);
+    return doc;
+  }
+  async findOne(filter = {}) {
+    const results = await this.find({ filter, limit: 1 });
+    return results[0] ?? null;
+  }
+  async find(options = {}) {
+    const { filter = {}, sort, limit, skip = 0, projection, useCache = true } = options;
+    const queryHash = this.hashQuery(filter, sort, limit, skip);
+    if (useCache) {
+      const cached = this.cache.getQuery(queryHash);
+      if (cached) return cached;
+    }
+    await this.ensureIndexLoaded();
+    const index = this.cache.getIndex(this.name);
+    if (!index) return [];
+    const docs = [];
+    const ids = [...index.keys()];
+    const uncachedIds = [];
+    for (const id of ids) {
+      const cached = this.cache.get(this.name, id);
+      if (cached) {
+        docs.push(cached);
+      } else {
+        uncachedIds.push(id);
+      }
+    }
+    await Promise.all(
+      uncachedIds.map(async (id) => {
+        const doc = await this.findById(id);
+        if (doc) docs.push(doc);
+      })
+    );
+    let results = docs.filter((doc) => this.matchesFilter(doc, filter));
+    if (sort) {
+      results = this.applySort(results, sort);
+    }
+    results = results.slice(skip, limit ? skip + limit : void 0);
+    if (projection) {
+      results = results.map((doc) => this.applyProjection(doc, projection));
+    }
+    if (useCache) {
+      this.cache.setQuery(queryHash, results);
+    }
+    return results;
+  }
+  async count(filter = {}) {
+    const results = await this.find({ filter, useCache: true });
+    return results.length;
+  }
+  // ─── Update ────────────────────────────────────────────────────────────
+  async updateOne(filter, update) {
+    const doc = await this.findOne(filter);
+    if (!doc) return null;
+    return this.applyUpdate(doc, update);
+  }
+  async updateMany(filter, update) {
+    const docs = await this.find({ filter });
+    return Promise.all(docs.map((doc) => this.applyUpdate(doc, update)));
+  }
+  async findByIdAndUpdate(id, update) {
+    const doc = await this.findById(id);
+    if (!doc) return null;
+    return this.applyUpdate(doc, update);
+  }
+  async applyUpdate(doc, update) {
+    const updated = { ...doc, _updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    if (update.$set) Object.assign(updated, update.$set);
+    if (update.$unset) {
+      for (const key of Object.keys(update.$unset)) {
+        delete updated[key];
+      }
+    }
+    if (update.$inc) {
+      for (const [key, val] of Object.entries(update.$inc)) {
+        updated[key] = (updated[key] ?? 0) + val;
+      }
+    }
+    if (update.$push) {
+      for (const [key, val] of Object.entries(update.$push)) {
+        const arr = updated[key];
+        updated[key] = Array.isArray(arr) ? [...arr, val] : [val];
+      }
+    }
+    this.config.schema.parse(updated);
+    await this.wal.append("UPDATE", this.name, updated._id, updated);
+    const newMsgId = await this.storage.updateDocument(
+      updated._msgId,
+      updated,
+      this.channelId
+    );
+    updated._msgId = newMsgId;
+    this.cache.set(this.name, updated._id, updated);
+    this.cache.updateIndexEntry(this.name, updated._id, newMsgId);
+    this.cache.invalidateQuery(this.name);
+    await this.flushIndex();
+    return updated;
+  }
+  // ─── Delete ────────────────────────────────────────────────────────────
+  async deleteOne(filter) {
+    const doc = await this.findOne(filter);
+    if (!doc) return false;
+    return this.deleteById(doc._id);
+  }
+  async deleteMany(filter) {
+    const docs = await this.find({ filter });
+    await Promise.all(docs.map((doc) => this.deleteById(doc._id)));
+    return docs.length;
+  }
+  async deleteById(id) {
+    const msgId = this.cache.getMsgId(this.name, id);
+    if (!msgId) return false;
+    await this.wal.append("DELETE", this.name, id);
+    await this.storage.deleteDocument(msgId, this.channelId);
+    this.cache.delete(this.name, id);
+    this.cache.deleteIndexEntry(this.name, id);
+    this.cache.invalidateQuery(this.name);
+    await this.flushIndex();
+    return true;
+  }
+  // ─── Index flush ──────────────────────────────────────────────────────
+  async flushIndex() {
+    const index = this.cache.getIndex(this.name);
+    if (!index) return;
+    await this.storage.saveIndex(
+      {
+        collection: this.name,
+        entries: Object.fromEntries(index.entries()),
+        walSeq: this.wal.getCurrentSeq(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      this.channelId
+    );
+  }
+  // ─── Filter engine ─────────────────────────────────────────────────────
+  matchesFilter(doc, filter) {
+    for (const [key, condition] of Object.entries(filter)) {
+      if (key === "$and") {
+        if (!condition.every((f) => this.matchesFilter(doc, f)))
+          return false;
+        continue;
+      }
+      if (key === "$or") {
+        if (!condition.some((f) => this.matchesFilter(doc, f)))
+          return false;
+        continue;
+      }
+      if (key === "$not") {
+        if (this.matchesFilter(doc, condition)) return false;
+        continue;
+      }
+      const val = doc[key];
+      if (condition === null || typeof condition !== "object" || condition instanceof RegExp) {
+        if (Array.isArray(val)) {
+          if (condition instanceof RegExp) {
+            if (!val.some((item) => condition.test(String(item)))) return false;
+          } else {
+            if (!val.includes(condition)) return false;
+          }
+        } else {
+          if (condition instanceof RegExp) {
+            if (!condition.test(String(val))) return false;
+          } else {
+            if (val !== condition) return false;
+          }
+        }
+        continue;
+      }
+      const ops = condition;
+      if ("$eq" in ops) {
+        const eqVal = ops["$eq"];
+        if (Array.isArray(val)) {
+          if (Array.isArray(eqVal)) {
+            if (val.length !== eqVal.length || !val.every((v, i) => v === eqVal[i])) return false;
+          } else {
+            if (!val.includes(eqVal)) return false;
+          }
+        } else {
+          if (val !== eqVal) return false;
+        }
+      }
+      if ("$ne" in ops) {
+        const neVal = ops["$ne"];
+        if (Array.isArray(val)) {
+          if (Array.isArray(neVal)) {
+            if (val.length === neVal.length && val.every((v, i) => v === neVal[i])) return false;
+          } else {
+            if (val.includes(neVal)) return false;
+          }
+        } else {
+          if (val === neVal) return false;
+        }
+      }
+      if ("$gt" in ops && !(val > ops["$gt"])) return false;
+      if ("$gte" in ops && !(val >= ops["$gte"])) return false;
+      if ("$lt" in ops && !(val < ops["$lt"])) return false;
+      if ("$lte" in ops && !(val <= ops["$lte"])) return false;
+      if ("$in" in ops) {
+        const inList = ops["$in"];
+        if (Array.isArray(val)) {
+          const hasIntersection = val.some((v) => inList.includes(v));
+          const hasExactArray = inList.some(
+            (item) => Array.isArray(item) && item.length === val.length && item.every((v, i) => v === val[i])
+          );
+          if (!hasIntersection && !hasExactArray) return false;
+        } else {
+          if (!inList.includes(val)) return false;
+        }
+      }
+      if ("$nin" in ops) {
+        const ninList = ops["$nin"];
+        if (Array.isArray(val)) {
+          const hasIntersection = val.some((v) => ninList.includes(v));
+          const hasExactArray = ninList.some(
+            (item) => Array.isArray(item) && item.length === val.length && item.every((v, i) => v === val[i])
+          );
+          if (hasIntersection || hasExactArray) return false;
+        } else {
+          if (ninList.includes(val)) return false;
+        }
+      }
+      if ("$exists" in ops) {
+        const exists = val !== void 0 && val !== null;
+        if (exists !== ops["$exists"]) return false;
+      }
+      if ("$regex" in ops) {
+        const re = ops["$regex"] instanceof RegExp ? ops["$regex"] : new RegExp(ops["$regex"]);
+        if (Array.isArray(val)) {
+          if (!val.some((item) => re.test(String(item)))) return false;
+        } else {
+          if (!re.test(String(val))) return false;
+        }
+      }
+    }
+    return true;
+  }
+  applySort(docs, sort) {
+    return [...docs].sort((a, b) => {
+      for (const [key, dir] of Object.entries(sort)) {
+        const av = a[key];
+        const bv = b[key];
+        if (av === bv) continue;
+        if (av == null) return dir;
+        if (bv == null) return -dir;
+        return av < bv ? -dir : dir;
+      }
+      return 0;
+    });
+  }
+  applyProjection(doc, projection) {
+    const result = {};
+    const isInclusive = Object.values(projection).some((v) => v === 1);
+    for (const [key, val] of Object.entries(doc)) {
+      if (isInclusive) {
+        if (projection[key] === 1 || key.startsWith("_")) result[key] = val;
+      } else {
+        if (projection[key] !== 0) result[key] = val;
+      }
+    }
+    return result;
+  }
+  hashQuery(...args) {
+    return `${this.name}:` + createHash("md5").update(JSON.stringify(args)).digest("hex");
+  }
+  getName() {
+    return this.name;
+  }
+};
+z.object({
+  email: z.string().email(),
+  passwordHash: z.string(),
+  roles: z.array(z.string()).default(["user"]),
+  metadata: z.record(z.unknown()).optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+function resolveJwtSecret(configSecret) {
+  if (configSecret) return configSecret;
+  if (process.env["JWT_SECRET"]) return process.env["JWT_SECRET"];
+  const secretFile = "./jwt_secret.txt";
+  if (existsSync(secretFile)) return readFileSync(secretFile, "utf-8").trim();
+  const ephemeral = randomBytes(32).toString("hex");
+  console.warn(
+    "[gramobase Auth] WARNING: No JWT_SECRET provided. Using an ephemeral random secret. Tokens will be invalidated on restart. Set JWT_SECRET env variable for production!"
+  );
+  return ephemeral;
+}
+function validatePasswordStrength(password) {
+  if (password.length < 8) {
+    throw new Error("[Auth] Password must be at least 8 characters long");
+  }
+}
+var GramoBaseAuth = class {
+  constructor(users, config) {
+    this.users = users;
+    this.config = config;
+    this.resolvedSecret = resolveJwtSecret(config.jwtSecret);
+  }
+  users;
+  config;
+  DEFAULT_ROUNDS = 12;
+  resolvedSecret;
+  // ─── Registration ─────────────────────────────────────────────────────
+  async register(email, password, roles = ["user"], metadata) {
+    if (!email || typeof email !== "string") {
+      throw new Error("[Auth] Invalid email");
+    }
+    validatePasswordStrength(password);
+    const existing = await this.users.findOne({ email: { $eq: email } });
+    if (existing) throw new Error("[Auth] Email already registered");
+    const passwordHash = await bcrypt.hash(
+      password,
+      this.config.bcryptRounds ?? this.DEFAULT_ROUNDS
+    );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const doc = await this.users.insertOne({
+      email,
+      passwordHash,
+      roles,
+      metadata,
+      createdAt: now,
+      updatedAt: now
+    });
+    const user = doc;
+    const session = this.createSession(user);
+    await this.config.onSignIn?.(user);
+    return { user, session };
+  }
+  // ─── Login ────────────────────────────────────────────────────────────
+  async login(email, password) {
+    const doc = await this.users.findOne({ email: { $eq: email } });
+    if (!doc) {
+      await bcrypt.compare(password, "$2a$12$invalidhashtopreventtimingattacks");
+      throw new Error("[Auth] Invalid credentials");
+    }
+    const user = doc;
+    const valid = await bcrypt.compare(password, user.passwordHash);
+    if (!valid) throw new Error("[Auth] Invalid credentials");
+    const session = this.createSession(user);
+    await this.config.onSignIn?.(user);
+    return { user, session };
+  }
+  // ─── Token verification ───────────────────────────────────────────────
+  verifyToken(token) {
+    try {
+      const payload = jwt.verify(token, this.resolvedSecret, {
+        algorithms: ["HS256"]
+      });
+      return payload;
+    } catch {
+      throw new Error("[Auth] Invalid or expired token");
+    }
+  }
+  // ─── Role-based access ────────────────────────────────────────────────
+  requireRole(session, role) {
+    if (!session.roles.includes(role) && !session.roles.includes("admin")) {
+      throw new Error(`[Auth] Requires role: ${role}`);
+    }
+  }
+  requireAnyRole(session, roles) {
+    const hasRole = roles.some(
+      (r) => session.roles.includes(r) || session.roles.includes("admin")
+    );
+    if (!hasRole) {
+      throw new Error(`[Auth] Requires one of roles: ${roles.join(", ")}`);
+    }
+  }
+  // ─── Password management ──────────────────────────────────────────────
+  async changePassword(userId, oldPassword, newPassword) {
+    const doc = await this.users.findById(userId);
+    if (!doc) throw new Error("[Auth] User not found");
+    const user = doc;
+    const valid = await bcrypt.compare(oldPassword, user.passwordHash);
+    if (!valid) throw new Error("[Auth] Old password incorrect");
+    validatePasswordStrength(newPassword);
+    const newHash = await bcrypt.hash(
+      newPassword,
+      this.config.bcryptRounds ?? this.DEFAULT_ROUNDS
+    );
+    await this.users.findByIdAndUpdate(userId, {
+      $set: { passwordHash: newHash, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+  }
+  async resetPassword(userId, newPassword) {
+    validatePasswordStrength(newPassword);
+    const newHash = await bcrypt.hash(
+      newPassword,
+      this.config.bcryptRounds ?? this.DEFAULT_ROUNDS
+    );
+    await this.users.findByIdAndUpdate(userId, {
+      $set: { passwordHash: newHash, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+  }
+  // ─── User management ─────────────────────────────────────────────────
+  async getUserById(id) {
+    const doc = await this.users.findById(id);
+    return doc ? doc : null;
+  }
+  async getUserByEmail(email) {
+    const doc = await this.users.findOne({ email: { $eq: email } });
+    return doc ? doc : null;
+  }
+  async updateRoles(userId, roles) {
+    await this.users.findByIdAndUpdate(userId, {
+      $set: { roles, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+  }
+  async deleteUser(userId) {
+    await this.users.deleteById(userId);
+    await this.config.onSignOut?.(userId);
+  }
+  // ─── Session helpers ──────────────────────────────────────────────────
+  createSession(user) {
+    const expiresIn = this.config.jwtExpiresIn ?? "7d";
+    const payload = {
+      sub: user._id,
+      userId: user._id,
+      roles: user.roles,
+      expiresAt: Date.now() + this.parseExpiry(expiresIn)
+    };
+    const token = jwt.sign(payload, this.resolvedSecret, {
+      expiresIn,
+      algorithm: "HS256"
+    });
+    return { ...payload, token };
+  }
+  parseExpiry(s) {
+    const n = parseInt(s);
+    if (s.endsWith("d")) return n * 864e5;
+    if (s.endsWith("h")) return n * 36e5;
+    if (s.endsWith("m")) return n * 6e4;
+    return n * 1e3;
+  }
+  // ─── Middleware factory (Express/Fastify compatible) ──────────────────
+  middleware() {
+    return (req, res, next) => {
+      const auth = req.headers["authorization"];
+      if (!auth?.startsWith("Bearer ")) {
+        return res.status(401).json({ error: "Missing token" });
+      }
+      try {
+        req.session = this.verifyToken(auth.slice(7));
+        next();
+      } catch {
+        res.status(401).json({ error: "Unauthorized" });
+      }
+    };
+  }
+  requireRoleMiddleware(role) {
+    return (req, res, next) => {
+      try {
+        this.requireRole(req.session, role);
+        next();
+      } catch {
+        res.status(403).json({ error: "Forbidden" });
+      }
+    };
+  }
+};
+var RealtimeManager = class extends EventEmitter {
+  constructor(pool, webhookUrl, debug = false) {
+    super();
+    this.pool = pool;
+    this.webhookUrl = webhookUrl;
+    this.debug = debug;
+  }
+  pool;
+  webhookUrl;
+  debug;
+  pollingActive = false;
+  pollingInterval = null;
+  lastUpdateId = 0;
+  async start() {
+    if (this.webhookUrl) {
+      await this.setupWebhook();
+    } else {
+      this.startPolling();
+    }
+  }
+  async stop() {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+      this.pollingInterval = null;
+    }
+    this.pollingActive = false;
+  }
+  // ─── Subscribe helpers ────────────────────────────────────────────────
+  onInsert(collection, cb) {
+    const handler = (ev) => {
+      if (ev.type === "insert" && ev.collection === collection) {
+        cb(ev.doc);
+      }
+    };
+    this.on("event", handler);
+    return () => this.off("event", handler);
+  }
+  onUpdate(collection, cb) {
+    const handler = (ev) => {
+      if (ev.type === "update" && ev.collection === collection) {
+        cb(ev.id, ev.changes, ev.doc);
+      }
+    };
+    this.on("event", handler);
+    return () => this.off("event", handler);
+  }
+  onDelete(collection, cb) {
+    const handler = (ev) => {
+      if (ev.type === "delete" && ev.collection === collection) {
+        cb(ev.id);
+      }
+    };
+    this.on("event", handler);
+    return () => this.off("event", handler);
+  }
+  onAny(cb) {
+    const handler = (ev) => cb(ev);
+    this.on("event", handler);
+    return () => this.off("event", handler);
+  }
+  // ─── SSE adapter ──────────────────────────────────────────────────────
+  // Usage: app.get('/events', db.realtime.sseHandler())
+  sseHandler(collection) {
+    return (req, res) => {
+      res.setHeader("Content-Type", "text/event-stream");
+      res.setHeader("Cache-Control", "no-cache, no-store");
+      res.setHeader("Connection", "keep-alive");
+      res.setHeader("X-Content-Type-Options", "nosniff");
+      res.flushHeaders?.();
+      const send = (ev) => {
+        if (!collection || "collection" in ev && ev.collection === collection) {
+          res.write(`data: ${JSON.stringify(ev)}
+
+`);
+        }
+      };
+      this.on("event", send);
+      const keepalive = setInterval(() => res.write(": ping\n\n"), 25e3);
+      req.on("close", () => {
+        this.off("event", send);
+        clearInterval(keepalive);
+      });
+    };
+  }
+  // ─── Internal event dispatch ──────────────────────────────────────────
+  dispatch(event) {
+    this.emit("event", event);
+    if (this.debug) {
+      console.log("[Realtime]", event.type, "collection" in event ? event.collection : "");
+    }
+  }
+  // ─── Webhook setup ────────────────────────────────────────────────────
+  async setupWebhook() {
+    const bot = this.pool.getBot();
+    await bot.setWebHook(this.webhookUrl);
+    if (this.debug) console.log("[Realtime] Webhook set");
+  }
+  // ─── Long polling fallback ────────────────────────────────────────────
+  startPolling() {
+    this.pollingActive = true;
+    const POLL_INTERVAL = 2e3;
+    this.pollingInterval = setInterval(async () => {
+      try {
+        const updates = await this.pool.execute(
+          (bot) => bot.getUpdates({ offset: this.lastUpdateId + 1, limit: 100, timeout: 0 })
+        );
+        for (const update of updates) {
+          this.lastUpdateId = Math.max(this.lastUpdateId, update.update_id);
+          this.processUpdate(update);
+        }
+      } catch {
+      }
+    }, POLL_INTERVAL);
+  }
+  processUpdate(update) {
+    const msg = update.channel_post ?? update.message;
+    if (!msg?.text?.includes('"__gramobase"')) return;
+    try {
+      const payload = JSON.parse(msg.text);
+      if (payload.__event) {
+        this.dispatch(payload.__event);
+      }
+    } catch {
+    }
+  }
+};
+
+// src/migrations/MigrationRunner.ts
+var MIGRATION_TAG = "__GRAMOBASE_MIGRATIONS__";
+var MigrationRunner = class {
+  constructor(pool, channelId, debug = false) {
+    this.pool = pool;
+    this.channelId = channelId;
+    this.debug = debug;
+  }
+  pool;
+  channelId;
+  debug;
+  historyMsgId = null;
+  async run(migrations, db) {
+    const applied = await this.loadHistory();
+    const appliedVersions = new Set(applied.map((m) => m.version));
+    const pending = migrations.filter((m) => !appliedVersions.has(m.version)).sort((a, b) => a.version - b.version);
+    if (pending.length === 0) {
+      if (this.debug) console.log("[Migrations] Nothing to run");
+      return;
+    }
+    for (const migration of pending) {
+      console.log(`[Migrations] Running: v${migration.version} \u2014 ${migration.name}`);
+      await migration.up(db);
+      applied.push({
+        version: migration.version,
+        name: migration.name,
+        appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await this.saveHistory(applied);
+      console.log(`[Migrations] \u2713 v${migration.version}`);
+    }
+  }
+  async rollback(migrations, db, steps = 1) {
+    const applied = await this.loadHistory();
+    const toRollback = applied.sort((a, b) => b.version - a.version).slice(0, steps);
+    for (const record of toRollback) {
+      const migration = migrations.find((m) => m.version === record.version);
+      if (!migration) throw new Error(`Migration v${record.version} not found`);
+      console.log(`[Migrations] Rolling back: v${record.version} \u2014 ${record.name}`);
+      await migration.down(db);
+      applied.splice(applied.indexOf(record), 1);
+      await this.saveHistory(applied);
+      console.log(`[Migrations] \u2713 Rolled back v${record.version}`);
+    }
+  }
+  async status(migrations) {
+    const applied = await this.loadHistory();
+    const appliedVersions = new Set(applied.map((m) => m.version));
+    console.log("\n  gramobase migration status\n");
+    for (const m of migrations.sort((a, b) => a.version - b.version)) {
+      const status = appliedVersions.has(m.version) ? "\u2713" : "\u25CB";
+      const appliedAt = applied.find((a) => a.version === m.version)?.appliedAt ?? "";
+      console.log(`  ${status} v${m.version}  ${m.name.padEnd(40)} ${appliedAt}`);
+    }
+    console.log();
+  }
+  async loadHistory() {
+    try {
+      const chat = await this.pool.execute((bot) => bot.getChat(this.channelId));
+      for (const msg of chat.pinned_messages ?? []) {
+        if (msg.text?.startsWith(MIGRATION_TAG)) {
+          this.historyMsgId = msg.message_id;
+          return JSON.parse(msg.text.replace(MIGRATION_TAG + "\n", ""));
+        }
+      }
+    } catch {
+    }
+    return [];
+  }
+  async saveHistory(records) {
+    const text = `${MIGRATION_TAG}
+${JSON.stringify(records)}`;
+    if (this.historyMsgId) {
+      try {
+        await this.pool.execute(
+          (bot) => bot.editMessageText(text, {
+            chat_id: this.channelId,
+            message_id: this.historyMsgId
+          })
+        );
+        return;
+      } catch {
+      }
+    }
+    const msg = await this.pool.execute(
+      (bot) => bot.sendMessage(this.channelId, text, { disable_notification: true })
+    );
+    this.historyMsgId = msg.message_id;
+  }
+};
+var GramoBase = class {
+  pool;
+  cache;
+  storage;
+  wal;
+  registry;
+  realtime;
+  migrations;
+  collections = /* @__PURE__ */ new Map();
+  initialized = false;
+  config;
+  constructor(config) {
+    this.config = config;
+    const tokens = Array.isArray(config.botToken) ? config.botToken : [config.botToken];
+    this.pool = new BotWorkerPool(tokens, config.concurrency ?? 25, config.debug ?? false);
+    this.cache = new HotCache(config.cacheMaxBytes, config.cacheTtlMs);
+    this.storage = new TelegramStorage(
+      this.pool,
+      config.channelId,
+      config.encryptionKey,
+      config.debug ?? false
+    );
+    this.wal = new WriteAheadLog(
+      this.pool,
+      config.walChannelId ?? config.channelId,
+      config.debug ?? false
+    );
+    this.registry = new Registry(
+      this.pool,
+      config.indexChannelId ?? config.channelId,
+      config.debug ?? false
+    );
+    this.realtime = new RealtimeManager(
+      this.pool,
+      config.webhookUrl,
+      config.debug ?? false
+    );
+    this.migrations = new MigrationRunner(
+      this.pool,
+      config.channelId,
+      config.debug ?? false
+    );
+    this.pool.on("worker:rotate", (idx) => {
+      this.realtime.dispatch({ type: "worker:rotate", tokenIndex: idx });
+    });
+    this.pool.on("wal:flush", (count) => {
+      this.realtime.dispatch({ type: "wal:flush", entries: count });
+    });
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────────────
+  async connect() {
+    if (this.initialized) return this;
+    await this.wal.init();
+    await this.registry.acquireWriteLease();
+    await this.realtime.start();
+    const walEntries = await this.wal.replay();
+    if (walEntries.length > 0 && this.config.debug) {
+      console.log(`[gramobase] Replaying ${walEntries.length} WAL entries`);
+    }
+    this.initialized = true;
+    if (this.config.debug) console.log("[gramobase] Connected \u2713");
+    return this;
+  }
+  async disconnect() {
+    await this.wal.flush();
+    await this.registry.releaseWriteLease();
+    await this.realtime.stop();
+    await this.pool.destroy();
+    this.initialized = false;
+  }
+  // ─── Collection factory ───────────────────────────────────────────────
+  collection(name, config) {
+    if (this.collections.has(name)) {
+      return this.collections.get(name);
+    }
+    const col = new Collection(
+      name,
+      config,
+      this.cache,
+      this.storage,
+      this.wal,
+      this.config.channelId
+    );
+    this.collections.set(name, col);
+    return col;
+  }
+  // ─── Auth factory ─────────────────────────────────────────────────────
+  createAuth(config) {
+    const UserSchema2 = z.object({
+      email: z.string().email(),
+      passwordHash: z.string(),
+      roles: z.array(z.string()).default(["user"]),
+      metadata: z.record(z.unknown()).optional(),
+      createdAt: z.string(),
+      updatedAt: z.string()
+    });
+    const users = this.collection("__gramobase_users__", { schema: UserSchema2 });
+    return new GramoBaseAuth(users, config);
+  }
+  // ─── File storage ─────────────────────────────────────────────────────
+  async uploadFile(data, options = {}) {
+    const { fileName = "file", mimeType = "application/octet-stream", metadata } = options;
+    const channelId = this.config.channelId;
+    const { fileId, msgId } = await this.storage.uploadFile(data, fileName, mimeType, channelId);
+    const url = await this.storage.getFileUrl(fileId);
+    const record = {
+      _id: randomUUID(),
+      fileId,
+      fileName,
+      mimeType,
+      sizeBytes: data.length,
+      uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...url !== void 0 ? { url } : {},
+      ...metadata !== void 0 ? { metadata } : {}
+    };
+    const files = this.collection("__gramobase_files__", {
+      schema: z.object({
+        _id: z.string(),
+        fileId: z.string(),
+        fileName: z.string(),
+        mimeType: z.string(),
+        sizeBytes: z.number(),
+        url: z.string().optional(),
+        uploadedAt: z.string(),
+        metadata: z.record(z.unknown()).optional()
+      })
+    });
+    await files.insertOne(record);
+    return record;
+  }
+  async getFileUrl(fileId) {
+    return this.storage.getFileUrl(fileId);
+  }
+  // ─── Migrations ───────────────────────────────────────────────────────
+  async migrate(migrations) {
+    await this.migrations.run(migrations, this);
+  }
+  async rollback(migrations, steps = 1) {
+    await this.migrations.rollback(migrations, this, steps);
+  }
+  async migrationStatus(migrations) {
+    await this.migrations.status(migrations);
+  }
+  // ─── State helpers ────────────────────────────────────────────────────
+  getCacheStats() {
+    return this.cache.getStats();
+  }
+  getWorkerStats() {
+    return this.pool.getStats();
+  }
+  getRegistryInstanceId() {
+    return this.registry.getInstanceId();
+  }
+  /**
+   * Warm up the cache by pre-loading all collection indexes.
+   */
+  async warmCache() {
+    for (const col of this.collections.values()) {
+      await col.ensureIndexLoaded();
+    }
+  }
+};
+function createClient(config) {
+  return new GramoBase(config);
+}
+
+export { Collection, GramoBase, GramoBaseAuth, RealtimeManager, createClient };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map