@whanext/core 0.19.2 → 0.19.4

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.19.4
+### Corrigido
+- Corrigida a normalização de `timestampMs` dos eventos nativos de chamada; removida uma referência inválida ao helper privado `#number`.
+- Chamadas no provider Zapo agora usam o evento nativo `call`, sem depender do plugin completo de VoIP.
+- `rejectCall()` envia diretamente a sinalização mínima `<call><reject/></call>` pelo `client.lowlevel.sendNode()`, preservando `callId` e `callCreatorJid`.
+- Removidas as dependências `@zapo-js/voip`, `@roamhq/wrtc` e `libmlow-wasm` do WhaNext Core; detectar/rejeitar chamadas não exige WebRTC nem binário nativo.
+- O `callCreatorJid` técnico é mantido em cache limitado para que a rejeição use o endereço de protocolo correto mesmo quando o evento público expõe o `callerPnJid`.
+
+### Compatibilidade
+- A API pública permanece igual: `app.on('call')`, `CallEvent` e `rejectCall(callId, from)` não mudam para consumidores.
+- O suporte completo a aceitar/realizar chamadas VoIP não faz parte da API pública do WhaNext.
+
+## 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.

package/MIGRATING_TO_ZAPO.md

@@ -58,7 +58,7 @@ O provider usa `@zapo-js/media-utils`. Para processamento completo de imagem, v
 
 ## Chamadas
 
-O suporte a `app.on('call')` e `rejectCall()` usa o plugin oficial `@zapo-js/voip`. As dependências de runtime do plugin já fazem parte do pacote do WhaNext v0.18.
+A partir da v0.19.4, `app.on('call')` usa o evento `call` nativo do Zapo e `rejectCall()` envia somente a sinalização de rejeição pelo `client.lowlevel`. O WhaNext não carrega o stack completo de VoIP/WebRTC para detectar ou rejeitar chamadas.
 
 ## Checklist de atualização
 

package/README.md

@@ -994,6 +994,8 @@ app.on('call', async (call) => {
 
 `call.status` reflete o ciclo da chamada (`offer`, `ringing`, `preaccept`, `timeout`, `reject`, `accept`). `call.isVideo` e `call.isGroup` indicam o tipo. Somente chamadas em `offer` podem ser rejeitadas.
 
+No provider Zapo, detecção e rejeição usam apenas a sinalização nativa de chamadas e `client.lowlevel.sendNode()`. O WhaNext não carrega o stack completo de VoIP/WebRTC para esse fluxo.
+
 ## Erros
 
 ```ts

package/dist/index.js

@@ -2708,9 +2708,11 @@ var ZapoProvider = class {
   #logger;
   #messageStore = /* @__PURE__ */ new Map();
   #messageKeyStore = /* @__PURE__ */ new WeakMap();
+  #deliveredMessageStore = /* @__PURE__ */ new Set();
+  #handledProtocolStore = /* @__PURE__ */ new Set();
+  #callCreatorStore = /* @__PURE__ */ new Map();
   #messageCacheSize;
   #client;
-  #voip;
   #intentionalClose = false;
   #reconnectAttempt = 0;
   #reconnectTimer;
@@ -2964,16 +2966,26 @@ var ZapoProvider = class {
     const presence = this.#requireClient().presence;
     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);
+  async rejectCall(callId, from) {
+    const client = this.#requireClient();
+    const creator = this.#callCreatorStore.get(callId) ?? from;
+    if (!creator) {
+      throw new WhaNextError("ARGUMENT_INVALID", "Call creator is required to reject a call.");
+    }
+    const lowlevel = client.lowlevel;
+    await lowlevel.sendNode({
+      tag: "call",
+      attrs: { to: creator },
+      content: [
+        {
+          tag: "reject",
+          attrs: {
+            "call-id": callId,
+            "call-creator": creator
+          }
+        }
+      ]
+    });
   }
   async #ensureClient() {
     if (this.#client) return this.#client;
@@ -3002,15 +3014,6 @@ 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 client = new WaClient({
       store,
       sessionId: this.#options.sessionId ?? "default",
@@ -3022,11 +3025,9 @@ var ZapoProvider = class {
         autoDecrypt: true,
         persistAllSecrets: true
       },
-      media: { processor: createMediaProcessor() },
-      plugins
+      media: { processor: createMediaProcessor() }
     }, new WhaNextZapoLogger(this.#logger));
     this.#client = client;
-    this.#voip = client.voip;
     this.#bind(client);
     return client;
   }
@@ -3058,49 +3059,46 @@ 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);
-      });
-    }
+    client.on("call", (event) => {
+      const call = this.#normalizeCall(event);
+      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(
@@ -3110,7 +3108,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;
@@ -3127,7 +3168,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);
@@ -3157,6 +3207,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);
@@ -3521,49 +3572,49 @@ var ZapoProvider = class {
       timestamp: /* @__PURE__ */ new Date()
     };
   }
-  #normalizeVoipCall(event, forcedStatus) {
+  #normalizeCall(event) {
     const id = event.callId;
-    const from = event.callerPn ?? event.peerJid ?? event.callCreator;
-    const chatId = event.groupJid ?? event.peerJid ?? from;
+    const creator = event.callCreatorJid ?? void 0;
+    const from = event.callerPnJid ?? creator;
+    const chatId = event.groupJid ?? from;
     if (!id || !from || !chatId) return void 0;
+    if (creator) {
+      this.#callCreatorStore.delete(id);
+      this.#callCreatorStore.set(id, creator);
+      while (this.#callCreatorStore.size > 256) {
+        const oldest = this.#callCreatorStore.keys().next().value;
+        if (!oldest) break;
+        this.#callCreatorStore.delete(oldest);
+      }
+    }
+    const timestampMs = toNumber2(event.timestampMs);
     return {
       id,
       chatId,
       from,
-      status: forcedStatus ?? this.#callStatus(event.stateData?.state),
-      isVideo: event.mediaType === "video",
+      status: this.#callStatus(event.type),
+      isVideo: event.isVideo === true,
       isGroup: Boolean(event.groupJid),
-      date: event.createdAt ?? /* @__PURE__ */ new Date()
+      date: timestampMs && timestampMs > 0 ? new Date(timestampMs) : /* @__PURE__ */ new Date()
     };
   }
   #callStatus(status) {
     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";
@@ -3607,9 +3658,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;
@@ -3699,6 +3774,12 @@ var WhaNextZapoLogger = class _WhaNextZapoLogger {
     return context ? { ...this.#context, ...context } : this.#context;
   }
 };
+function toNumber2(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 toSeconds(value) {
   const raw = typeof value === "number" ? value : value?.toNumber ? value.toNumber() : value?.low;
   if (raw === void 0) return void 0;