@whanext/core 0.19.3 → 0.19.5

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.19.5
+
+### Fixed
+- Zapo protocol mutations (`MESSAGE_EDIT` and `REVOKE`) no longer trust the undocumented `offline` envelope flag after the live connection is open; stale mutations are filtered by connection time instead.
+- Protocol edits/revokes are recognized both from `message_protocol` and from a raw `message.protocolMessage` fallback, with existing deduplication preventing double delivery.
+- Edited-message wrappers are unwrapped before normalization, preserving the previous/current payload expected by `messageEdited`.
+- Decrypted `message_addon` edits now accept both the typed `message_edit` form and nested `protocolMessage` forms.
+- Protocol target lookup remains ID-first so PN/LID/participant addressing differences do not prevent recovering the cached original.
+
+
+## 0.19.4
+### Corrigido
+- 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.

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

@@ -2388,9 +2388,13 @@ import {
 // src/provider/zapo/normalize-message.ts
 function unwrapZapoMessageContent(input) {
   if (!input) return void 0;
-  const nested = input.ephemeralMessage?.message ?? input.viewOnceMessage?.message ?? input.viewOnceMessageV2?.message ?? viewOnceV2ExtensionMessage(input) ?? input.deviceSentMessage?.message ?? input.documentWithCaptionMessage?.message;
+  const nested = input.ephemeralMessage?.message ?? input.viewOnceMessage?.message ?? input.viewOnceMessageV2?.message ?? viewOnceV2ExtensionMessage(input) ?? input.deviceSentMessage?.message ?? input.documentWithCaptionMessage?.message ?? editedWrapperMessage(input);
   return nested ? unwrapZapoMessageContent(nested) : input;
 }
+function editedWrapperMessage(input) {
+  const edited = input.editedMessage;
+  return edited?.message ?? void 0;
+}
 function viewOnceV2ExtensionMessage(input) {
   const extension = input.viewOnceMessageV2Extension;
   return extension?.message ?? void 0;
@@ -2710,6 +2714,7 @@ var ZapoProvider = class {
   #messageKeyStore = /* @__PURE__ */ new WeakMap();
   #deliveredMessageStore = /* @__PURE__ */ new Set();
   #handledProtocolStore = /* @__PURE__ */ new Set();
+  #callCreatorStore = /* @__PURE__ */ new Map();
   #messageCacheSize;
   #client;
   #intentionalClose = false;
@@ -2965,9 +2970,26 @@ var ZapoProvider = class {
     const presence = this.#requireClient().presence;
     await presence.sendChatstate(chatId, { state: value });
   }
-  async rejectCall(callId, _from) {
+  async rejectCall(callId, from) {
     const client = this.#requireClient();
-    await client.voip.rejectCall(callId);
+    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;
@@ -2996,8 +3018,6 @@ var ZapoProvider = class {
         messageSecret: "sqlite"
       }
     });
-    const { voipPlugin } = await import("@zapo-js/voip");
-    const voip = voipPlugin({ logLevel: "warn" });
     const client = new WaClient({
       store,
       sessionId: this.#options.sessionId ?? "default",
@@ -3009,8 +3029,7 @@ var ZapoProvider = class {
         autoDecrypt: true,
         persistAllSecrets: true
       },
-      media: { processor: createMediaProcessor() },
-      plugins: [voip]
+      media: { processor: createMediaProcessor() }
     }, new WhaNextZapoLogger(this.#logger));
     this.#client = client;
     this.#bind(client);
@@ -3027,6 +3046,14 @@ var ZapoProvider = class {
       this.#pairingRequired = false;
     });
     client.on("message", (event) => {
+      const protocol = this.#protocolMessage(event);
+      if (protocol && this.#isMessageMutationProtocol(protocol.type)) {
+        this.#handleProtocolEvent({
+          ...event,
+          protocolMessage: protocol
+        });
+        return;
+      }
       this.#handleMessage(event);
     });
     client.on("message_send", (event) => {
@@ -3050,22 +3077,8 @@ var ZapoProvider = class {
     client.on("group", (event) => {
       this.#handleGroupEvent(event);
     });
-    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)
-      );
+    client.on("call", (event) => {
+      const call = this.#normalizeCall(event);
       if (call) void this.#events.emit("call", call);
     });
     client.on("connection", (event) => {
@@ -3108,26 +3121,56 @@ 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);
+    const decrypted = this.#addonRecord(event.decrypted);
+    const protocol = this.#addonProtocolMessage(decrypted);
+    const kind = event.kind ?? this.#stringField(decrypted, "kind") ?? this.#stringField(decrypted, "type");
+    const isEdit = kind === "message_edit" || protocol?.type === proto.Message.ProtocolMessage.Type.MESSAGE_EDIT;
+    if (!isEdit) return;
+    const targetMessageId = event.targetMessageId ?? this.#stringField(decrypted, "targetMessageId") ?? this.#stringField(decrypted, "targetMessageID") ?? protocol?.key?.id ?? void 0;
+    if (!targetMessageId) return;
+    const editedMessage = protocol?.editedMessage ?? this.#addonEditedMessage(event.decrypted);
     if (!editedMessage) return;
+    const protocolKey = protocol?.key;
     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 } : {}
+      ...protocolKey ?? {},
+      id: targetMessageId,
+      ...protocolKey?.remoteJid !== void 0 ? { remoteJid: protocolKey.remoteJid } : event.key.remoteJid !== void 0 ? { remoteJid: event.key.remoteJid } : {},
+      ...protocolKey?.fromMe !== void 0 ? { fromMe: protocolKey.fromMe } : event.key.fromMe !== void 0 ? { fromMe: event.key.fromMe } : {},
+      ...protocolKey?.participant !== void 0 ? { participant: protocolKey.participant } : event.key.participant !== void 0 ? { participant: event.key.participant } : {},
+      ...protocolKey?.participantAlt !== void 0 ? { participantAlt: protocolKey.participantAlt } : event.key.participantAlt !== void 0 ? { participantAlt: event.key.participantAlt } : {}
     };
     this.#handleProtocolEvent({
       key: event.key,
-      ...event.offline !== void 0 ? { offline: event.offline } : {},
+      ...event.timestampSeconds !== void 0 ? { timestampSeconds: event.timestampSeconds } : {},
       protocolMessage: {
         type: proto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
         key: target,
-        editedMessage
+        editedMessage,
+        ...protocol?.timestampMs !== void 0 ? { timestampMs: protocol.timestampMs } : {}
       }
     });
   }
+  #addonRecord(value) {
+    return value && typeof value === "object" ? value : void 0;
+  }
+  #stringField(record, field) {
+    const value = record?.[field];
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  }
+  #addonProtocolMessage(record) {
+    const direct = record?.protocolMessage;
+    if (direct && typeof direct === "object") {
+      return direct;
+    }
+    const message = record?.message;
+    if (message && typeof message === "object") {
+      const nested = message.protocolMessage;
+      if (nested && typeof nested === "object") {
+        return nested;
+      }
+    }
+    return void 0;
+  }
   #addonEditedMessage(value) {
     if (!value || typeof value !== "object") return void 0;
     const record = value;
@@ -3137,24 +3180,57 @@ var ZapoProvider = class {
       if (edited2 && typeof edited2 === "object") return edited2;
     }
     const edited = record.editedMessage;
-    if (edited && typeof edited === "object") return edited;
+    if (edited && typeof edited === "object") {
+      const nested = edited.message;
+      return nested && typeof nested === "object" ? nested : edited;
+    }
     const message = record.message;
-    if (message && typeof message === "object") return message;
+    if (message && typeof message === "object") {
+      const messageRecord = message;
+      const nestedEdited = messageRecord.editedMessage;
+      if (nestedEdited && typeof nestedEdited === "object") {
+        const nested = nestedEdited.message;
+        if (nested && typeof nested === "object") return nested;
+      }
+      return message;
+    }
     return value;
   }
+  #protocolMessage(event) {
+    if (event.protocolMessage) return event.protocolMessage;
+    const content = unwrapZapoMessageContent(event.message);
+    return content?.protocolMessage;
+  }
+  #isMessageMutationProtocol(type) {
+    return type === proto.Message.ProtocolMessage.Type.REVOKE || type === proto.Message.ProtocolMessage.Type.MESSAGE_EDIT;
+  }
+  #shouldIgnoreProtocolEvent(event) {
+    if (this.#options.processOfflineMessages === true) return false;
+    if (!this.#connected) return true;
+    if (!this.#connectedAtSeconds || event.timestampSeconds == null) return false;
+    const timestamp = toSeconds(event.timestampSeconds);
+    if (timestamp === void 0) return false;
+    return timestamp < this.#connectedAtSeconds - 3;
+  }
   #handleProtocolEvent(event) {
-    if (this.#isOfflineMessage(event)) {
-      this.#logger.debug("Ignored protocol event queued before the current live connection.", {
+    if (this.#shouldIgnoreProtocolEvent(event)) {
+      this.#logger.debug("Ignored protocol mutation from 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 protocol = this.#protocolMessage(event);
+    if (!protocol || !this.#isMessageMutationProtocol(protocol.type)) return;
     const protocolKey = protocol.key;
-    if (!protocolKey?.id) return;
+    if (!protocolKey?.id) {
+      this.#logger.debug("Ignored Zapo protocol mutation without a target message id.", {
+        messageId: event.key.id ?? void 0,
+        protocolType: protocol.type ?? void 0
+      });
+      return;
+    }
     const remoteJid = protocolKey.remoteJid ?? event.key.remoteJid;
     const participant = protocolKey.participant ?? event.key.participant;
     const participantAlt = protocolKey.participantAlt ?? event.key.participantAlt;
@@ -3164,9 +3240,10 @@ var ZapoProvider = class {
       ...participant !== void 0 ? { participant } : {},
       ...participantAlt !== void 0 ? { participantAlt } : {}
     };
-    if (!target.remoteJid) return;
     const stored = this.#findStoredMessage(target);
-    const type = protocol?.type;
+    if (!target.remoteJid && stored?.key.remoteJid) target.remoteJid = stored.key.remoteJid;
+    if (!target.remoteJid) return;
+    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.", {
@@ -3180,6 +3257,12 @@ var ZapoProvider = class {
       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);
+      if (!previous2) {
+        this.#logger.debug("Zapo revoke target was not present in the recent message cache.", {
+          targetMessageId: target.id ?? void 0,
+          chatId: target.remoteJid ?? void 0
+        });
+      }
       void this.#events.emit("messageDeleted", {
         key: previous2?.keys ?? normalizeZapoKey(target),
         ...previous2 ? { message: previous2 } : {},
@@ -3189,9 +3272,8 @@ var ZapoProvider = class {
       });
       return;
     }
-    if (type !== proto.Message.ProtocolMessage.Type.MESSAGE_EDIT || !protocol.editedMessage) {
-      return;
-    }
+    const editedContent = protocol.editedMessage ? this.#unwrapEditedContent(protocol.editedMessage) : void 0;
+    if (!editedContent) return;
     const pushName = event.pushName ?? stored?.pushName;
     const edited = {
       ...stored ?? {},
@@ -3199,7 +3281,7 @@ var ZapoProvider = class {
         ...stored?.key ?? {},
         ...target
       },
-      message: protocol.editedMessage,
+      message: editedContent,
       timestampSeconds: toSeconds(protocol.timestampMs) ?? event.timestampSeconds ?? stored?.timestampSeconds ?? Math.floor(Date.now() / 1e3),
       ...pushName !== void 0 ? { pushName } : {}
     };
@@ -3210,6 +3292,12 @@ var ZapoProvider = class {
     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);
+    if (!previous) {
+      this.#logger.debug("Zapo edit target was not present in the recent message cache.", {
+        targetMessageId: target.id ?? void 0,
+        chatId: target.remoteJid ?? void 0
+      });
+    }
     void this.#events.emit("messageEdited", {
       key: message.keys,
       ...previous ? { previous } : {},
@@ -3219,6 +3307,10 @@ var ZapoProvider = class {
       editedAt: message.timestamp
     });
   }
+  #unwrapEditedContent(message) {
+    const wrapper = message.editedMessage;
+    return wrapper?.message ?? message;
+  }
   #handleGroupEvent(event) {
     const groupId = event.groupJid;
     if (!groupId) return;
@@ -3571,49 +3663,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";
@@ -3773,6 +3865,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;