@whanext/core 0.17.1 → 0.18.1

package/dist/index.js

@@ -2297,96 +2297,36 @@ var Browser = /* @__PURE__ */ ((Browser2) => {
   return Browser2;
 })(Browser || {});
 
-// src/provider/baileys/baileys-provider.ts
+// src/provider/zapo/zapo-provider.ts
+import { mkdir } from "fs/promises";
+import { join } from "path";
+import { createMediaProcessor } from "@zapo-js/media-utils";
+import { createSqliteStore } from "@zapo-js/store-sqlite";
 import {
-  Browsers,
-  DisconnectReason,
-  downloadMediaMessage,
-  generateWAMessageFromContent,
-  isJidGroup,
-  makeWASocket,
-  proto as proto2,
-  useMultiFileAuthState
-} from "@whiskeysockets/baileys";
-
-// src/provider/baileys/baileys-logger.ts
-function createBaileysLogger(logger) {
-  return {
-    level: logger.level,
-    child(context) {
-      const name = typeof context.class === "string" ? context.class : "internal";
-      return createBaileysLogger(logger.child(name));
-    },
-    trace(value, message) {
-      logger.debug(resolveMessage(value, message, "Provider trace"), safeContext(value));
-    },
-    debug(value, message) {
-      logger.debug(resolveMessage(value, message, "Provider debug"), safeContext(value));
-    },
-    info(value, message) {
-      logger.debug(resolveMessage(value, message, "Provider info"), safeContext(value));
-    },
-    warn(value, message) {
-      logger.warn(resolveMessage(value, message, "Provider warning"), safeContext(value));
-    },
-    error(value, message) {
-      logger.error(resolveMessage(value, message, "Provider error"), safeContext(value));
-    }
-  };
-}
-function resolveMessage(value, message, fallback) {
-  if (message) {
-    return message;
-  }
-  return typeof value === "string" ? value : fallback;
-}
-function safeContext(value) {
-  if (value instanceof Error) {
-    return { error: value };
-  }
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return {};
-  }
-  const source = value;
-  const allowed = [
-    "location",
-    "reason",
-    "status",
-    "statusCode",
-    "type"
-  ];
-  return Object.fromEntries(
-    allowed.filter((key) => source[key] !== void 0).map((key) => [key, source[key]])
-  );
-}
+  WaClient,
+  createStore,
+  proto
+} from "zapo-js";
 
-// src/provider/baileys/normalize-message.ts
-import {
-  extractMessageContent,
-  getContentType,
-  normalizeMessageContent
-} from "@whiskeysockets/baileys";
-function unwrapMessageContent(input) {
+// src/provider/zapo/normalize-message.ts
+function unwrapZapoMessageContent(input) {
   if (!input) return void 0;
-  const normalized = normalizeMessageContent(input);
-  const content = extractMessageContent(normalized);
-  if (!content) return void 0;
-  const nested = content.ephemeralMessage?.message ?? content.viewOnceMessage?.message ?? content.viewOnceMessageV2?.message ?? content.viewOnceMessageV2Extension?.message;
-  return nested ? unwrapMessageContent(nested) : content;
+  const nested = input.ephemeralMessage?.message ?? input.viewOnceMessage?.message ?? input.viewOnceMessageV2?.message ?? input.deviceSentMessage?.message ?? input.documentWithCaptionMessage?.message;
+  return nested ? unwrapZapoMessageContent(nested) : input;
 }
-function isViewOnceContent(input) {
+function isZapoViewOnceContent(input) {
   if (!input) return false;
-  if (input.viewOnceMessage?.message || input.viewOnceMessageV2?.message || input.viewOnceMessageV2Extension?.message) {
+  if (input.viewOnceMessage?.message || input.viewOnceMessageV2?.message) {
     return true;
   }
-  return isViewOnceContent(input.ephemeralMessage?.message);
+  return isZapoViewOnceContent(input.ephemeralMessage?.message);
 }
-function extractQuotedBaileysMessage(input) {
-  const chatId = input.key.remoteJid;
-  const content = unwrapMessageContent(input.message);
+function extractQuotedZapoMessage(input) {
+  const event = input;
+  const chatId = event.key.remoteJid;
+  const content = unwrapZapoMessageContent(event.message);
   if (!chatId || !content) return void 0;
-  const type = getContentType(content);
-  const node = type ? content[type] : void 0;
+  const node = contentNode(content);
   const context = getContextInfo(node);
   if (!context?.stanzaId || !context.quotedMessage) return void 0;
   return {
@@ -2399,26 +2339,25 @@ function extractQuotedBaileysMessage(input) {
     message: context.quotedMessage
   };
 }
-function normalizeBaileysMessage(input) {
-  const chatId = input.key.remoteJid;
-  const id = input.key.id;
-  if (!chatId || !id || !input.message) {
+function normalizeZapoMessage(input) {
+  const event = input;
+  const chatId = event.key.remoteJid;
+  const id = event.key.id;
+  if (!chatId || !id || !event.message) {
     return void 0;
   }
-  const content = unwrapMessageContent(input.message);
+  const content = unwrapZapoMessageContent(event.message);
   if (!content) {
     return void 0;
   }
-  const type = getContentType(content);
-  const node = type ? content[type] : void 0;
+  const { type, node } = contentNode(content);
   const context = getContextInfo(node);
-  const isPrivateIncoming = !chatId.endsWith("@g.us") && input.key.fromMe !== true;
-  const remoteJidAlt = input.key.remoteJidAlt;
+  const isPrivateIncoming = !chatId.endsWith("@g.us") && event.key.fromMe !== true;
   const senderIds = uniqueIdentities([
-    input.key.participant,
-    input.key.participantAlt,
-    input.key.participantUsername?.includes("@") ? input.key.participantUsername : void 0,
-    isPrivateIncoming ? remoteJidAlt : void 0,
+    event.key.participant,
+    event.key.participantAlt,
+    event.key.senderUsername?.includes("@") ? event.key.senderUsername : void 0,
+    isPrivateIncoming ? event.key.remoteJidAlt : void 0,
     isPrivateIncoming ? chatId : void 0
   ]);
   const senderJid = senderIds.find((identity) => identity.endsWith("@s.whatsapp.net") || identity.endsWith("@c.us"));
@@ -2427,10 +2366,11 @@ function normalizeBaileysMessage(input) {
   const sender = new User({
     id: senderId,
     identities: senderIds.length > 0 ? senderIds : [senderId],
-    ...input.pushName ? { name: input.pushName } : {}
+    ...event.pushName ? { name: event.pushName } : {}
   });
-  const mentionedUsers = (context?.mentionedJid ?? []).map((identity) => User.fromIdentities([identity]));
-  const viewOnce = Boolean(input.key.isViewOnce) || isViewOnceContent(input.message);
+  const mentionedIds = [...context?.mentionedJid ?? []];
+  const mentionedUsers = mentionedIds.map((identity) => User.fromIdentities([identity]));
+  const viewOnce = isZapoViewOnceContent(event.message);
   const media = getMedia(type, node, viewOnce);
   const contentKind = getContentKind(type);
   const text = getText(content);
@@ -2443,10 +2383,10 @@ function normalizeBaileysMessage(input) {
     senderId,
     senderIds: senderIds.length > 0 ? senderIds : [senderId],
     sender,
-    keys: normalizeKey(input.key),
-    mentions: [...context?.mentionedJid ?? []],
+    keys: normalizeZapoKey(event.key),
+    mentions: mentionedIds,
     mentionedUsers,
-    timestamp: toDate(input.messageTimestamp),
+    timestamp: toDate(event.timestampSeconds),
     isGroup: chatId.endsWith("@g.us"),
     isReply: quoted !== void 0,
     isViewOnce: media?.viewOnce ?? false,
@@ -2464,6 +2404,45 @@ function normalizeBaileysMessage(input) {
   if (quoted !== void 0) message.quoted = quoted;
   return message;
 }
+function normalizeZapoKey(key) {
+  const normalized = {
+    id: key.id ?? "",
+    chatId: key.remoteJid ?? "",
+    fromMe: key.fromMe ?? false
+  };
+  const participantId = key.participant ?? key.participantAlt;
+  if (participantId !== null && participantId !== void 0) {
+    normalized.participantId = participantId;
+  }
+  return normalized;
+}
+function contentNode(content) {
+  const order = [
+    "conversation",
+    "extendedTextMessage",
+    "imageMessage",
+    "videoMessage",
+    "audioMessage",
+    "documentMessage",
+    "stickerMessage",
+    "locationMessage",
+    "liveLocationMessage",
+    "contactMessage",
+    "contactsArrayMessage",
+    "buttonsResponseMessage",
+    "listResponseMessage",
+    "templateButtonReplyMessage",
+    "pollCreationMessage",
+    "pollCreationMessageV2",
+    "pollCreationMessageV3",
+    "pollCreationMessageV5",
+    "productMessage",
+    "orderMessage",
+    "interactiveResponseMessage"
+  ];
+  const type = order.find((key) => content[key] !== null && content[key] !== void 0);
+  return { type, node: type ? content[type] : void 0 };
+}
 function getContentKind(type) {
   switch (String(type ?? "")) {
     case "conversation":
@@ -2471,6 +2450,7 @@ function getContentKind(type) {
     case "buttonsResponseMessage":
     case "listResponseMessage":
     case "templateButtonReplyMessage":
+    case "interactiveResponseMessage":
       return "text";
     case "imageMessage":
       return "image";
@@ -2479,7 +2459,6 @@ function getContentKind(type) {
     case "audioMessage":
       return "audio";
     case "documentMessage":
-    case "documentWithCaptionMessage":
       return "document";
     case "stickerMessage":
       return "sticker";
@@ -2492,6 +2471,7 @@ function getContentKind(type) {
     case "pollCreationMessage":
     case "pollCreationMessageV2":
     case "pollCreationMessageV3":
+    case "pollCreationMessageV5":
       return "poll";
     case "productMessage":
     case "orderMessage":
@@ -2500,20 +2480,8 @@ function getContentKind(type) {
       return "unknown";
   }
 }
-function normalizeKey(key) {
-  const normalized = {
-    id: key.id ?? "",
-    chatId: key.remoteJid ?? "",
-    fromMe: key.fromMe ?? false
-  };
-  const participantId = key.participant ?? key.participantAlt;
-  if (participantId !== null && participantId !== void 0) {
-    normalized.participantId = participantId;
-  }
-  return normalized;
-}
 function getText(content) {
-  return content.conversation ?? content.extendedTextMessage?.text ?? content.buttonsResponseMessage?.selectedDisplayText ?? content.listResponseMessage?.title ?? void 0;
+  return content.conversation ?? content.extendedTextMessage?.text ?? content.buttonsResponseMessage?.selectedDisplayText ?? content.listResponseMessage?.title ?? content.templateButtonReplyMessage?.selectedDisplayText ?? void 0;
 }
 function getCaption(content) {
   return content.imageMessage?.caption ?? content.videoMessage?.caption ?? content.documentMessage?.caption ?? void 0;
@@ -2522,9 +2490,9 @@ function getContextInfo(node) {
   if (typeof node !== "object" || node === null || !("contextInfo" in node)) {
     return void 0;
   }
-  return node.contextInfo;
+  return node.contextInfo ?? void 0;
 }
-function getMedia(type, node, keyViewOnce) {
+function getMedia(type, node, wrapperViewOnce) {
   const mapping = {
     imageMessage: "image",
     videoMessage: "video",
@@ -2539,307 +2507,112 @@ function getMedia(type, node, keyViewOnce) {
   const value = node;
   const media = {
     kind,
-    viewOnce: keyViewOnce || value.viewOnce === true
+    viewOnce: wrapperViewOnce || value.viewOnce === true
   };
   if (value.mimetype) media.mimetype = value.mimetype;
   if (value.fileName) media.fileName = value.fileName;
-  if (value.seconds !== void 0 && value.seconds !== null) media.seconds = Number(value.seconds);
+  const seconds = toNumber(value.seconds);
+  if (seconds !== void 0) media.seconds = seconds;
   return media;
 }
 function getQuoted(context, chatId) {
-  if (!context?.stanzaId) {
-    return void 0;
-  }
-  const quoted = context.quotedMessage;
-  const quotedIsViewOnce = isViewOnceContent(quoted);
-  const content = unwrapMessageContent(quoted);
-  const type = content ? getContentType(content) : void 0;
-  const node = type && content ? content[type] : void 0;
-  const media = getMedia(type, node, quotedIsViewOnce);
-  const result = {
+  if (!context?.stanzaId || !context.quotedMessage) return void 0;
+  const content = unwrapZapoMessageContent(context.quotedMessage);
+  if (!content) return void 0;
+  const { type, node } = contentNode(content);
+  const media = getMedia(type, node, isZapoViewOnceContent(context.quotedMessage));
+  const senderId = context.participant ?? void 0;
+  const quoted = {
     key: {
       id: context.stanzaId,
       chatId: context.remoteJid ?? chatId,
-      fromMe: false
+      fromMe: false,
+      ...senderId ? { participantId: senderId } : {}
     },
     hasMedia: media !== void 0,
-    isViewOnce: media?.viewOnce ?? quotedIsViewOnce
+    isViewOnce: media?.viewOnce ?? false,
+    contentKind: getContentKind(type)
   };
-  if (content) {
-    result.contentKind = getContentKind(type);
-  }
-  if (media) {
-    result.media = media;
-  }
-  if (context.participant) {
-    result.senderId = context.participant;
-    result.sender = User.fromIdentities([context.participant]);
-    result.key.participantId = context.participant;
-  }
-  if (content) {
-    const text = getText(content) ?? getCaption(content);
-    if (text !== void 0) result.text = text;
-  }
-  return result;
+  const text = getText(content) ?? getCaption(content);
+  if (text !== void 0) quoted.text = text;
+  if (senderId !== void 0) {
+    quoted.senderId = senderId;
+    quoted.sender = User.fromIdentities([senderId]);
+  }
+  if (media !== void 0) quoted.media = media;
+  return quoted;
 }
 function toDate(value) {
-  const seconds = value === null || value === void 0 ? Date.now() / 1e3 : Number(value);
+  const seconds = toNumber(value) ?? Math.floor(Date.now() / 1e3);
   return new Date(seconds * 1e3);
 }
-
-// src/provider/baileys/secret-edit.ts
-import { createDecipheriv, hkdfSync } from "crypto";
-import {
-  jidNormalizedUser,
-  normalizeMessageContent as normalizeMessageContent2,
-  proto
-} from "@whiskeysockets/baileys";
-function isSecretEncryptedEdit(message) {
-  const content = normalizeMessageContent2(message.message);
-  return content?.secretEncryptedMessage?.secretEncType === proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT;
-}
-function secretEditTargetKey(message) {
-  const content = normalizeMessageContent2(message.message);
-  const secret = content?.secretEncryptedMessage;
-  if (secret?.secretEncType !== proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT || !secret.targetMessageKey?.id) {
-    return void 0;
-  }
-  return secret.targetMessageKey;
-}
-function decryptSecretEncryptedEdit(envelope, original, meId, meLid) {
-  const content = normalizeMessageContent2(envelope.message);
-  const secret = content?.secretEncryptedMessage;
-  const targetKey = secret?.targetMessageKey;
-  if (secret?.secretEncType !== proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT || !targetKey?.id || !secret.encPayload?.length || secret.encIv?.length !== 12) {
-    return void 0;
-  }
-  const messageSecret = findMessageSecret(original.message);
-  if (messageSecret?.length !== 32) {
-    return void 0;
-  }
-  const editorCandidates = envelope.key.fromMe ? uniqueUserJids([meId, meLid]) : uniqueUserJids([
-    envelope.key.participant,
-    envelope.key.participantAlt,
-    envelope.key.remoteJid,
-    envelope.key.remoteJidAlt
-  ]);
-  const originalSenderCandidates = targetKey.fromMe ? editorCandidates : isUserJid(envelope.key.remoteJid) ? uniqueUserJids([
-    targetKey.remoteJid,
-    targetKey.remoteJidAlt,
-    original.key.remoteJid,
-    original.key.remoteJidAlt
-  ]) : uniqueUserJids([
-    targetKey.participant,
-    targetKey.participantAlt,
-    original.key.participant,
-    original.key.participantAlt
-  ]);
-  const fallbackOriginalCandidates = original.key.fromMe ? uniqueUserJids([meId, meLid]) : uniqueUserJids([
-    original.key.participant,
-    original.key.participantAlt,
-    original.key.remoteJid,
-    original.key.remoteJidAlt
-  ]);
-  const senders = uniqueUserJids([
-    ...originalSenderCandidates,
-    ...fallbackOriginalCandidates
-  ]);
-  if (!editorCandidates.length || !senders.length) {
-    return void 0;
-  }
-  let decoded;
-  for (const originalSender of senders) {
-    for (const editor of editorCandidates) {
-      try {
-        decoded = decryptPayload(
-          targetKey.id,
-          originalSender,
-          editor,
-          messageSecret,
-          secret.encIv,
-          secret.encPayload
-        );
-        break;
-      } catch {
-        continue;
-      }
-    }
-    if (decoded) {
-      break;
-    }
-  }
-  const protocol = decoded?.protocolMessage;
-  if (protocol?.type !== proto.Message.ProtocolMessage.Type.MESSAGE_EDIT || !protocol.editedMessage || protocol.key?.id && protocol.key.id !== targetKey.id) {
-    return void 0;
-  }
-  const edited = protocol.editedMessage;
-  if (!edited.messageContextInfo?.messageSecret?.length) {
-    edited.messageContextInfo = {
-      ...edited.messageContextInfo,
-      messageSecret
-    };
-  }
-  return {
-    message: edited,
-    ...protocol.timestampMs ? { timestamp: Math.floor(numberValue(protocol.timestampMs) / 1e3) } : {}
-  };
-}
-function decryptPayload(messageId, originalSender, editor, messageSecret, iv, payload) {
-  const info = Buffer.concat([
-    Buffer.from(messageId, "utf8"),
-    Buffer.from(originalSender, "utf8"),
-    Buffer.from(editor, "utf8"),
-    Buffer.from("Message Edit", "utf8")
-  ]);
-  const key = Buffer.from(hkdfSync(
-    "sha256",
-    Buffer.from(messageSecret),
-    Buffer.alloc(32),
-    info,
-    32
-  ));
-  const encrypted = Buffer.from(payload);
-  if (encrypted.length <= 16) {
-    throw new Error("INVALID_EDIT_PAYLOAD");
-  }
-  const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(iv));
-  decipher.setAAD(Buffer.alloc(0));
-  decipher.setAuthTag(encrypted.subarray(encrypted.length - 16));
-  return proto.Message.decode(Buffer.concat([
-    decipher.update(encrypted.subarray(0, encrypted.length - 16)),
-    decipher.final()
-  ]));
-}
-function findMessageSecret(message) {
-  if (!message) {
-    return void 0;
-  }
-  const direct = message.messageContextInfo?.messageSecret;
-  if (direct?.length) {
-    return direct;
-  }
-  const normalized = normalizeMessageContent2(message);
-  const normalizedSecret = normalized?.messageContextInfo?.messageSecret;
-  if (normalizedSecret?.length) {
-    return normalizedSecret;
-  }
-  const deviceSecret = message.deviceSentMessage?.message?.messageContextInfo?.messageSecret;
-  if (deviceSecret?.length) {
-    return deviceSecret;
-  }
+function toNumber(value) {
+  if (typeof value === "number") return value;
+  if (value?.toNumber) return value.toNumber();
+  if (typeof value?.low === "number") return value.low;
   return void 0;
 }
-function uniqueUserJids(values) {
-  return [...new Set(
-    values.map(normalizeUserJid).filter((value) => value !== void 0)
-  )];
-}
-function normalizeUserJid(value) {
-  if (!isUserJid(value)) {
-    return void 0;
-  }
-  return jidNormalizedUser(value);
-}
-function isUserJid(value) {
-  if (!value) {
-    return false;
-  }
-  const normalized = jidNormalizedUser(value);
-  return normalized.endsWith("@s.whatsapp.net") || normalized.endsWith("@lid") || normalized.endsWith("@hosted") || normalized.endsWith("@hosted.lid");
-}
-function numberValue(value) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "bigint") {
-    return Number(value);
-  }
-  if (value && typeof value === "object" && "toString" in value) {
-    return Number(String(value));
-  }
-  return Number(value);
-}
 
-// src/provider/baileys/baileys-provider.ts
-var BaileysProvider = class {
+// src/provider/zapo/zapo-provider.ts
+var ZapoProvider = class {
   #options;
   #events = new TypedEventEmitter();
   #logger;
   #messageStore = /* @__PURE__ */ new Map();
   #messageCacheSize;
-  #groupMetadataCache = /* @__PURE__ */ new Map();
-  #groupMetadataRequests = /* @__PURE__ */ new Map();
-  #groupMetadataGenerations = /* @__PURE__ */ new Map();
-  #groupMetadataCacheEnabled;
-  #groupMetadataCacheTtlMs;
-  #groupMetadataCacheSize;
-  #socket;
-  #saveCredentials;
-  #saveQueue = Promise.resolve();
+  #client;
+  #voip;
   #intentionalClose = false;
   #reconnectAttempt = 0;
   #reconnectTimer;
-  #registered = false;
+  #connectPromise;
+  #pairingRequired = false;
+  #connected = false;
+  #connectedAtSeconds = 0;
+  #pairingReady = Promise.resolve();
+  #resolvePairingReady;
   constructor(options) {
     this.#options = options;
     this.#logger = options.logger ?? new Logger("silent");
     this.#messageCacheSize = Math.max(1, options.messageCacheSize ?? 1e3);
-    this.#groupMetadataCacheEnabled = options.groupMetadataCache?.enabled !== false;
-    this.#groupMetadataCacheTtlMs = Math.max(1, options.groupMetadataCache?.ttlMs ?? 3e5);
-    this.#groupMetadataCacheSize = Math.max(1, options.groupMetadataCache?.maxEntries ?? 1e3);
   }
   on(event, listener) {
     return this.#events.on(event, listener);
   }
   async connect() {
-    if (this.#socket) {
+    this.#intentionalClose = false;
+    const client = await this.#ensureClient();
+    if (this.#connected || this.#connectPromise) {
       return;
     }
-    this.#intentionalClose = false;
+    this.#preparePairingGate();
     await this.#events.emit("connection", {
       state: this.#reconnectAttempt > 0 ? "reconnecting" : "connecting",
       attempt: this.#reconnectAttempt
     });
-    try {
-      const { state, saveCreds } = await useMultiFileAuthState(this.#options.auth);
-      this.#registered = state.creds.registered;
-      this.#saveCredentials = saveCreds;
-      const socket = makeWASocket({
-        auth: state,
-        browser: this.#browserDescription(),
-        logger: createBaileysLogger(this.#logger.child("baileys")),
-        markOnlineOnConnect: false,
-        enableAutoSessionRecreation: true,
-        enableRecentMessageCache: true,
-        cachedGroupMetadata: async (jid) => this.#getGroupMetadata(jid),
-        getMessage: async (key) => this.#messageStore.get(this.#messageStoreKey(key))?.message ?? void 0
-      });
-      this.#socket = socket;
-      this.#bind(socket);
-    } catch (error) {
-      this.#socket = void 0;
-      throw new WhaNextError("CONNECTION_FAILED", "Could not start the WhatsApp connection.", {
-        cause: error,
-        recoverable: true
-      });
-    }
+    this.#startConnect(client);
   }
   async disconnect() {
     this.#intentionalClose = true;
-    if (this.#reconnectTimer) clearTimeout(this.#reconnectTimer);
-    const socket = this.#socket;
-    this.#socket = void 0;
-    if (socket) {
-      await socket.end(void 0);
+    if (this.#reconnectTimer) {
+      clearTimeout(this.#reconnectTimer);
+      this.#reconnectTimer = void 0;
+    }
+    const client = this.#client;
+    this.#connectPromise = void 0;
+    if (client) {
+      await client.disconnect();
+    } else {
+      await this.#events.emit("connection", { state: "closed" });
     }
-    await this.#events.emit("connection", { state: "closed" });
+    this.#connected = false;
   }
   getCurrentUserIds() {
-    const user = this.#socket?.user;
-    if (!user) {
-      return [];
-    }
-    return [user.id, user.lid, user.phoneNumber].filter((id) => Boolean(id)).filter((id, index, ids) => ids.indexOf(id) === index);
+    const credentials = this.#client?.getCredentials();
+    return uniqueIdentities([
+      credentials?.meJid,
+      credentials?.meLid
+    ]);
   }
   async requestPairingCode(phone) {
     const normalized = phone.replace(/\D/g, "");
@@ -2849,34 +2622,28 @@ var BaileysProvider = class {
         "The phone number must include its country code."
       );
     }
-    if (this.#registered) {
+    const client = await this.#ensureClient();
+    if (client.getCredentials()?.meJid) {
       return "";
     }
-    const socket = this.#requireSocket();
+    if (!this.#connectPromise && !this.#connected) {
+      await this.connect();
+    }
     try {
-      await socket.waitForConnectionUpdate(async (update) => Boolean(update.qr), 6e4);
-      if (socket !== this.#socket) {
-        throw new WhaNextError(
-          "CONNECTION_CLOSED",
-          "The WhatsApp socket changed while preparing the pairing code.",
-          {
-            recoverable: true
-          }
+      if (!this.#pairingRequired) {
+        await this.#withTimeout(
+          this.#pairingReady,
+          6e4,
+          "The WhatsApp pairing challenge was not received in time."
         );
       }
-      return await socket.requestPairingCode(normalized);
+      return await client.auth.requestPairingCode(normalized);
     } catch (error) {
-      if (error instanceof WhaNextError) {
-        throw error;
-      }
+      if (error instanceof WhaNextError) throw error;
       throw new WhaNextError(
         "CONNECTION_FAILED",
         "Could not request the pairing code after the authentication challenge.",
-        {
-          cause: error,
-          context: { statusCode: this.#statusCode(error) },
-          recoverable: this.#statusCode(error) === DisconnectReason.connectionClosed
-        }
+        { cause: error, recoverable: true }
       );
     }
   }
@@ -2884,18 +2651,17 @@ var BaileysProvider = class {
     if ("buttons" in content) {
       return this.#sendButtons(chatId, content, replyTo);
     }
-    const socket = this.#requireSocket();
-    const options = replyTo ? {
-      quoted: {
-        key: this.#toWaKey(replyTo),
-        message: { conversation: "" }
-      }
-    } : void 0;
-    const result = await socket.sendMessage(chatId, this.#toContent(content), options);
-    return this.#sent(result);
+    const client = this.#requireClient();
+    const { value, mentions, viewOnce } = await this.#toContent(content);
+    const result = await client.message.send(chatId, value, {
+      ...replyTo ? { quote: this.#toZapoKey(replyTo) } : {},
+      ...mentions.length > 0 ? { mentions } : {},
+      ...viewOnce !== void 0 ? { viewOnce } : {}
+    });
+    return this.#sent(result, chatId);
   }
   async repostMessage(source, chatId, options = {}) {
-    const original = this.#messageStore.get(this.#messageStoreKey(source));
+    const original = this.#findStoredMessage(this.#toZapoKey(source));
     if (!original?.message) {
       throw new WhaNextError(
         "MESSAGE_NOT_FOUND",
@@ -2906,24 +2672,26 @@ var BaileysProvider = class {
         }
       );
     }
-    const content = {
-      forward: original,
-      ...options.mentions && options.mentions.length > 0 ? { mentions: this.#mentions(options.mentions) } : {}
-    };
-    const result = await this.#requireSocket().sendMessage(chatId, content);
-    return this.#sent(result);
+    const result = await this.#requireClient().message.send(
+      chatId,
+      original.message,
+      {
+        forward: true,
+        ...options.mentions && options.mentions.length > 0 ? { mentions: this.#mentions(options.mentions) } : {}
+      }
+    );
+    return this.#sent(result, chatId);
   }
   async reactToMessage(key, emoji) {
-    const result = await this.#requireSocket().sendMessage(key.chatId, {
-      react: {
-        text: emoji ?? "",
-        key: this.#toWaKey(key)
-      }
+    const result = await this.#requireClient().message.send(key.chatId, {
+      type: "reaction",
+      emoji: emoji ?? "",
+      target: this.#toZapoKey(key)
     });
-    return this.#sent(result);
+    return this.#sent(result, key.chatId);
   }
   async downloadMedia(key) {
-    const message = this.#messageStore.get(this.#messageStoreKey(key));
+    const message = this.#findStoredMessage(this.#toZapoKey(key));
     if (!message?.message) {
       throw new WhaNextError(
         "MEDIA_NOT_AVAILABLE",
@@ -2931,54 +2699,75 @@ var BaileysProvider = class {
         { recoverable: true }
       );
     }
-    const data = await downloadMediaMessage(message, "buffer", {}, {
-      reuploadRequest: (current) => this.#requireSocket().updateMediaMessage(current),
-      logger: createBaileysLogger(this.#logger.child("media"))
-    });
-    const media = normalizeBaileysMessage(message)?.media;
-    if (!media) {
-      throw new WhaNextError("MEDIA_NOT_AVAILABLE", "The selected message does not contain media.");
+    const normalized = normalizeZapoMessage(message);
+    if (!normalized?.media) {
+      throw new WhaNextError(
+        "MEDIA_NOT_AVAILABLE",
+        "The selected message does not contain media."
+      );
+    }
+    try {
+      const bytes = await this.#requireClient().message.downloadBytes(
+        message
+      );
+      return {
+        data: Buffer.from(bytes),
+        kind: normalized.media.kind,
+        ...normalized.media.mimetype ? { mimetype: normalized.media.mimetype } : {},
+        ...normalized.media.fileName ? { fileName: normalized.media.fileName } : {}
+      };
+    } catch (error) {
+      throw new WhaNextError(
+        "MEDIA_NOT_AVAILABLE",
+        "WhatsApp could not download the selected media.",
+        { cause: error, recoverable: true }
+      );
     }
-    return {
-      data,
-      kind: media.kind,
-      ...media.mimetype ? { mimetype: media.mimetype } : {},
-      ...media.fileName ? { fileName: media.fileName } : {}
-    };
   }
   async editMessage(key, content) {
-    const result = await this.#requireSocket().sendMessage(key.chatId, {
-      text: content,
-      edit: this.#toWaKey(key)
-    });
-    return this.#sent(result);
+    const result = await this.#requireClient().message.send(
+      key.chatId,
+      content,
+      { editKey: this.#toZapoKey(key) }
+    );
+    return this.#sent(result, key.chatId);
   }
   async deleteMessage(key) {
-    await this.#requireSocket().sendMessage(key.chatId, { delete: this.#toWaKey(key) });
+    await this.#requireClient().message.send(key.chatId, {
+      type: "revoke",
+      target: this.#toZapoKey(key)
+    });
   }
   async getGroup(groupId) {
-    const metadata = await this.#getGroupMetadata(groupId);
+    const metadata = await this.#requireClient().group.queryGroupMetadata(groupId);
+    const participants = [...metadata.participants ?? []];
+    const addressingMode = metadata.addressingMode === "lid" || participants.some((participant) => (participant.jid ?? participant.id ?? "").endsWith("@lid")) ? "lid" : "pn";
     return {
-      id: metadata.id,
-      subject: metadata.subject,
+      id: metadata.jid ?? metadata.id ?? groupId,
+      subject: metadata.subject ?? "",
       access: metadata.announce ? "closed" : "open",
-      addressingMode: metadata.addressingMode === "lid" ? "lid" : "pn",
+      addressingMode,
       fetchedAt: /* @__PURE__ */ new Date(),
-      participants: metadata.participants.map((participant) => ({
-        id: participant.id,
-        ...participant.lid ? { lid: participant.lid } : {},
-        ...participant.phoneNumber ? { phoneNumber: participant.phoneNumber } : {},
-        role: participant.admin === "superadmin" || participant.isSuperAdmin ? "owner" : participant.admin === "admin" || participant.isAdmin ? "admin" : "member"
-      }))
+      participants: participants.map((participant) => {
+        const id = participant.jid ?? participant.id ?? participant.lid ?? participant.phoneNumber ?? "";
+        return {
+          id,
+          ...participant.lid ? { lid: participant.lid } : {},
+          ...participant.phoneNumber ? { phoneNumber: participant.phoneNumber } : {},
+          role: participant.isSuperAdmin || participant.admin === "superadmin" ? "owner" : participant.isAdmin || participant.admin === "admin" ? "admin" : "member"
+        };
+      })
     };
   }
   async setGroupAccess(groupId, access) {
-    const setting = access === "closed" ? "announcement" : "not_announcement";
-    await this.#requireSocket().groupSettingUpdate(groupId, setting);
-    this.#invalidateGroupMetadata(groupId);
+    await this.#requireClient().group.setSetting(
+      groupId,
+      "announcement",
+      access === "closed"
+    );
   }
   async getGroupInviteCode(groupId) {
-    const code = await this.#requireSocket().groupInviteCode(groupId);
+    const code = await this.#requireClient().group.queryInviteCode(groupId);
     if (!code) {
       throw new WhaNextError(
         "PROVIDER_ERROR",
@@ -2988,139 +2777,300 @@ var BaileysProvider = class {
     return code;
   }
   async revokeGroupInvite(groupId) {
-    const code = await this.#requireSocket().groupRevokeInvite(groupId);
-    if (!code) {
+    const result = await this.#requireClient().group.revokeInvite(groupId);
+    if (!result.code) {
       throw new WhaNextError(
         "PROVIDER_ERROR",
         "WhatsApp did not return a new group invite code."
       );
     }
-    return code;
+    return result.code;
   }
   async setMessagePin(groupId, key, pinned) {
-    await this.#requireSocket().sendMessage(groupId, {
-      pin: this.#toWaKey(key),
-      type: pinned ? proto2.PinInChat.Type.PIN_FOR_ALL : proto2.PinInChat.Type.UNPIN_FOR_ALL,
-      ...pinned ? { time: 604800 } : {}
+    await this.#requireClient().message.send(groupId, pinned ? {
+      type: "pin",
+      target: this.#toZapoKey(key),
+      durationSecs: 604800
+    } : {
+      type: "unpin",
+      target: this.#toZapoKey(key)
     });
   }
   async updateParticipant(groupId, memberId, action) {
-    const [result] = await this.#requireSocket().groupParticipantsUpdate(groupId, [memberId], action);
-    this.#invalidateGroupMetadata(groupId);
-    const status = result?.status ?? "unknown";
+    const group = this.#requireClient().group;
+    const results = action === "remove" ? await group.removeParticipants(groupId, [memberId]) : action === "promote" ? await group.promoteParticipants(groupId, [memberId]) : await group.demoteParticipants(groupId, [memberId]);
+    const result = results[0];
+    const success = result?.status === "ok";
+    const status = success ? "200" : String(result?.code ?? result?.status ?? "unknown");
     return {
-      success: status === "200",
+      success,
       status,
       ...result?.jid ? { memberId: result.jid } : {}
     };
   }
   async setPresence(chatId, state) {
-    const socket = this.#requireSocket();
-    const presence = state === "typing" ? "composing" : state === "recording" ? "recording" : "paused";
-    await socket.sendPresenceUpdate(presence, chatId);
-  }
-  async rejectCall(callId, from) {
-    await this.#requireSocket().rejectCall(callId, from);
+    const value = state === "typing" ? "composing" : state === "recording" ? "recording" : "paused";
+    const presence = this.#requireClient().presence;
+    await presence.sendChatstate(chatId, { state: value });
   }
-  #bind(socket) {
-    socket.ev.on("creds.update", (update) => {
-      if (update.registered !== void 0) {
-        this.#registered = update.registered;
+  async rejectCall(callId, _from) {
+    this.#requireClient();
+    if (!this.#voip) {
+      throw new WhaNextError(
+        "PROVIDER_ERROR",
+        "WhatsApp call support is unavailable because the Zapo VoIP plugin could not be loaded.",
+        { recoverable: true }
+      );
+    }
+    await this.#voip.rejectCall(callId);
+  }
+  async #ensureClient() {
+    if (this.#client) return this.#client;
+    await mkdir(this.#options.auth, { recursive: true });
+    const store = createStore({
+      backends: {
+        sqlite: createSqliteStore({
+          path: join(this.#options.auth, "state.sqlite"),
+          driver: "auto"
+        })
+      },
+      providers: {
+        auth: "sqlite",
+        signal: "sqlite",
+        preKey: "sqlite",
+        session: "sqlite",
+        identity: "sqlite",
+        senderKey: "sqlite",
+        appState: "sqlite",
+        privacyToken: "sqlite",
+        messages: "none",
+        threads: "none",
+        contacts: "none"
+      },
+      cacheProviders: {
+        messageSecret: "sqlite"
       }
-      this.#saveQueue = this.#saveQueue.then(() => this.#saveCredentials?.()).then(() => void 0);
     });
-    socket.ev.on("messages.upsert", ({ messages, type }) => {
-      if (type !== "notify") return;
-      for (const raw of messages) {
-        if (this.#handleSecretEncryptedEdit(raw)) continue;
-        if (raw.key.id && raw.message) this.#remember(raw);
-        const quoted = extractQuotedBaileysMessage(raw);
-        if (quoted?.key.id && quoted.message) this.#remember(quoted);
-        const message = normalizeBaileysMessage(raw);
-        if (message) void this.#events.emit("message", message);
-      }
+    const plugins = [];
+    try {
+      const { voipPlugin } = await import("@zapo-js/voip");
+      plugins.push(voipPlugin({ logLevel: "warn" }));
+    } catch (error) {
+      this.#logger.warn("Zapo VoIP support is unavailable; call events and rejection are disabled.", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    const client = new WaClient({
+      store,
+      sessionId: this.#options.sessionId ?? "default",
+      markOnlineOnConnect: false,
+      deviceBrowser: this.#deviceBrowser(),
+      deviceOsDisplayName: this.#deviceOsDisplayName(),
+      history: { enabled: false },
+      addons: {
+        autoDecrypt: true,
+        persistAllSecrets: true
+      },
+      media: { processor: createMediaProcessor() },
+      plugins
+    }, new WhaNextZapoLogger(this.#logger));
+    this.#client = client;
+    this.#voip = client.voip;
+    this.#bind(client);
+    return client;
+  }
+  #bind(client) {
+    client.on("auth_pairing_required", () => {
+      this.#markPairingReady();
     });
-    socket.ev.on("messages.update", (updates) => {
-      for (const { key, update } of updates) {
-        if (!key.id || !key.remoteJid) continue;
-        const stored = this.#messageStore.get(this.#messageStoreKey(key));
-        if (update.message === null) {
-          const message = stored ? normalizeBaileysMessage(stored) : void 0;
-          const deletionKey = update.key;
-          const deletedByMe = deletionKey?.fromMe === true;
-          const deletedById = deletionKey?.participant ?? deletionKey?.participantAlt ?? (deletedByMe ? this.#socket?.user?.id : deletionKey?.remoteJid ?? void 0);
-          void this.#events.emit("messageDeleted", {
-            key: message?.keys ?? normalizeKey(key),
-            ...message ? { message } : {},
-            deletedByMe,
-            ...deletedById ? { deletedById } : {},
-            deletedAt: /* @__PURE__ */ new Date()
-          });
-          continue;
-        }
-        if (!update.message?.editedMessage?.message) continue;
-        const editedRaw = {
-          ...stored ?? {},
-          key: {
-            ...stored?.key ?? {},
-            ...key
-          },
-          message: update.message,
-          messageTimestamp: update.messageTimestamp ?? stored?.messageTimestamp ?? Math.floor(Date.now() / 1e3)
-        };
-        this.#emitMessageEdited(key, editedRaw, stored);
-      }
+    client.on("auth_qr", () => {
+      this.#markPairingReady();
     });
-    socket.ev.on("groups.update", (groups) => {
-      for (const group of groups) {
-        if (group.id) {
-          this.#invalidateGroupMetadata(group.id);
-          void this.#events.emit("groupChanged", { groupId: group.id });
-        }
-      }
+    client.on("auth_paired", () => {
+      this.#pairingRequired = false;
     });
-    socket.ev.on("group-participants.update", (update) => {
-      this.#invalidateGroupMetadata(update.id);
-      const change = this.#groupParticipantsChanged(update);
-      void this.#events.emit("groupParticipantsChanged", change);
-      const { id } = update;
-      void this.#events.emit("groupChanged", { groupId: id });
+    client.on("message", (event) => {
+      this.#handleMessage(event);
     });
-    socket.ev.on("call", (calls) => {
-      for (const call of calls) {
-        void this.#events.emit("call", this.#normalizeCall(call));
-      }
+    client.on("message_send", (event) => {
+      if (!event.id || !event.message) return;
+      this.#remember({
+        key: {
+          id: event.id,
+          remoteJid: event.to,
+          fromMe: true
+        },
+        message: event.message,
+        timestampSeconds: Math.floor(Date.now() / 1e3)
+      });
+    });
+    client.on("message_protocol", (event) => {
+      this.#handleProtocolEvent(event);
+    });
+    client.on("group", (event) => {
+      this.#handleGroupEvent(event);
+    });
+    if (this.#voip) {
+      const voipClient = client;
+      voipClient.on("voip_call_incoming", (event) => {
+        const call = this.#normalizeVoipCall(event, "offer");
+        if (call) void this.#events.emit("call", call);
+      });
+      voipClient.on("voip_call_state", (event) => {
+        if (event.stateData?.state === "ended") return;
+        const call = this.#normalizeVoipCall(event);
+        if (call && call.status !== "offer") void this.#events.emit("call", call);
+      });
+      voipClient.on("voip_call_ended", (event) => {
+        const call = this.#normalizeVoipCall(
+          event,
+          this.#callEndStatus(event.stateData?.endReason)
+        );
+        if (call) void this.#events.emit("call", call);
+      });
+    }
+    client.on("connection", (event) => {
+      void this.#handleConnectionEvent(client, event);
     });
-    socket.ev.on("connection.update", (update) => {
-      void this.#handleConnectionUpdate(socket, update.connection, update.lastDisconnect?.error);
+  }
+  #handleMessage(event) {
+    const stored = event;
+    if (this.#isOfflineMessage(stored)) {
+      this.#logger.debug("Ignored message queued before the current connection.", {
+        messageId: stored.key.id ?? void 0,
+        chatId: stored.key.remoteJid ?? void 0,
+        timestampSeconds: stored.timestampSeconds ?? void 0
+      });
+      return;
+    }
+    if (stored.key?.id && stored.message) this.#remember(stored);
+    const quoted = extractQuotedZapoMessage(event);
+    if (quoted) {
+      const quotedStored = quoted;
+      if (quotedStored.key?.id && quotedStored.message) this.#remember(quotedStored);
+    }
+    const message = normalizeZapoMessage(event);
+    if (message) void this.#events.emit("message", message);
+  }
+  #handleProtocolEvent(event) {
+    const protocol = event.protocolMessage ?? event.message?.protocolMessage;
+    if (!protocol) return;
+    const protocolKey = protocol.key;
+    if (!protocolKey?.id) return;
+    const remoteJid = protocolKey.remoteJid ?? event.key.remoteJid;
+    const participant = protocolKey.participant ?? event.key.participant;
+    const participantAlt = protocolKey.participantAlt ?? event.key.participantAlt;
+    const target = {
+      ...protocolKey,
+      ...remoteJid !== void 0 ? { remoteJid } : {},
+      ...participant !== void 0 ? { participant } : {},
+      ...participantAlt !== void 0 ? { participantAlt } : {}
+    };
+    if (!target.remoteJid) return;
+    const stored = this.#findStoredMessage(target);
+    const type = protocol?.type;
+    if (type === proto.Message.ProtocolMessage.Type.REVOKE) {
+      const previous2 = stored ? normalizeZapoMessage(stored) : void 0;
+      const deletedByMe = event.key.fromMe === true;
+      const deletedById = event.key.participant ?? event.key.participantAlt ?? (deletedByMe ? this.getCurrentUserIds()[0] : event.key.remoteJid ?? void 0);
+      void this.#events.emit("messageDeleted", {
+        key: previous2?.keys ?? normalizeZapoKey(target),
+        ...previous2 ? { message: previous2 } : {},
+        deletedByMe,
+        ...deletedById ? { deletedById } : {},
+        deletedAt: /* @__PURE__ */ new Date()
+      });
+      return;
+    }
+    if (type !== proto.Message.ProtocolMessage.Type.MESSAGE_EDIT || !protocol.editedMessage) {
+      return;
+    }
+    const pushName = event.pushName ?? stored?.pushName;
+    const edited = {
+      ...stored ?? {},
+      key: {
+        ...stored?.key ?? {},
+        ...target
+      },
+      message: protocol.editedMessage,
+      timestampSeconds: toSeconds(protocol.timestampMs) ?? event.timestampSeconds ?? stored?.timestampSeconds ?? Math.floor(Date.now() / 1e3),
+      ...pushName !== void 0 ? { pushName } : {}
+    };
+    const message = normalizeZapoMessage(edited);
+    if (!message) return;
+    const previous = stored ? normalizeZapoMessage(stored) : void 0;
+    this.#remember(edited);
+    const editedByMe = event.key.fromMe === true;
+    const editedById = event.key.participant ?? event.key.participantAlt ?? (editedByMe ? this.getCurrentUserIds()[0] : event.key.remoteJid ?? void 0);
+    void this.#events.emit("messageEdited", {
+      key: message.keys,
+      ...previous ? { previous } : {},
+      message,
+      editedByMe,
+      ...editedById ? { editedById } : {},
+      editedAt: message.timestamp
     });
   }
-  async #handleConnectionUpdate(socket, connection, error) {
-    if (socket !== this.#socket || !connection) return;
-    if (connection === "open") {
+  #handleGroupEvent(event) {
+    const groupId = event.groupJid;
+    if (!groupId) return;
+    const action = this.#groupAction(event.action);
+    const participantIds = this.#groupParticipantIds(event);
+    if (action && participantIds.length > 0) {
+      const authorId = event.authorJid;
+      const change = {
+        groupId,
+        action,
+        participantIds,
+        ...authorId ? { authorId } : {}
+      };
+      void this.#events.emit("groupParticipantsChanged", change);
+    }
+    void this.#events.emit("groupChanged", { groupId });
+  }
+  async #handleConnectionEvent(client, event) {
+    if (client !== this.#client) return;
+    if (event.status === "open") {
+      this.#connectPromise = void 0;
+      this.#connected = true;
+      this.#connectedAtSeconds = Math.floor(Date.now() / 1e3);
       this.#reconnectAttempt = 0;
       await this.#events.emit("connection", { state: "connected" });
       return;
     }
-    if (connection === "connecting") {
+    this.#connectPromise = void 0;
+    this.#connected = false;
+    const error = event.reason instanceof Error ? event.reason : event.reason ? new Error(String(event.reason)) : void 0;
+    if (this.#intentionalClose || event.isLogout) {
       await this.#events.emit("connection", {
-        state: "connecting",
-        attempt: this.#reconnectAttempt
+        state: "closed",
+        ...error ? { error } : {}
       });
       return;
     }
-    this.#socket = void 0;
-    if (this.#intentionalClose || this.#isTerminal(error)) {
-      await this.#events.emit("connection", { state: "closed", ...error ? { error } : {} });
-      return;
-    }
     await this.#scheduleReconnect(error);
   }
+  #startConnect(client) {
+    const promise = client.connect();
+    this.#connectPromise = promise;
+    void promise.catch(async (error) => {
+      if (this.#connectPromise !== promise) return;
+      this.#connectPromise = void 0;
+      if (this.#intentionalClose) return;
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      this.#logger.warn("WhatsApp connection attempt failed.", { error: normalized });
+      await this.#scheduleReconnect(normalized);
+    });
+  }
   async #scheduleReconnect(error) {
+    if (this.#reconnectTimer) return;
     const options = this.#options.reconnect;
     const maxAttempts = options?.maxAttempts ?? 10;
     if (options?.enabled === false || this.#reconnectAttempt >= maxAttempts) {
-      await this.#events.emit("connection", { state: "closed", ...error ? { error } : {} });
+      await this.#events.emit("connection", {
+        state: "closed",
+        ...error ? { error } : {}
+      });
       return;
     }
     this.#reconnectAttempt += 1;
@@ -3132,184 +3082,120 @@ var BaileysProvider = class {
     const initial = options?.initialDelayMs ?? 1e3;
     const maximum = options?.maxDelayMs ?? 3e4;
     const delay = Math.min(maximum, initial * 2 ** (this.#reconnectAttempt - 1));
-    this.#reconnectTimer = setTimeout(
-      () => void this.connect(),
-      delay + Math.floor(Math.random() * 250)
-    );
-  }
-  #browserDescription() {
-    if (this.#options.browser === "macos" /* MacOS */) return Browsers.macOS("Safari");
-    if (this.#options.browser === "ubuntu" /* Ubuntu */) return Browsers.ubuntu("Chrome");
-    return Browsers.windows("Brave");
-  }
-  #isTerminal(error) {
-    const statusCode = this.#statusCode(error);
-    return statusCode === DisconnectReason.loggedOut || statusCode === DisconnectReason.badSession || statusCode === DisconnectReason.connectionReplaced;
-  }
-  #statusCode(error) {
-    return error?.output?.statusCode;
-  }
-  #requireSocket() {
-    if (!this.#socket) {
-      throw new WhaNextError(
-        "CONNECTION_CLOSED",
-        "WhatsApp is not connected.",
-        { recoverable: true }
-      );
-    }
-    return this.#socket;
+    this.#reconnectTimer = setTimeout(() => {
+      this.#reconnectTimer = void 0;
+      void this.connect();
+    }, delay + Math.floor(Math.random() * 250));
   }
   async #sendButtons(chatId, content, replyTo) {
-    const socket = this.#requireSocket();
-    const userJid = socket.user?.id;
-    if (!userJid) {
-      throw new WhaNextError(
-        "PROVIDER_ERROR",
-        "WhatsApp did not expose the current account identity for the interactive message."
-      );
-    }
-    const interactiveMessage = proto2.Message.InteractiveMessage.create({
-      ...content.title !== void 0 ? {
-        header: {
-          title: content.title,
-          hasMediaAttachment: false
-        }
-      } : {},
-      body: { text: content.text },
-      ...content.footer !== void 0 ? { footer: { text: content.footer } } : {},
-      ...content.mentions && content.mentions.length > 0 ? {
-        contextInfo: {
-          mentionedJid: this.#mentions(content.mentions)
-        }
-      } : {},
-      nativeFlowMessage: {
-        buttons: content.buttons.map((button) => {
-          if (button.type === "copy") {
-            return {
-              name: "cta_copy",
-              buttonParamsJson: JSON.stringify({
-                display_text: button.label,
-                copy_code: button.code
-              })
-            };
+    const mentions = content.mentions ? this.#mentions(content.mentions) : [];
+    const raw = {
+      interactiveMessage: {
+        ...content.title !== void 0 ? {
+          header: {
+            title: content.title,
+            hasMediaAttachment: false
           }
-          return {
+        } : {},
+        body: { text: content.text },
+        ...content.footer !== void 0 ? { footer: { text: content.footer } } : {},
+        ...mentions.length > 0 ? { contextInfo: { mentionedJid: mentions } } : {},
+        nativeFlowMessage: {
+          buttons: content.buttons.map((button) => button.type === "copy" ? {
+            name: "cta_copy",
+            buttonParamsJson: JSON.stringify({
+              display_text: button.label,
+              copy_code: button.code
+            })
+          } : {
             name: "cta_url",
             buttonParamsJson: JSON.stringify({
               display_text: button.label,
               url: button.url,
               merchant_url: button.url
             })
-          };
-        }),
-        messageParamsJson: "{}",
-        messageVersion: 1
-      }
-    });
-    const quoted = replyTo ? {
-      key: this.#toWaKey(replyTo),
-      message: { conversation: "" }
-    } : void 0;
-    const generated = generateWAMessageFromContent(
-      chatId,
-      { interactiveMessage },
-      {
-        userJid,
-        ...quoted ? { quoted } : {}
-      }
-    );
-    const messageId = generated.key.id;
-    if (!generated.message || !messageId) {
-      throw new WhaNextError(
-        "PROVIDER_ERROR",
-        "WhatsApp could not generate the interactive message."
-      );
-    }
-    await socket.relayMessage(chatId, generated.message, {
-      messageId,
-      additionalNodes: this.#interactiveRelayNodes(chatId)
-    });
-    return this.#sent(generated);
-  }
-  #interactiveRelayNodes(chatId) {
-    const bizNode = {
-      tag: "biz",
-      attrs: {
-        actual_actors: "2",
-        host_storage: "2",
-        privacy_mode_ts: (Math.floor(Date.now() / 1e3) - 77980457).toString()
-      },
-      content: [
-        {
-          tag: "interactive",
-          attrs: { type: "native_flow", v: "1" },
-          content: [
-            {
-              tag: "native_flow",
-              attrs: { v: "9", name: "mixed" }
-            }
-          ]
-        },
-        {
-          tag: "quality_control",
-          attrs: { source_type: "third_party" }
+          }),
+          messageParamsJson: "{}",
+          messageVersion: 1
         }
-      ]
+      }
     };
-    if (isJidGroup(chatId)) {
-      return [bizNode];
-    }
-    return [
-      { tag: "bot", attrs: { biz_bot: "1" } },
-      bizNode
-    ];
+    const result = await this.#requireClient().message.send(chatId, raw, {
+      ...replyTo ? { quote: this.#toZapoKey(replyTo) } : {},
+      ...mentions.length > 0 ? { mentions } : {}
+    });
+    return this.#sent(result, chatId);
   }
-  #toContent(content) {
+  async #toContent(content) {
     if ("text" in content) {
       return {
-        text: content.text,
-        ...content.mentions ? { mentions: this.#mentions(content.mentions) } : {}
+        value: { type: "text", text: content.text },
+        mentions: content.mentions ? this.#mentions(content.mentions) : []
       };
     }
     if ("image" in content) {
       return {
-        image: this.#media(content.image),
-        ...content.caption !== void 0 ? { caption: content.caption } : {},
-        ...content.mentions ? { mentions: this.#mentions(content.mentions) } : {},
+        value: {
+          type: "image",
+          media: await this.#media(content.image),
+          ...content.caption !== void 0 ? { caption: content.caption } : {}
+        },
+        mentions: content.mentions ? this.#mentions(content.mentions) : [],
         ...content.viewOnce !== void 0 ? { viewOnce: content.viewOnce } : {}
       };
     }
     if ("video" in content) {
       return {
-        video: this.#media(content.video),
-        ...content.caption !== void 0 ? { caption: content.caption } : {},
-        ...content.mentions ? { mentions: this.#mentions(content.mentions) } : {},
-        ...content.viewOnce !== void 0 ? { viewOnce: content.viewOnce } : {},
-        ...content.gif !== void 0 ? { gifPlayback: content.gif } : {}
+        value: {
+          type: "video",
+          media: await this.#media(content.video),
+          ...content.caption !== void 0 ? { caption: content.caption } : {},
+          ...content.gif !== void 0 ? { gifPlayback: content.gif } : {}
+        },
+        mentions: content.mentions ? this.#mentions(content.mentions) : [],
+        ...content.viewOnce !== void 0 ? { viewOnce: content.viewOnce } : {}
       };
     }
     if ("sticker" in content) {
-      return { sticker: this.#media(content.sticker) };
+      return {
+        value: {
+          type: "sticker",
+          media: await this.#media(content.sticker),
+          mimetype: "image/webp"
+        },
+        mentions: []
+      };
     }
     return {
-      audio: this.#media(content.audio),
-      ...content.mimetype ? { mimetype: content.mimetype } : {},
-      ...content.voice !== void 0 ? { ptt: content.voice } : {}
+      value: {
+        type: "audio",
+        media: await this.#media(content.audio),
+        ...content.mimetype ? { mimetype: content.mimetype } : {},
+        ...content.voice !== void 0 ? { ptt: content.voice } : {}
+      },
+      mentions: []
     };
   }
-  #media(source) {
-    if (source instanceof Uint8Array) {
-      return Buffer.from(source);
-    }
-    if ("url" in source) {
-      return { url: source.url };
+  async #media(source) {
+    if (source instanceof Uint8Array) return source;
+    if ("path" in source) return source.path;
+    const response = await fetch(source.url);
+    if (!response.ok) {
+      throw new WhaNextError(
+        "PROVIDER_ERROR",
+        "Could not download the remote media source.",
+        {
+          context: { status: response.status },
+          recoverable: response.status >= 500
+        }
+      );
     }
-    return { url: source.path };
+    return new Uint8Array(await response.arrayBuffer());
   }
   #mentions(mentions) {
     return mentions.map((mention) => typeof mention === "string" ? mention : mention.mentionId);
   }
-  #toWaKey(key) {
+  #toZapoKey(key) {
     return {
       id: key.id,
       remoteJid: key.chatId,
@@ -3317,101 +3203,78 @@ var BaileysProvider = class {
       ...key.participantId ? { participant: key.participantId } : {}
     };
   }
-  #sent(message) {
-    if (!message?.key.id || !message.key.remoteJid) {
-      throw new WhaNextError("PROVIDER_ERROR", "WhatsApp did not confirm the sent message.");
+  #sent(result, chatId) {
+    if (!result.id) {
+      throw new WhaNextError(
+        "PROVIDER_ERROR",
+        "WhatsApp did not confirm the sent message."
+      );
     }
-    if (message.message) this.#remember(message);
     return {
-      id: message.key.id,
-      chatId: message.key.remoteJid,
-      keys: normalizeKey(message.key),
+      id: result.id,
+      chatId,
+      keys: {
+        id: result.id,
+        chatId,
+        fromMe: true
+      },
       timestamp: /* @__PURE__ */ new Date()
     };
   }
-  #normalizeCall(call) {
+  #normalizeVoipCall(event, forcedStatus) {
+    const id = event.callId;
+    const from = event.callerPn ?? event.peerJid ?? event.callCreator;
+    const chatId = event.groupJid ?? event.peerJid ?? from;
+    if (!id || !from || !chatId) return void 0;
     return {
-      id: call.id,
-      chatId: call.chatId,
-      from: call.from,
-      status: this.#callStatus(call.status),
-      isVideo: Boolean(call.isVideo),
-      isGroup: Boolean(call.isGroup),
-      date: call.date ?? /* @__PURE__ */ new Date()
-    };
-  }
-  #groupParticipantsChanged(change) {
-    const participantIds = change.participants.map((participant) => participant.id).filter((id) => Boolean(id));
-    return {
-      groupId: change.id,
-      action: change.action,
-      participantIds,
-      ...change.author ? { authorId: change.author } : {}
+      id,
+      chatId,
+      from,
+      status: forcedStatus ?? this.#callStatus(event.stateData?.state),
+      isVideo: event.mediaType === "video",
+      isGroup: Boolean(event.groupJid),
+      date: event.createdAt ?? /* @__PURE__ */ new Date()
     };
   }
   #callStatus(status) {
-    const known = [
-      "offer",
-      "ringing",
-      "preaccept",
-      "timeout",
-      "reject",
-      "accept"
-    ];
-    return known.find((value) => value === status) ?? "timeout";
-  }
-  #handleSecretEncryptedEdit(raw) {
-    if (!isSecretEncryptedEdit(raw)) return false;
-    const targetKey = secretEditTargetKey(raw);
-    if (!targetKey?.id) return true;
-    const stored = this.#findStoredMessage(targetKey);
-    if (!stored) return true;
-    try {
-      const decrypted = decryptSecretEncryptedEdit(
-        raw,
-        stored,
-        this.#socket?.user?.id,
-        this.#socket?.user?.lid
-      );
-      if (!decrypted) return true;
-      const key = {
-        ...stored.key,
-        id: targetKey.id
-      };
-      const editedRaw = {
-        ...stored,
-        key,
-        message: {
-          editedMessage: {
-            message: decrypted.message
-          }
-        },
-        messageTimestamp: decrypted.timestamp ?? raw.messageTimestamp ?? stored.messageTimestamp ?? Math.floor(Date.now() / 1e3)
-      };
-      this.#emitMessageEdited(key, editedRaw, stored);
-    } catch (error) {
-      this.#logger.warn("Could not decrypt the encrypted message edit.", {
-        messageId: targetKey.id,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-    return true;
+    switch (status?.toLowerCase()) {
+      case "offer":
+      case "initiating":
+        return "offer";
+      case "ringing":
+      case "incoming_ringing":
+        return "ringing";
+      case "preaccept":
+      case "connecting":
+        return "preaccept";
+      case "accept":
+      case "accepted":
+      case "active":
+        return "accept";
+      case "reject":
+      case "rejected":
+      case "terminate":
+      case "terminated":
+      case "ended":
+        return "reject";
+      default:
+        return "timeout";
+    }
+  }
+  #callEndStatus(reason) {
+    return reason?.toLowerCase() === "timeout" ? "timeout" : "reject";
+  }
+  #groupAction(action) {
+    const value = action?.toLowerCase() ?? "";
+    if (value.includes("promote")) return "promote";
+    if (value.includes("demote")) return "demote";
+    if (value.includes("remove") || value.includes("leave")) return "remove";
+    if (value.includes("add") || value.includes("join")) return "add";
+    if (value.includes("participant") || value.includes("modify")) return "modify";
+    return void 0;
   }
-  #emitMessageEdited(key, editedRaw, stored) {
-    const previous = stored ? normalizeBaileysMessage(stored) : void 0;
-    const message = normalizeBaileysMessage(editedRaw);
-    if (!message) return;
-    this.#remember(editedRaw);
-    const editedByMe = key.fromMe === true;
-    const editedById = key.participant ?? key.participantAlt ?? (editedByMe ? this.#socket?.user?.id : key.remoteJid ?? void 0);
-    void this.#events.emit("messageEdited", {
-      key: message.keys,
-      ...previous ? { previous } : {},
-      message,
-      editedByMe,
-      ...editedById ? { editedById } : {},
-      editedAt: message.timestamp
-    });
+  #groupParticipantIds(event) {
+    return uniqueIdentities((event.participants ?? []).map((participant) => participant.jid ?? participant.lidJid ?? participant.phoneJid));
   }
   #findStoredMessage(key) {
     const direct = this.#messageStore.get(this.#messageStoreKey(key));
@@ -3431,70 +3294,117 @@ var BaileysProvider = class {
       if (oldest) this.#messageStore.delete(oldest);
     }
   }
-  async #getGroupMetadata(groupId) {
-    if (this.#groupMetadataCacheEnabled) {
-      const cached = this.#groupMetadataCache.get(groupId);
-      if (cached && cached.expiresAt > Date.now()) {
-        this.#groupMetadataCache.delete(groupId);
-        this.#groupMetadataCache.set(groupId, cached);
-        return cached.value;
-      }
-      if (cached) this.#groupMetadataCache.delete(groupId);
-    }
-    const generation = this.#groupMetadataGenerations.get(groupId) ?? 0;
-    const pending = this.#groupMetadataRequests.get(groupId);
-    if (pending?.generation === generation) return pending.promise;
-    const request = this.#requireSocket().groupMetadata(groupId);
-    const requestEntry = { generation, promise: request };
-    this.#groupMetadataRequests.set(groupId, requestEntry);
+  #messageStoreKey(key) {
+    return `${key.remoteJid ?? ""}:${key.id ?? ""}:${key.participant ?? key.participantAlt ?? ""}`;
+  }
+  #isOfflineMessage(message) {
+    if (this.#options.processOfflineMessages === true) return false;
+    if (message.offline === true) return true;
+    if (!this.#connectedAtSeconds || message.timestampSeconds == null) return false;
+    const timestamp = toSeconds(message.timestampSeconds);
+    if (timestamp === void 0) return false;
+    return timestamp < this.#connectedAtSeconds - 3;
+  }
+  #markPairingReady() {
+    this.#pairingRequired = true;
+    this.#resolvePairingReady?.();
+    this.#resolvePairingReady = void 0;
+  }
+  #preparePairingGate() {
+    this.#pairingRequired = false;
+    this.#pairingReady = new Promise((resolve3) => {
+      this.#resolvePairingReady = resolve3;
+    });
+  }
+  #deviceBrowser() {
+    return this.#options.browser === "macos" /* MacOS */ ? "safari" : "chrome";
+  }
+  #deviceOsDisplayName() {
+    if (this.#options.browser === "macos" /* MacOS */) return "macOS";
+    if (this.#options.browser === "ubuntu" /* Ubuntu */) return "Ubuntu";
+    return "Windows";
+  }
+  #requireClient() {
+    const client = this.#client;
+    if (!client || !this.#connected) {
+      throw new WhaNextError(
+        "CONNECTION_CLOSED",
+        "WhatsApp is not connected.",
+        { recoverable: true }
+      );
+    }
+    return client;
+  }
+  async #withTimeout(promise, timeoutMs, message) {
+    let timer;
     try {
-      const metadata = await request;
-      if ((this.#groupMetadataGenerations.get(groupId) ?? 0) === generation) {
-        this.#rememberGroupMetadata(groupId, metadata);
-      }
-      return metadata;
+      return await Promise.race([
+        promise,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            reject(new WhaNextError(
+              "CONNECTION_FAILED",
+              message,
+              { recoverable: true }
+            ));
+          }, timeoutMs);
+        })
+      ]);
     } finally {
-      if (this.#groupMetadataRequests.get(groupId) === requestEntry) {
-        this.#groupMetadataRequests.delete(groupId);
-      }
+      if (timer) clearTimeout(timer);
     }
   }
-  #rememberGroupMetadata(groupId, metadata) {
-    if (!this.#groupMetadataCacheEnabled) return;
-    this.#groupMetadataCache.delete(groupId);
-    this.#groupMetadataCache.set(groupId, {
-      value: metadata,
-      expiresAt: Date.now() + this.#groupMetadataCacheTtlMs
-    });
-    while (this.#groupMetadataCache.size > this.#groupMetadataCacheSize) {
-      const oldest = this.#groupMetadataCache.keys().next().value;
-      if (oldest === void 0) return;
-      this.#groupMetadataCache.delete(oldest);
-    }
+};
+var WhaNextZapoLogger = class _WhaNextZapoLogger {
+  level;
+  #logger;
+  #context;
+  constructor(logger, context = {}) {
+    this.#logger = logger;
+    this.#context = context;
+    this.level = logger.level === "debug" ? "debug" : logger.level === "warn" ? "warn" : logger.level === "error" || logger.level === "silent" ? "error" : "info";
   }
-  #invalidateGroupMetadata(groupId) {
-    this.#groupMetadataCache.delete(groupId);
-    const generation = this.#groupMetadataGenerations.get(groupId) ?? 0;
-    this.#groupMetadataGenerations.set(groupId, generation + 1);
+  trace(message, context) {
+    this.#logger.debug(message, this.#merge(context));
   }
-  #messageStoreKey(key) {
-    const chatId = "chatId" in key ? key.chatId : key.remoteJid;
-    return `${chatId ?? ""}:${key.id ?? ""}`;
+  debug(message, context) {
+    this.#logger.debug(message, this.#merge(context));
+  }
+  info(message, context) {
+    this.#logger.info(message, this.#merge(context));
+  }
+  warn(message, context) {
+    this.#logger.warn(message, this.#merge(context));
+  }
+  error(message, context) {
+    this.#logger.error(message, this.#merge(context));
+  }
+  child(bindings) {
+    return new _WhaNextZapoLogger(this.#logger, {
+      ...this.#context,
+      ...bindings
+    });
+  }
+  #merge(context) {
+    return context ? { ...this.#context, ...context } : this.#context;
   }
 };
+function toSeconds(value) {
+  const raw = typeof value === "number" ? value : value?.toNumber ? value.toNumber() : value?.low;
+  if (raw === void 0) return void 0;
+  return raw > 1e10 ? Math.floor(raw / 1e3) : raw;
+}
 
 // src/app/create.ts
 async function create(options = {}) {
   const logger = new Logger(options.logger);
-  const provider = options.provider ?? new BaileysProvider({
+  const provider = options.provider ?? new ZapoProvider({
     auth: options.auth ?? "./session",
     browser: options.browser ?? "windows" /* Windows */,
     logger: logger.child("provider"),
+    ...options.accountId ? { sessionId: options.accountId } : {},
     ...options.messageCacheSize !== void 0 ? { messageCacheSize: options.messageCacheSize } : {},
-    groupMetadataCache: {
-      ...options.cache?.groupTtlMs !== void 0 ? { ttlMs: options.cache.groupTtlMs } : {},
-      ...options.cache?.memoryMaxEntries !== void 0 ? { maxEntries: options.cache.memoryMaxEntries } : {}
-    },
+    ...options.processOfflineMessages !== void 0 ? { processOfflineMessages: options.processOfflineMessages } : {},
     ...options.reconnect ? { reconnect: options.reconnect } : {}
   });
   return new WhaNextApp(provider, {
@@ -3510,7 +3420,7 @@ async function create(options = {}) {
 
 // src/app/multi-app.ts
 import {
-  join,
+  join as join2,
   resolve as resolve2
 } from "path";
 var MultiCommandRouter = class {
@@ -3656,7 +3566,7 @@ async function createMulti(options) {
     }
     normalizedIds.add(normalizedId);
     if (account.provider === void 0) {
-      const authPath = resolve2(account.auth ?? join(authRoot, account.id));
+      const authPath = resolve2(account.auth ?? join2(authRoot, account.id));
       if (authPaths.has(authPath)) {
         throw new WhaNextError(
           "ARGUMENT_INVALID",
@@ -3677,13 +3587,13 @@ async function createMulti(options) {
     if (merged.mute?.enabled === true && merged.mute.store === void 0 && merged.mute.database === void 0) {
       merged.mute = {
         ...merged.mute,
-        database: join("./data", `whanext-${id}.sqlite`)
+        database: join2("./data", `whanext-${id}.sqlite`)
       };
     }
     const app = await create({
       ...merged,
       accountId: id,
-      auth: overrides.auth ?? join(authRoot, id)
+      auth: overrides.auth ?? join2(authRoot, id)
     });
     apps.set(id, app);
   }