@whanext/core 0.19.1 → 0.19.3

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.19.3
+### Corrigido
+- Carregamento lazy do plugin VoIP do Zapo para evitar importar o runtime WebRTC em consumidores e testes que não inicializam o provider.
+- Ajustes de tipagem dos testes com `exactOptionalPropertyTypes`.
+- Provider Zapo agora usa `@zapo-js/voip` como único caminho de chamadas: eventos `voip_*` e `client.voip.rejectCall()`, sem fallback silencioso.
+- `messageEdited` também reconhece edições criptografadas descriptografadas pelo Zapo em `message_addon`, além de `message_protocol`.
+- `messageDeleted` e `messageEdited` ignoram protocolo de backlog durante bootstrap quando `processOfflineMessages` está desativado.
+- Mensagens recebidas antes de `connection: open` deixam de ser publicadas como mensagens ao vivo; ainda entram no cache limitado para permitir recuperação posterior.
+- Eventos `message` duplicados no mesmo runtime são descartados antes de chegar aos consumidores, evitando downloads repetidos de mídia/ViewOnce.
+
+### Compatibilidade
+- Mudança corretiva e aditiva; a API pública de `CallEvent`, `messageDeleted` e `messageEdited` permanece inalterada.
+
+## 0.19.2
+
+- Corrigido o download real de mídias citadas no provider Zapo: `downloadMedia()` agora entrega o `Proto.IMessage` bruto diretamente ao `downloadBytes()`, como suportado pela API do Zapo.
+- Envelopes `viewOnceMessage`, `viewOnceMessageV2` e `viewOnceMessageV2Extension` são desembrulhados antes do download, evitando falhas ao responder imagens/vídeos de visualização única.
+- A correção cobre replies comuns de imagem, vídeo, áudio e sticker, além de view-once.
+
+
 ## 0.19.1
 
 - Corrige menus de lista no provider Zapo usando `interactiveMessage` Native Flow com `single_select` em vez do `listMessage` legado.

package/dist/index.js

@@ -2708,9 +2708,10 @@ var ZapoProvider = class {
   #logger;
   #messageStore = /* @__PURE__ */ new Map();
   #messageKeyStore = /* @__PURE__ */ new WeakMap();
+  #deliveredMessageStore = /* @__PURE__ */ new Set();
+  #handledProtocolStore = /* @__PURE__ */ new Set();
   #messageCacheSize;
   #client;
-  #voip;
   #intentionalClose = false;
   #reconnectAttempt = 0;
   #reconnectTimer;
@@ -2859,9 +2860,8 @@ var ZapoProvider = class {
       );
     }
     try {
-      const bytes = await this.#requireClient().message.downloadBytes(
-        message
-      );
+      const mediaMessage = unwrapZapoMessageContent(message.message) ?? message.message;
+      const bytes = await this.#requireClient().message.downloadBytes(mediaMessage);
       return {
         data: Buffer.from(bytes),
         kind: normalized.media.kind,
@@ -2966,15 +2966,8 @@ var ZapoProvider = class {
     await presence.sendChatstate(chatId, { state: value });
   }
   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);
+    const client = this.#requireClient();
+    await client.voip.rejectCall(callId);
   }
   async #ensureClient() {
     if (this.#client) return this.#client;
@@ -3003,15 +2996,8 @@ var ZapoProvider = class {
         messageSecret: "sqlite"
       }
     });
-    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 { voipPlugin } = await import("@zapo-js/voip");
+    const voip = voipPlugin({ logLevel: "warn" });
     const client = new WaClient({
       store,
       sessionId: this.#options.sessionId ?? "default",
@@ -3024,10 +3010,9 @@ var ZapoProvider = class {
         persistAllSecrets: true
       },
       media: { processor: createMediaProcessor() },
-      plugins
+      plugins: [voip]
     }, new WhaNextZapoLogger(this.#logger));
     this.#client = client;
-    this.#voip = client.voip;
     this.#bind(client);
     return client;
   }
@@ -3059,49 +3044,60 @@ var ZapoProvider = class {
     client.on("message_protocol", (event) => {
       this.#handleProtocolEvent(event);
     });
+    client.on("message_addon", (event) => {
+      this.#handleAddonEvent(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);
-      });
-    }
+    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) => {
+      const state = event.stateData?.state;
+      if (state === "incoming_ringing" || state === "ended") return;
+      const call = this.#normalizeVoipCall(event);
+      if (call) 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);
     });
   }
   #handleMessage(event) {
     const stored = event;
+    if (stored.key?.id && stored.message) this.#remember(stored);
+    const quoted = extractQuotedZapoMessage(event);
+    if (quoted?.key.id && quoted.message) {
+      this.#remember(quoted);
+    }
     if (this.#isOfflineMessage(stored)) {
-      this.#logger.debug("Ignored message queued before the current connection.", {
+      this.#logger.debug("Ignored message queued before the current live 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?.key.id && quoted.message) {
-      this.#remember(quoted);
+    const deliveryKey = this.#messageDeliveryKey(stored.key);
+    if (stored.key.id && this.#deliveredMessageStore.has(deliveryKey)) {
+      this.#logger.debug("Ignored duplicate Zapo message event.", {
+        messageId: stored.key.id,
+        chatId: stored.key.remoteJid ?? void 0
+      });
+      return;
     }
     const message = normalizeZapoMessage(event);
     if (!message) return;
+    if (stored.key.id) this.#rememberDeliveredMessage(deliveryKey);
     this.#messageKeyStore.set(message.keys, stored);
     if (message.quoted && quoted?.message) {
       this.#messageKeyStore.set(
@@ -3111,7 +3107,50 @@ var ZapoProvider = class {
     }
     void this.#events.emit("message", message);
   }
+  #handleAddonEvent(event) {
+    if (event.kind !== "message_edit" || !event.targetMessageId) return;
+    const editedMessage = this.#addonEditedMessage(event.decrypted);
+    if (!editedMessage) return;
+    const target = {
+      id: event.targetMessageId,
+      ...event.key.remoteJid !== void 0 ? { remoteJid: event.key.remoteJid } : {},
+      ...event.key.fromMe !== void 0 ? { fromMe: event.key.fromMe } : {},
+      ...event.key.participant !== void 0 ? { participant: event.key.participant } : {},
+      ...event.key.participantAlt !== void 0 ? { participantAlt: event.key.participantAlt } : {}
+    };
+    this.#handleProtocolEvent({
+      key: event.key,
+      ...event.offline !== void 0 ? { offline: event.offline } : {},
+      protocolMessage: {
+        type: proto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
+        key: target,
+        editedMessage
+      }
+    });
+  }
+  #addonEditedMessage(value) {
+    if (!value || typeof value !== "object") return void 0;
+    const record = value;
+    const protocol = record.protocolMessage;
+    if (protocol && typeof protocol === "object") {
+      const edited2 = protocol.editedMessage;
+      if (edited2 && typeof edited2 === "object") return edited2;
+    }
+    const edited = record.editedMessage;
+    if (edited && typeof edited === "object") return edited;
+    const message = record.message;
+    if (message && typeof message === "object") return message;
+    return value;
+  }
   #handleProtocolEvent(event) {
+    if (this.#isOfflineMessage(event)) {
+      this.#logger.debug("Ignored protocol event queued before the current live connection.", {
+        messageId: event.key.id ?? void 0,
+        chatId: event.key.remoteJid ?? void 0,
+        timestampSeconds: event.timestampSeconds ?? void 0
+      });
+      return;
+    }
     const protocol = event.protocolMessage ?? event.message?.protocolMessage;
     if (!protocol) return;
     const protocolKey = protocol.key;
@@ -3128,7 +3167,16 @@ var ZapoProvider = class {
     if (!target.remoteJid) return;
     const stored = this.#findStoredMessage(target);
     const type = protocol?.type;
+    const mutationKey = this.#protocolDeliveryKey(event, target, type);
+    if (mutationKey && this.#handledProtocolStore.has(mutationKey)) {
+      this.#logger.debug("Ignored duplicate Zapo protocol event.", {
+        messageId: event.key.id ?? void 0,
+        targetMessageId: target.id ?? void 0
+      });
+      return;
+    }
     if (type === proto.Message.ProtocolMessage.Type.REVOKE) {
+      if (mutationKey) this.#rememberHandledProtocol(mutationKey);
       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);
@@ -3158,6 +3206,7 @@ var ZapoProvider = class {
     const message = normalizeZapoMessage(edited);
     if (!message) return;
     const previous = stored ? normalizeZapoMessage(stored) : void 0;
+    if (mutationKey) this.#rememberHandledProtocol(mutationKey);
     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);
@@ -3608,9 +3657,33 @@ var ZapoProvider = class {
   #messageStoreKey(key) {
     return `${key.remoteJid ?? ""}:${key.id ?? ""}:${key.participant ?? key.participantAlt ?? ""}`;
   }
+  #messageDeliveryKey(key) {
+    return `${key.remoteJid ?? ""}:${key.id ?? ""}`;
+  }
+  #protocolDeliveryKey(event, target, type) {
+    if (type == null || !event.key.id || !target.id) return void 0;
+    return `${type}:${event.key.remoteJid ?? target.remoteJid ?? ""}:${event.key.id}:${target.id}`;
+  }
+  #rememberHandledProtocol(key) {
+    this.#handledProtocolStore.delete(key);
+    this.#handledProtocolStore.add(key);
+    while (this.#handledProtocolStore.size > this.#messageCacheSize) {
+      const oldest = this.#handledProtocolStore.values().next().value;
+      if (oldest) this.#handledProtocolStore.delete(oldest);
+    }
+  }
+  #rememberDeliveredMessage(key) {
+    this.#deliveredMessageStore.delete(key);
+    this.#deliveredMessageStore.add(key);
+    while (this.#deliveredMessageStore.size > this.#messageCacheSize) {
+      const oldest = this.#deliveredMessageStore.values().next().value;
+      if (oldest) this.#deliveredMessageStore.delete(oldest);
+    }
+  }
   #isOfflineMessage(message) {
     if (this.#options.processOfflineMessages === true) return false;
     if (message.offline === true) return true;
+    if (!this.#connected) return true;
     if (!this.#connectedAtSeconds || message.timestampSeconds == null) return false;
     const timestamp = toSeconds(message.timestampSeconds);
     if (timestamp === void 0) return false;