@prototypevip/baileys 0.1.2 → 0.1.3

package/lib/Store/prototype-store.js.bak-1788477006895

@@ -1,983 +0,0 @@
-import { serialize, deserialize } from "v8";
-import { proto } from "../../WAProto/index.js";
-import {
-  jidNormalizedUser,
-  isPnUser,
-  isLidUser,
-  isHostedPnUser,
-  isHostedLidUser,
-} from "../WABinary/index.js";
-import { makeOrderedDictionary } from "./make-ordered-dictionary.js";
-// نسخه نظيفه من الداله: بس clone سطحي للرساله، من غير اي شرط مخفي
-function cloneM(obj) {
-  const out = {};
-  if (!obj || typeof obj !== "object") return obj;
-  const keys = Object.keys(obj);
-  for (let i = 0; i < keys.length; i++) {
-    const k = keys[i];
-    try {
-      out[k] = obj[k];
-    } catch (e) {
-      // silent
-    }
-  }
-  return out;
-}
-import {
-  updateMessageWithReaction,
-  updateMessageWithReceipt,
-} from "../Utils/index.js";
-import { makeMutex } from "../Utils/make-mutex.js";
-let sig = false;
-
-const resolveJID = (jid, lidMapping) => {
-  if (!jid || typeof jid !== "string") return jid;
-  if (isPnUser(jid) || isHostedPnUser(jid)) {
-    return jidNormalizedUser(jid);
-  }
-  if (isLidUser(jid) || isHostedLidUser(jid)) {
-    const pn = lidMapping?.getPNForLIDSync(jid);
-    if (pn) return jidNormalizedUser(pn);
-  }
-  return jidNormalizedUser(jid);
-};
-
-const resolveJIDAsync = async (jid, lidMapping) => {
-  if (!jid || typeof jid !== "string") return jid;
-  if (isPnUser(jid) || isHostedPnUser(jid)) {
-    return jidNormalizedUser(jid);
-  }
-  if (isLidUser(jid) || isHostedLidUser(jid)) {
-    const pn =
-      lidMapping?.getPNForLIDSync(jid) || (await lidMapping?.getPNForLID(jid));
-    if (pn) return jidNormalizedUser(pn);
-  }
-  return jidNormalizedUser(jid);
-};
-
-const getMessageKey = (msg, messages = {}, lidMapping) => {
-  const id = msg.key.id;
-  const participant = msg.key.participant
-    ? resolveJID(msg.key.participant, lidMapping)
-    : msg.key.fromMe
-      ? "me"
-      : "";
-  if (
-    messages[id] &&
-    (messages[id].key.participant
-      ? resolveJID(messages[id].key.participant, lidMapping)
-      : messages[id].key.fromMe
-        ? "me"
-        : "") !== participant
-  ) {
-    return `${participant}:${id}`;
-  }
-  return id;
-};
-
-const getMessageKeyFromKey = (key, lidMapping) => {
-  const id = key.id;
-  const participant = key.participant
-    ? resolveJID(key.participant, lidMapping)
-    : key.fromMe
-      ? "me"
-      : "";
-  return participant ? `${participant}:${id}` : id;
-};
-
-const findMessageByKey = (messages, key, lidMapping) => {
-  const msgKey = getMessageKeyFromKey(key, lidMapping);
-  if (messages[msgKey]) return messages[msgKey];
-  return messages[key.id];
-};
-
-const safeDeserialize = (data) => {
-  if (!data) return null;
-  if (typeof data === "string") {
-    try {
-      return JSON.parse(data);
-    } catch {
-      return data;
-    }
-  }
-  try {
-    return deserialize(data);
-  } catch {
-    try {
-      return JSON.parse(data.toString());
-    } catch {
-      return data;
-    }
-  }
-};
-
-/**
- * Creates a Prototype Store instance.
- */
-export const makePrototypeStore = (config = {}) => {
-  const {
-    db: Database,
-    file,
-    retentionDays = 2,
-    maxMessagesPerChat = 50000,
-  } = config;
-  const db = Database && file ? new Database(file) : null;
-  const dbMutex = makeMutex();
-
-  if (db) {
-    db.exec(`
-      CREATE TABLE IF NOT EXISTS messages (
-        id TEXT,
-        remoteJid TEXT,
-        fromMe INTEGER,
-        participant TEXT,
-        data BLOB,
-        timestamp INTEGER,
-        PRIMARY KEY (id, remoteJid, fromMe)
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages (timestamp);
-      CREATE INDEX IF NOT EXISTS idx_messages_jid ON messages (remoteJid);
-
-      CREATE TABLE IF NOT EXISTS contacts (
-        jid TEXT PRIMARY KEY,
-        data BLOB
-      );
-
-      CREATE TABLE IF NOT EXISTS receipts (
-        id TEXT,
-        remoteJid TEXT,
-        fromMe INTEGER,
-        data BLOB,
-        PRIMARY KEY (id, remoteJid, fromMe)
-      );
-    `);
-    const tableInfo = db.prepare("PRAGMA table_info(messages)").all();
-    if (!tableInfo.some((col) => col.name === "timestamp")) {
-      try {
-        db.exec("ALTER TABLE messages ADD COLUMN timestamp INTEGER");
-        db.exec(
-          "CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages (timestamp)",
-        );
-      } catch {
-        console.error("PrototypeStore Timestamp Migration Error");
-      }
-    }
-    if (!tableInfo.some((col) => col.name === "participant")) {
-      try {
-        db.exec("ALTER TABLE messages ADD COLUMN participant TEXT");
-      } catch {
-        console.error("PrototypeStore Participant Migration Error");
-      }
-    }
-  }
-  const pendingUpdates = new Map();
-  const stmts = {};
-  if (db) {
-    stmts.insertMsg = db.prepare(
-      "INSERT OR REPLACE INTO messages (id, remoteJid, fromMe, participant, data, timestamp) VALUES (?, ?, ?, ?, ?, ?)",
-    );
-    stmts.insertContact = db.prepare(
-      "INSERT OR REPLACE INTO contacts (jid, data) VALUES (?, ?)",
-    );
-    stmts.insertReceipt = db.prepare(
-      "INSERT OR REPLACE INTO receipts (id, remoteJid, fromMe, data) VALUES (?, ?, ?, ?)",
-    );
-    stmts.deleteMessages = db.prepare(
-      "DELETE FROM messages WHERE remoteJid = ?",
-    );
-    stmts.deleteOneMsg = db.prepare(
-      "DELETE FROM messages WHERE id = ? AND remoteJid = ? AND fromMe = ?",
-    );
-    stmts.deleteOldMessagesByTime = db.prepare(
-      "DELETE FROM messages WHERE timestamp < ?",
-    );
-    stmts.getDistinctJids = db.prepare(
-      "SELECT DISTINCT remoteJid FROM messages",
-    );
-    stmts.limitMessagesPerChat = db.prepare(
-      `DELETE FROM messages WHERE remoteJid = ? AND id NOT IN (SELECT id FROM messages WHERE remoteJid = ? ORDER BY timestamp DESC LIMIT ?)`,
-    );
-  }
-
-  const _flush = () => {
-    if (!db || pendingUpdates.size === 0) return;
-
-    const updates = Array.from(pendingUpdates.values());
-
-    try {
-      db.transaction(() => {
-        for (const update of updates) {
-          try {
-            switch (update.type) {
-              case "delete":
-                if (update.table === "messages") {
-                  if (update.id) {
-                    stmts.deleteMessages.run(update.id);
-                  } else if (update.key) {
-                    stmts.deleteOneMsg.run(
-                      update.key.id,
-                      update.key.remoteJid,
-                      update.key.fromMe ? 1 : 0,
-                    );
-                  }
-                }
-                break;
-              case "message": {
-                const m = update.data;
-                const timestamp = m.messageTimestamp
-                  ? typeof m.messageTimestamp === "number"
-                    ? m.messageTimestamp
-                    : m.messageTimestamp.toNumber?.() || m.messageTimestamp
-                  : Math.floor(Date.now() / 1000);
-                stmts.insertMsg.run(
-                  m.key.id || "",
-                  m.key.remoteJid || "",
-                  m.key.fromMe ? 1 : 0,
-                  m.key.participant || "",
-                  serialize(m),
-                  timestamp || 0,
-                );
-                break;
-              }
-              case "contact": {
-                stmts.insertContact.run(update.data.id, serialize(update.data));
-                break;
-              }
-              case "receipt": {
-                const r = update.data;
-                stmts.insertReceipt.run(
-                  r.key.id,
-                  r.key.remoteJid,
-                  r.key.fromMe ? 1 : 0,
-                  serialize(r.receipt),
-                );
-                break;
-              }
-            }
-          } catch (err) {
-            const code = err?.code || err?.message || "";
-            if (String(code).includes("READONLY") || String(code).includes("SQLITE_READONLY")) {
-              console.error("PrototypeStore Transaction Step Error (readonly DB - check file path/permissions/volume):", err.message || err);
-            } else {
-              console.error("PrototypeStore Transaction Step Error:", err);
-            }
-          }
-        }
-      })();
-      pendingUpdates.clear();
-    } catch (e) {
-      console.error("PrototypeStore Flush Error:", e);
-    }
-  };
-
-  const flush = async () => {
-    return await dbMutex.mutex(async () => _flush());
-  };
-
-  const _clean = () => {
-    if (!db) return;
-    try {
-      const cutoff =
-        Math.floor(Date.now() / 1000) - retentionDays * 24 * 60 * 60;
-      stmts.deleteOldMessagesByTime.run(cutoff);
-
-      const chats = stmts.getDistinctJids.all();
-      for (const chat of chats) {
-        stmts.limitMessagesPerChat.run(
-          chat.remoteJid,
-          chat.remoteJid,
-          maxMessagesPerChat,
-        );
-      }
-
-      db.exec("VACUUM");
-      Object.keys(chatsCache).forEach((k) => delete chatsCache[k]);
-      Object.keys(contactsCache).forEach((k) => delete contactsCache[k]);
-      Object.keys(groupsCache).forEach((k) => delete groupsCache[k]);
-      Object.keys(presencesCache).forEach((k) => delete presencesCache[k]);
-    } catch {
-      console.error("PrototypeStore Clean Error");
-    }
-  };
-
-  const clean = async () => {
-    return await dbMutex.mutex(async () => _clean());
-  };
-
-  let flushInterval;
-  let cleanInterval;
-  let handleExit;
-  if (db) {
-    flushInterval = setInterval(flush, 5000);
-    cleanInterval = setInterval(clean, 12 * 60 * 60 * 1000);
-    handleExit = () => {
-      _flush();
-      try {
-        db.close();
-      } catch {
-        // Ignore close errors
-      }
-    };
-    if (!sig) {
-      sig = true;
-      process.once("SIGINT", handleExit);
-      process.once("SIGTERM", handleExit);
-    }
-  }
-
-  const chatsCache = {};
-  const contactsCache = {};
-  const groupsCache = {};
-
-  const contactsUpsert = async (newContacts) => {
-    if (!Array.isArray(newContacts)) return;
-    for (const contact of newContacts) {
-      const id = await resolveJIDAsync(
-        contact.id,
-        store.signalRepository?.lidMapping,
-      );
-      if (!id || id === "status@broadcast") continue;
-
-      const current = contactsCache[id] || {};
-      contactsCache[id] = {
-        ...current,
-        ...contact,
-        id,
-        name:
-          contact.notify ||
-          contact.name ||
-          current.name ||
-          current.notify ||
-          "",
-      };
-    }
-  };
-
-  const presencesCache = {};
-
-
-  const safeAssignChat = (existing, incoming) => {
-    if (!existing || !incoming) return existing;
-    const savedMessages = existing.messages;
-    Object.assign(existing, incoming, { isChats: true });
-    // Never let chat events wipe the ordered messages store
-    if (
-      !existing.messages ||
-      typeof existing.messages.upsert !== "function"
-    ) {
-      existing.messages = savedMessages || makeMessagesStore();
-    }
-    if (!existing.id) existing.id = incoming.id || existing.id;
-    return existing;
-  };
-
-  const makeMessagesStore = () =>
-    new Proxy(
-      makeOrderedDictionary((m) => {
-        const participant = m.key.participant
-          ? resolveJID(m.key.participant, store.signalRepository?.lidMapping)
-          : m.key.fromMe
-            ? "me"
-            : "";
-        return participant ? `${participant}:${m.key.id}` : m.key.id;
-      }),
-      {
-        get(target, prop) {
-          if (prop in target) return target[prop];
-          return target.get(prop);
-        },
-        set(target, prop, value) {
-          target.upsert(value);
-          return true;
-        },
-        deleteProperty(target, prop) {
-          const item = target.get(prop);
-          if (item) return target.remove(item);
-          return false;
-        },
-      },
-    );
-
-  const store = {
-    signalRepository: config.signalRepository,
-    chats: new Proxy(chatsCache, {
-      get(target, chatId) {
-        if (typeof chatId !== "string") return target[chatId];
-        const jid = resolveJID(chatId, store.signalRepository?.lidMapping);
-        if (!target[jid]) {
-          target[jid] = {
-            id: jid,
-            messages: makeMessagesStore(),
-            get isGroup() {
-              return jid.endsWith("@g.us");
-            },
-          };
-        } else if (
-          !target[jid].messages ||
-          typeof target[jid].messages.upsert !== "function"
-        ) {
-          // Recover if messages was overwritten by Object.assign / chat updates
-          target[jid].messages = makeMessagesStore();
-        }
-        return target[jid];
-      },
-      set(target, chatId, value) {
-        const jid = resolveJID(chatId, store.signalRepository?.lidMapping);
-        target[jid] = value;
-        return true;
-      },
-    }),
-
-    contacts: new Proxy(contactsCache, {
-      get(target, jid) {
-        if (typeof jid !== "string") return target[jid];
-        const normalizedJid = resolveJID(
-          jid,
-          store.signalRepository?.lidMapping,
-        );
-        if (target[normalizedJid]) return target[normalizedJid];
-        if (db) {
-          const row = db
-            .prepare("SELECT data FROM contacts WHERE jid = ?")
-            .get(normalizedJid);
-          if (row) {
-            const contact = safeDeserialize(row.data);
-            target[normalizedJid] = contact;
-            return contact;
-          }
-        }
-        return undefined;
-      },
-    }),
-
-    groups: new Proxy(groupsCache, {
-      get(target, jid) {
-        if (typeof jid !== "string") return target[jid];
-        return target[jid];
-      },
-    }),
-
-    presences: new Proxy(presencesCache, {
-      get(target, jid) {
-        if (typeof jid !== "string") return target[jid];
-        const normalizedJid = resolveJID(
-          jid,
-          store.signalRepository?.lidMapping,
-        );
-        if (!target[normalizedJid]) {
-          target[normalizedJid] = {};
-        }
-        return target[normalizedJid];
-      },
-    }),
-
-    state: { connection: "close" },
-    me: null,
-
-    clean,
-    flush,
-
-    dispose() {
-      if (flushInterval) clearInterval(flushInterval);
-      if (cleanInterval) clearInterval(cleanInterval);
-      if (handleExit) {
-        process.removeListener("SIGINT", handleExit);
-        process.removeListener("SIGTERM", handleExit);
-      }
-      if (this._ev && this._listeners) {
-        for (const evName in this._listeners) {
-          this._ev.off(evName, this._listeners[evName]);
-        }
-      }
-      this._listeners = {};
-    },
-
-    loadMessage(key) {
-      const id = typeof key === "string" ? key : key.id;
-      const remoteJid = key?.remoteJid;
-      const chatId = remoteJid
-        ? resolveJID(remoteJid, store.signalRepository?.lidMapping)
-        : null;
-
-      if (chatId) {
-        const msgKey = getMessageKeyFromKey(
-          key,
-          store.signalRepository?.lidMapping,
-        );
-        const msg = store.chats[chatId].messages.get(msgKey);
-        if (msg) return msg;
-
-        // Fallback search in memory
-        const msgInMemory = Array.from(
-          store.chats[chatId].messages.iterator(),
-        ).find((m) => m.key?.id === id);
-        if (msgInMemory) return msgInMemory;
-      }
-
-      // Global search fallback in memory
-      for (const cId in chatsCache) {
-        const chat = chatsCache[cId];
-        if (!chat.messages) continue;
-        const msg = Array.from(chat.messages.iterator()).find(
-          (m) => m.key?.id === id,
-        );
-        if (msg) return msg;
-      }
-
-      if (db) {
-        let query = "SELECT data FROM messages WHERE id = ?";
-        let params = [id];
-        if (chatId) {
-          query += " AND remoteJid = ?";
-          params.push(chatId);
-        }
-        const row = db.prepare(query).get(...params);
-        if (row) {
-          const msg = safeDeserialize(row.data);
-          const cId = resolveJID(
-            msg.key.remoteJid,
-            store.signalRepository?.lidMapping,
-          );
-
-          store.chats[cId].messages.upsert(msg);
-          return msg;
-        }
-      }
-      return undefined;
-    },
-
-    bind(ev) {
-      if (this._ev && this._listeners) {
-        for (const evName in this._listeners) {
-          this._ev.off(evName, this._listeners[evName]);
-        }
-      }
-      this._ev = ev;
-      this._listeners = {};
-
-      const listen = (name, fn) => {
-        this._listeners[name] = fn;
-        ev.on(name, fn);
-      };
-
-      const upsertContacts = async (contacts) => {
-        await contactsUpsert(contacts);
-        for (const contact of contacts) {
-          const id = await resolveJIDAsync(
-            contact.id,
-            store.signalRepository?.lidMapping,
-          );
-          if (!id || id === "status@broadcast") continue;
-
-          if (db)
-            pendingUpdates.set(`c:${id}`, {
-              type: "contact",
-              data: contactsCache[id],
-            });
-
-          // Ensure chat names are in sync
-          const chat = store.chats[id];
-          if (id.endsWith("@g.us")) {
-            chat.subject =
-              contactsCache[id].subject ||
-              contactsCache[id].name ||
-              chat.subject ||
-              "";
-          } else {
-            chat.name = contactsCache[id].name || chat.name || "";
-          }
-        }
-      };
-
-      // Order of registration for clean handling
-      listen("contacts.upsert", upsertContacts);
-      listen("contacts.set", ({ contacts }) => upsertContacts(contacts));
-      listen("contacts.update", upsertContacts);
-
-      listen("chats.upsert", async (chats) => {
-        for (const chat of chats) {
-          const id = await resolveJIDAsync(
-            chat.id,
-            store.signalRepository?.lidMapping,
-          );
-          if (!id || id === "status@broadcast") continue;
-
-          const existingChat = store.chats[id];
-          safeAssignChat(existingChat, chat);
-
-          if (id.endsWith("@g.us")) {
-            const current = groupsCache[id] || {};
-            const updated = {
-              ...current,
-              ...chat,
-              subject: chat.name || chat.subject || current.subject || "",
-            };
-            groupsCache[id] = updated;
-          } else {
-            const current = contactsCache[id] || {};
-            const updated = {
-              ...current,
-              ...chat,
-              name: chat.name || current.name || "",
-            };
-            contactsCache[id] = updated;
-            if (db)
-              pendingUpdates.set(`c:${id}`, {
-                type: "contact",
-                data: updated,
-              });
-          }
-        }
-      });
-
-      listen("message-receipt.update", async (updates) => {
-        for (const { key, receipt } of updates) {
-          if (!key || !receipt) continue;
-          const chatId = await resolveJIDAsync(
-            key.remoteJid,
-            store.signalRepository?.lidMapping,
-          );
-          const msg = findMessageByKey(
-            store.chats[chatId].messages,
-            key,
-            store.signalRepository?.lidMapping,
-          );
-          if (msg) {
-            updateMessageWithReceipt(msg, receipt);
-            if (db) {
-              const msgKey = getMessageKey(
-                msg,
-                store.chats[chatId].messages,
-                store.signalRepository?.lidMapping,
-              );
-              pendingUpdates.set(`m:${chatId}:${msgKey}`, {
-                type: "message",
-                data: msg,
-              });
-            }
-          }
-        }
-      });
-
-      listen("presence.update", async ({ id, presences: update }) => {
-        const jid = await resolveJIDAsync(
-          id,
-          store.signalRepository?.lidMapping,
-        );
-        Object.assign(store.presences[jid], update);
-      });
-
-      listen("connection.update", (update) => {
-        Object.assign(this.state, update);
-        if (update.me) {
-          this.me = resolveJID(
-            update.me.id,
-            store.signalRepository?.lidMapping,
-          );
-        }
-      });
-
-      listen("chats.delete", async (jids) => {
-        for (const id of jids) {
-          const jid = await resolveJIDAsync(
-            id,
-            store.signalRepository?.lidMapping,
-          );
-          delete chatsCache[jid];
-          delete groupsCache[jid];
-          if (db) {
-            pendingUpdates.set(`del:m:${jid}`, {
-              type: "delete",
-              id: jid,
-              table: "messages",
-            });
-          }
-        }
-      });
-
-      listen(
-        "messaging-history.set",
-        async ({ messages, contacts: newContacts, chats: newChats }) => {
-          await upsertContacts(newContacts);
-
-          for (const msg of messages) {
-            const chatId = await resolveJIDAsync(
-              msg.key.remoteJid,
-              store.signalRepository?.lidMapping,
-            );
-            if (!chatId) continue;
-
-            store.chats[chatId].messages.upsert(msg);
-
-            if (db) {
-              const msgKey = getMessageKey(
-                msg,
-                {}, // passing empty since we know messages are upserted now
-                store.signalRepository?.lidMapping,
-              );
-              pendingUpdates.set(`m:${chatId}:${msgKey}`, {
-                type: "message",
-                data: msg,
-              });
-            }
-          }
-
-          for (const chat of newChats) {
-            const id = await resolveJIDAsync(
-              chat.id,
-              store.signalRepository?.lidMapping,
-            );
-            const existingChat = store.chats[id];
-            safeAssignChat(existingChat, chat);
-          }
-        },
-      );
-
-      listen("messages.upsert", async ({ messages }) => {
-        for (let msg of messages) {
-          const rawChatId = msg?.key?.remoteJid;
-          if (!rawChatId) continue;
-          const chatId = await resolveJIDAsync(
-            rawChatId,
-            store.signalRepository?.lidMapping,
-          );
-          if (!chatId) continue;
-          const chat = store.chats[chatId];
-          if (!chat) continue;
-          if (!chat.messages || typeof chat.messages.upsert !== "function") {
-            chat.messages = makeMessagesStore();
-          }
-          chat.messages.upsert(cloneM(msg));
-
-          if (db) {
-            const msgKey = getMessageKey(
-              msg,
-              {},
-              store.signalRepository?.lidMapping,
-            );
-            pendingUpdates.set(`m:${chatId}:${msgKey}`, {
-              type: "message",
-              data: cloneM(msg),
-            });
-          }
-        }
-      });
-
-      listen("messages.update", async (updates) => {
-        for (const { key, update } of updates) {
-          if (!key || !update) continue;
-          const msg = this.loadMessage(key);
-          if (msg) {
-            Object.assign(msg, update);
-            if (db) {
-              const chatId = await resolveJIDAsync(
-                msg.key.remoteJid,
-                store.signalRepository?.lidMapping,
-              );
-              const msgKey = getMessageKey(
-                msg,
-                store.chats[chatId].messages,
-                store.signalRepository?.lidMapping,
-              );
-              pendingUpdates.set(`m:${chatId}:${msgKey}`, {
-                type: "message",
-                data: msg,
-              });
-            }
-          }
-        }
-      });
-
-      listen("messages.delete", async (item) => {
-        if ("all" in item) {
-          const jid = await resolveJIDAsync(
-            item.jid,
-            store.signalRepository?.lidMapping,
-          );
-          if (chatsCache[jid]) {
-            chatsCache[jid].messages = makeMessagesStore();
-            if (db)
-              pendingUpdates.set(`del:m:${jid}`, {
-                type: "delete",
-                id: jid,
-                table: "messages",
-              });
-          }
-        } else {
-          for (const key of item.keys) {
-            const chatId = await resolveJIDAsync(
-              key.remoteJid,
-              store.signalRepository?.lidMapping,
-            );
-            if (!chatId) continue;
-
-            const msg = findMessageByKey(
-              {}, // Dummy object as we use loadMessage/get
-              key,
-              store.signalRepository?.lidMapping,
-            );
-
-            // We need to fetch the actual object to remove
-            const actualMsg = store.loadMessage(key);
-            if (actualMsg) {
-              store.chats[chatId].messages.remove(actualMsg);
-            }
-
-            if (db) {
-              pendingUpdates.set(
-                `del:m:${chatId}:${key.id}:${key.fromMe ? 1 : 0}`,
-                {
-                  type: "delete",
-                  key,
-                  table: "messages",
-                },
-              );
-            }
-          }
-        }
-      });
-
-      listen("messages.reaction", async (updates) => {
-        for (const item of updates) {
-          const { key } = item;
-          const reactions =
-            item.reactions || (item.reaction ? [item.reaction] : []);
-
-          if (!key || reactions.length === 0) continue;
-
-          for (const reaction of reactions) {
-            const chatId = await resolveJIDAsync(
-              key?.remoteJid,
-              store.signalRepository?.lidMapping,
-            );
-            if (!chatId || !key.id || !reaction.key) continue;
-
-            const msg = this.loadMessage(key);
-            if (msg) {
-              updateMessageWithReaction(msg, reaction, this.me);
-              if (db) {
-                const msgKey = getMessageKey(
-                  msg,
-                  store.chats[chatId].messages,
-                  store.signalRepository?.lidMapping,
-                );
-                pendingUpdates.set(`m:${chatId}:${msgKey}`, {
-                  type: "message",
-                  data: msg,
-                });
-              }
-            }
-          }
-        }
-      });
-
-      listen("groups.update", async (updates) => {
-        for (const update of updates) {
-          if (!update?.id) continue;
-          const id = await resolveJIDAsync(
-            update.id,
-            store.signalRepository?.lidMapping,
-          );
-          if (groupsCache[id]) {
-            Object.assign(groupsCache[id], update);
-          }
-        }
-      });
-
-      listen(
-        "group-participants.update",
-        async ({ id, participants, action }) => {
-          const gid = await resolveJIDAsync(
-            id,
-            store.signalRepository?.lidMapping,
-          );
-          const metadata = groupsCache[gid];
-          if (metadata) {
-            const mappedParticipants = await Promise.all(
-              participants.map(async (p) => ({
-                id: p.phoneNumber,
-                lid: p.id,
-                jid: await resolveJIDAsync(
-                  p.phoneNumber || p.id,
-                  store.signalRepository?.lidMapping,
-                ),
-                admin: p.admin,
-              })),
-            );
-
-            switch (action) {
-              case "add":
-                metadata.participants.push(...mappedParticipants);
-                break;
-              case "demote":
-              case "promote":
-                for (const participant of metadata.participants) {
-                  for (const participantData of mappedParticipants) {
-                    if (
-                      participantData.id === participant.id ||
-                      participantData.lid === participant.lid ||
-                      participantData.jid === participant.jid
-                    ) {
-                      participant.admin =
-                        action === "promote" &&
-                        (participantData.admin || "admin");
-                    }
-                  }
-                }
-                break;
-              case "remove": {
-                const removeSet = new Set();
-                for (const p of mappedParticipants) {
-                  if (p.id) removeSet.add(p.id);
-                  if (p.lid) removeSet.add(p.lid);
-                  if (p.jid) removeSet.add(p.jid);
-
-                  // If me is removed, delete group from cache
-                  if (
-                    this.me &&
-                    (this.me === p.id || this.me === p.lid || this.me === p.jid)
-                  ) {
-                    delete groupsCache[gid];
-                  }
-                }
-                metadata.participants = metadata.participants.reduce(
-                  (acc, p) => {
-                    if (
-                      !removeSet.has(p.id) &&
-                      !removeSet.has(p.jid) &&
-                      !removeSet.has(p.lid)
-                    )
-                      acc.push(p);
-                    return acc;
-                  },
-                  [],
-                );
-                break;
-              }
-            }
-          }
-        },
-      );
-    },
-  };
-
-  store.close = () => {
-    if (flushInterval) clearInterval(flushInterval);
-    if (cleanInterval) clearInterval(cleanInterval);
-    try {
-      _flush();
-    } catch {
-      // ignore flush errors on close
-    }
-    if (db) {
-      try {
-        db.close();
-      } catch {
-        // ignore close errors
-      }
-    }
-  };
-
-  return store;
-};