@whanext/core 0.19.4 → 0.19.5

package/CHANGELOG.md

@@ -1,8 +1,17 @@
 # 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
-- 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.

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;
@@ -3042,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) => {
@@ -3109,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;
@@ -3138,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;
@@ -3165,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.", {
@@ -3181,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 } : {},
@@ -3190,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 ?? {},
@@ -3200,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 } : {}
     };
@@ -3211,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 } : {},
@@ -3220,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;