whalibmob 5.29.2 → 5.29.3

package/README.md

@@ -2473,6 +2473,7 @@ Run it once, type the code into the phone, and it is linked. Run it again and it
 | `client.connectWeb(phone, opts?)` | Open the companion connection. Resolves as soon as the encrypted channel is up when unlinked, or after `<success>` when already linked. |
 | `client.requestPairingCode(phone?, customCode?)` | Ask for an 8-character code. Returns it immediately; the link completes later. Throws if the session is already linked. |
 | `client.disconnect()` | Close the connection. The link survives — reconnect with `connectWeb()`. |
+| `client.logout()` | Unlink this device from the account, the way the Linked Devices screen does, then disconnect. The link does **not** survive — the next `connectWeb()` pairs afresh. Nothing on disk is deleted; remove the session directory yourself if you want the keys gone. |
 
 `connectWeb(phone, opts)` options:
 
@@ -3778,13 +3779,36 @@ The whole message object is accepted as well as its `decoded` half, so
 
 **Verifying the file**
 
-Pass `{ verify: true }` to check the download against the message's
-`fileEncSha256` before decrypting it. The MAC already proves the plaintext was
-not tampered with; this catches a truncated or substituted download earlier, and
-names that failure separately from a decryption one.
+Three things are checked, and all three by default — the message says what the
+file should be, so there is no reason to take the CDN's word for it:
+
+| check | what it covers |
+|---|---|
+| `fileEncSha256` | the blob as it arrived, before any work is spent decrypting it |
+| the MAC | the ciphertext, under a key derived from `mediaKey` — this is the one that authenticates |
+| `fileSha256` | the decrypted file |
+
+```js
+const bytes = await client.downloadMedia(d)                    // all three
+const raw   = await client.downloadMedia(d, { verify: false }) // MAC only
+```
+
+`verify: false` skips the two digests for a caller that wants the bytes whatever
+they are. The MAC is checked either way and is never optional.
+
+**Link preview thumbnails**
+
+A text message that quoted a link carries the preview the sender's client built.
+The small inline image is already on the message as `jpegThumbnail` and needs no
+download. The full-size one is a media file of its own — its own `directPath`,
+its own `mediaKey`, encrypted under a key name of its own — so `downloadMedia`
+cannot reach it:
 
 ```js
-const bytes = await client.downloadMedia(d, { verify: true })
+if (d.thumbnail) {
+  const preview = await client.downloadThumbnail(d)
+  // d.title, d.description and d.matchedText are the rest of the preview
+}
 ```
 
 **What happens underneath**
@@ -3991,10 +4015,36 @@ const { id, encKey } = await client.sendPoll(
   ['JavaScript', 'Python', 'Rust'],
   1            // voters may pick 1 option (0 = unlimited)
 )
-// encKey (32-byte Buffer) is needed to decrypt incoming poll votes
+// encKey (32-byte Buffer) is what reads the votes — keep it
 // (also returned as `messageSecret`, which is the name the protocol uses)
 ```
 
+**Reading the votes**
+
+A vote arrives as its own message and the ballot inside it is encrypted, so
+nothing about who chose what is visible in the stanza. `decryptPollVote()` opens
+it with the poll's `encKey`:
+
+```js
+const options = ['JavaScript', 'Python', 'Rust']
+
+client.on('message', (msg) => {
+  if (msg.decoded?.type !== 'pollVote') return
+  if (msg.decoded.pollKey.id !== id) return      // a vote on some other poll
+
+  const { selected, votedAt } = client.decryptPollVote(msg, { encKey, options })
+  console.log(msg.participant, 'voted for', selected)   // [ 'Rust' ]
+})
+```
+
+Pass `options` and the choices come back as text. Without them you get
+`selectedHashes` — the SHA-256 of each chosen option, which is how the ballot
+names them on the wire — and match them yourself.
+
+The key is derived from the poll id, the poll's sender and the voter, so a vote
+on someone else's poll needs their `encKey`, which only arrives if they sent the
+poll to you: read it off `msg.decoded.encKey` on the poll message itself.
+
 ### Quoted Reply
 
 Send a text message that quotes (replies to) a specific earlier message. The recipient sees the original message highlighted above your reply.

package/index.d.ts

@@ -271,6 +271,11 @@ export interface DecodedBase {
   ephemeral?: boolean;
   /** The message is the new text of an edit. */
   edited?: boolean;
+  /**
+   * On a text message that quoted a link, the downloadable preview image.
+   * Fetch it with `downloadThumbnail()`.
+   */
+  thumbnail?: LinkThumbnail;
   /**
    * Present only on a message this account sent from one of its other devices.
    * The stanza names us as the sender, so the chat it belongs to is written
@@ -280,6 +285,34 @@ export interface DecodedBase {
   [key: string]: any;
 }
 
+/** The downloadable preview image on a message that quoted a link. */
+export interface LinkThumbnail {
+  directPath: string;
+  mediaKey: Buffer;
+  thumbnailSha256: Buffer | null;
+  thumbnailEncSha256: Buffer | null;
+}
+
+export interface PollVoteOptions {
+  /** The poll's 32-byte message secret — what `sendPoll` returned. */
+  encKey: Buffer;
+  /** Who cast the vote. Defaults to the message's `participant`, then `from`. */
+  voter?: Jid;
+  /** Who sent the poll. Defaults to what the vote's message key names. */
+  pollSender?: Jid;
+  /** The poll's options, so the choices come back as text rather than hashes. */
+  options?: string[];
+}
+
+export interface PollVoteResult {
+  /** The chosen options as text. Empty unless `options` was passed. */
+  selected: string[];
+  /** SHA-256 of each chosen option, always present. */
+  selectedHashes: Buffer[];
+  /** When the vote was cast, in ms, when the sender said. */
+  votedAt: number | null;
+}
+
 /** What a `DeviceSentMessage` envelope said about the message inside it. */
 export interface DeviceSentMeta {
   /** The chat the message was originally addressed to. */
@@ -856,6 +889,15 @@ export declare class WhalibmobClient extends EventEmitter {
   /** Ask for an 8-character pairing code. Throws if the session is already linked. */
   requestPairingCode(phoneNumber?: string, customCode?: string): Promise<string>;
   disconnect(opts?: DisconnectOptions): void;
+  /**
+   * Unlink this device from the account, the way the Linked Devices screen on
+   * the phone does, then close the connection.
+   *
+   * Web only. Nothing on disk is deleted — the session it describes no longer
+   * exists, so the next `connectWeb()` pairs afresh. Resolves to whether the
+   * server accepted the removal; the connection drops either way.
+   */
+  logout(): Promise<boolean>;
 
   /** Ask the server whether this session still logs in, and under which number. */
   checkSessionAlive(): Promise<SessionAliveProbe>;
@@ -882,8 +924,30 @@ export declare class WhalibmobClient extends EventEmitter {
   createCallLink(type?: 'audio' | 'video', opts?: { startTime?: number }): Promise<CallLink>;
 
   // ─── Receiving ───────────────────────────────────────────────────────────
-  /** Download and decrypt a media message. Accepts `msg` or `msg.decoded`. */
+  /**
+   * Download and decrypt a media message. Accepts `msg` or `msg.decoded`.
+   *
+   * Both digests the message carried are checked by default, on top of the MAC
+   * that always is. `verify: false` skips the digests only.
+   */
   downloadMedia(decoded: DecodedMessage | IncomingMessage, opts?: { verify?: boolean }): Promise<Buffer>;
+  /**
+   * Download the full-size preview image of a message that quoted a link.
+   *
+   * A link preview's thumbnail is a media file of its own, encrypted under its
+   * own key name, so `downloadMedia` cannot reach it. The small inline preview
+   * needs no download — it is already on the message as `jpegThumbnail`.
+   */
+  downloadThumbnail(decoded: DecodedMessage | IncomingMessage, opts?: { verify?: boolean }): Promise<Buffer>;
+  /**
+   * Read a vote on a poll.
+   *
+   * The ballot is encrypted under a key derived from the poll's message secret:
+   * the `encKey` `sendPoll` returned, or `decoded.encKey` on a poll somebody
+   * else sent. Pass the poll's `options` to get the choices back as text —
+   * without them only the SHA-256 of each choice is available.
+   */
+  decryptPollVote(vote: DecodedMessage | IncomingMessage, opts: PollVoteOptions): PollVoteResult;
   /** Ask the sender's phone to re-upload a file the CDN no longer has. */
   requestMediaRetry(info: { id: string; chatJid: Jid; fromMe: boolean; participant?: Jid }, mediaKey: Buffer): Promise<void>;
   decryptMediaRetry(notification: MediaRetryNotification, mediaKey: Buffer): MediaRetryResult;
@@ -980,6 +1044,15 @@ export declare class WhalibmobClient extends EventEmitter {
 
   /** Pull pins/archives/mutes/stars/contact names changed elsewhere. */
   syncAppState(names?: string[] | null, opts?: { snapshot?: boolean }): Promise<AppStateSyncResult>;
+  /**
+   * Acknowledge a dirty bit so the server stops announcing it.
+   *
+   * Done for you on every `<ib><dirty>` the server sends; this is here for a
+   * bit you want to clear yourself. Pass the `timestamp` the announcement
+   * carried — without it nothing in particular is acknowledged and the server
+   * re-announces on the next connection.
+   */
+  markNotDirty(type: string, timestamp?: number | string): boolean;
   /** Whether an app-state key is available — `false` on an SMS session with no companion. */
   canSyncAppState(): boolean;
   /**

package/lib/Client.js

@@ -1898,8 +1898,18 @@ class WhalibmobClient extends EventEmitter {
     const dirtyTypes = [];
     for (const child of children) {
       if (!child || child.description !== 'dirty') continue;
-      const type = child.attrs && child.attrs.type;
-      if (type) dirtyTypes.push(type);
+      const attrs = child.attrs || {};
+      if (!attrs.type) continue;
+      // The announcement carries the moment the change happened, and clearing
+      // the bit means naming that moment back. A <clean> without it does not
+      // acknowledge anything in particular, so the server keeps announcing the
+      // same change on every connection from now on — which is what it did:
+      // the timestamp was on the wire and never read off it. whatsmeow's
+      // MarkNotDirty takes it as an argument for exactly this reason.
+      dirtyTypes.push({
+        type:      String(attrs.type),
+        timestamp: attrs.timestamp ? String(attrs.timestamp) : null
+      });
     }
 
     if (dirtyTypes.length > 0) {
@@ -1922,15 +1932,23 @@ class WhalibmobClient extends EventEmitter {
   /**
    * Acknowledge a dirty bit so the server stops announcing it.
    *
-   * `<ib><dirty type="..."/></ib>` is the server saying something changed while
-   * we were away. Whatever the client does about it, the bit has to be cleared
-   * or the same announcement arrives on every connection.
+   * `<ib><dirty type="..." timestamp="..."/></ib>` is the server saying
+   * something changed while we were away, and when. Whatever the client does
+   * about it, the bit has to be cleared or the same announcement arrives on
+   * every connection.
+   *
+   * The timestamp is half of that acknowledgement: it says *which* change is
+   * being cleared. Every `<clean>` this sent went out without one, because the
+   * attribute was never read off the `<dirty>` that carried it — so nothing was
+   * acknowledged in particular and the server kept announcing. whatsmeow's
+   * MarkNotDirty takes it as an argument for the same reason.
    *
    * @param {string} type            the dirty type, e.g. 'groups'
    * @param {number|string} [fromTs] the timestamp the announcement carried
+   * @returns {boolean} whether the acknowledgement went out
    */
-  _cleanDirtyBits(type, fromTs) {
-    if (!this._socket || !this._connected) return;
+  markNotDirty(type, fromTs) {
+    if (!this._socket || !this._connected) return false;
     const attrs = { type: String(type) };
     if (fromTs) attrs.timestamp = String(fromTs);
     _whaDbg('[DBG] CLEAN_DIRTY type=' + type + (fromTs ? ' t=' + fromTs : ''));
@@ -1940,6 +1958,7 @@ class WhalibmobClient extends EventEmitter {
       type:  'set',
       xmlns: 'urn:xmpp:whatsapp:dirty'
     }, [new BinaryNode('clean', attrs, null)]));
+    return true;
   }
 
   /**
@@ -1948,7 +1967,7 @@ class WhalibmobClient extends EventEmitter {
    * Best effort on purpose: the bit has to be cleared either way, or the server
    * announces the same change on every connection from now on.
    */
-  _refreshGroupsAfterDirty(type) {
+  _refreshGroupsAfterDirty(type, fromTs) {
     Promise.resolve()
       .then(() => this.fetchAllGroups())
       .then(groups => {
@@ -1957,7 +1976,7 @@ class WhalibmobClient extends EventEmitter {
       .catch(err => {
         _whaDbg('[DBG] DIRTY groups — refresh failed: ' + (err && err.message));
       })
-      .then(() => this._cleanDirtyBits(type));
+      .then(() => this.markNotDirty(type, fromTs));
   }
 
   _sendAppStateSyncForTypes(dirtyTypes) {
@@ -1974,8 +1993,10 @@ class WhalibmobClient extends EventEmitter {
       regular:              ['regular']
     };
 
+    // Each entry is { type, timestamp } — the timestamp is what the
+    // announcement said, and it goes back on the <clean> that acknowledges it.
     const collections = new Set();
-    for (const type of dirtyTypes) {
+    for (const { type, timestamp } of dirtyTypes) {
       const mapped = COLLECTION_MAP[type];
       if (!mapped) {
         if (type === 'groups') {
@@ -1983,14 +2004,14 @@ class WhalibmobClient extends EventEmitter {
           // away. Clearing it without looking leaves every cached group sitting
           // on the membership and settings it had before we disconnected, so
           // re-read them first and acknowledge after.
-          this._refreshGroupsAfterDirty(type);
+          this._refreshGroupsAfterDirty(type, timestamp);
           continue;
         }
         // Not an app-state collection, but still a dirty bit the server expects
         // to be cleared. Ignoring it meant the server re-announced it on every
         // single connection, forever.
         _whaDbg('[DBG] DIRTY type=' + type + ' — not an app-state collection, clearing the bit');
-        this._cleanDirtyBits(type);
+        this.markNotDirty(type, timestamp);
         continue;
       }
       for (const c of mapped) collections.add(c);
@@ -2003,8 +2024,8 @@ class WhalibmobClient extends EventEmitter {
     // session that registered its own number — would otherwise leave it set
     // forever and be told about the same change on every single connection.
     const clearAll = () => {
-      for (const type of dirtyTypes) {
-        if (COLLECTION_MAP[type]) this._cleanDirtyBits(type);
+      for (const { type, timestamp } of dirtyTypes) {
+        if (COLLECTION_MAP[type]) this.markNotDirty(type, timestamp);
       }
     };
 
@@ -3960,26 +3981,28 @@ class WhalibmobClient extends EventEmitter {
       // hash, and if it matches there is nothing to invalidate and nothing to
       // ask usync about — see DeviceManager.verifyDeviceDelta().
       if (fromUser && this._devMgr) {
-        const delta = this._parseDeviceDelta(node);
-        if (delta) {
+        const steps = this._parseDeviceDelta(node);
+        if (steps) {
           // The primary half is keyed the way the notification is addressed.
-          const priKey    = isLid ? 'lid:' + fromUser : fromUser;
-          const priServer = isLid ? 'lid' : 's.whatsapp.net';
-          const priOk     = this._devMgr.verifyDeviceDelta(
-            priKey, fromUser, delta.changes, delta.hash, priServer);
-
           // The secondary half only exists when the notification arrived under
           // the number and named the LID alongside it.
-          if (!isLid && lidUser && delta.lidHash && delta.lidChanges) {
-            const lidOk = this._devMgr.verifyDeviceDelta(
-              'lid:' + lidUser, lidUser, delta.lidChanges, delta.lidHash, 'lid');
+          const { primaryOk, lidOk } = this._devMgr.applyDeviceDelta({
+            priKey:    isLid ? 'lid:' + fromUser : fromUser,
+            priUser:   fromUser,
+            priServer: isLid ? 'lid' : 's.whatsapp.net',
+            lidKey:    (!isLid && lidUser) ? 'lid:' + lidUser : null,
+            lidUser:   (!isLid && lidUser) ? lidUser : null,
+            steps
+          });
+
+          if (!isLid && lidUser) {
             _whaDbg('[DBG] NOTIF_DEVICES lid delta ' +
               (lidOk ? 'verified' : 'unverified') + ' for lid:' + lidUser);
           }
 
-          if (priOk) {
-            _whaDbg('[DBG] NOTIF_DEVICES delta verified for ' + priKey +
-              ' — cache kept, no usync needed');
+          if (primaryOk) {
+            _whaDbg('[DBG] NOTIF_DEVICES delta verified over ' + steps.length +
+              ' step(s) — cache kept, no usync needed');
             return;
           }
         }
@@ -4037,39 +4060,44 @@ class WhalibmobClient extends EventEmitter {
   }
 
   /**
-   * Read a `devices` notification as a change plus the hash it should produce.
+   * Read a `devices` notification as an ordered list of steps.
    *
    *   <notification type="devices" from="…">
    *     <add device_hash="2:…"><device jid="40711111111:3@s.whatsapp.net"/></add>
+   *     <add device_hash="2:…"><device jid="40711111111:4@s.whatsapp.net"/></add>
    *   </notification>
    *
-   * Children are `add`, `remove`, or `update`. Only the first two say something
-   * that can be applied; `update` does not name what it changed, so it is
-   * treated as unreadable here and the caller falls back to invalidating.
+   * Each child is one change, and the `device_hash` on it is the hash of the
+   * device list **after that change** — not of the notification as a whole. So
+   * children in a multi-change notification carry different hashes, by design,
+   * and each has to be checked against the list as it stands at that point.
+   *
+   * This used to demand that every child agree on one hash and give up when
+   * they did not, which is exactly what a two-change notification looks like:
+   * someone linking a laptop and a tablet in the same sitting produced two
+   * children, two hashes, and the whole thing was thrown away — cache dropped,
+   * full usync round-trip on the next send. Steps are now kept separately and
+   * applied one at a time, the way whatsmeow's handleDeviceNotification does.
    *
-   * All children must agree on the hash — the server sends one per child, and a
-   * notification carrying two different ones is describing intermediate states
-   * this cannot reconstruct.
+   * Children are `add`, `remove`, or `update`. `update` does not name what it
+   * changed, so it survives as a step that tells the applier to drop the cache
+   * and carry on with the rest. A tag this does not know is skipped, and a
+   * child that cannot be read at all rejects the notification: guessing at a
+   * change we could not parse is how a device list quietly goes wrong.
    *
-   * Each child may also carry `device_lid_hash`, and each `<device>` a `lid`
-   * beside its `jid`, describing the same change to the contact's LID device
-   * list. That half is optional: missing on any child, and only the phone-number
-   * half is returned, which is what the caller then verifies. It is never a
-   * reason to reject the notification outright — the two lists are hashed
-   * independently by the server and are checked independently here.
+   * Each child may also carry `device_lid_hash`, and its `<device>` a `lid`
+   * beside the `jid`, describing the same change to the contact's LID device
+   * list. That half is per-step and optional — a step without it leaves the LID
+   * list alone rather than invalidating the step, because the server hashes the
+   * two lists independently and they are checked independently here.
    *
-   * @returns {{changes: Array<{tag, deviceId}>, hash: string,
-   *            lidChanges: Array<{tag, deviceId}>|null, lidHash: string|null}|null}
+   * @returns {Array<{tag: 'add'|'remove'|'update', deviceId: number|null,
+   *                  hash: string|null, lidDeviceId: number|null,
+   *                  lidHash: string|null}>|null}
    */
   _parseDeviceDelta(node) {
     if (!node || !Array.isArray(node.content)) return null;
 
-    const changes    = [];
-    const lidChanges = [];
-    let hash    = null;
-    let lidHash = null;
-    let lidOk   = true;   // every child so far carried a usable LID half
-
     // "user:3@server" / "user@server" → 3 / 0, or null when unreadable.
     const deviceIdOf = (jid) => {
       if (!jid) return null;
@@ -4080,40 +4108,43 @@ class WhalibmobClient extends EventEmitter {
       return Number.isFinite(device) ? device : null;
     };
 
+    const steps = [];
+
     for (const child of node.content) {
       if (!child || !child.description) continue;
       const tag = child.description;
-      if (tag !== 'add' && tag !== 'remove') return null;   // 'update' and friends
 
-      const childHash = child.attrs && child.attrs.device_hash;
-      if (!childHash) return null;
-      if (hash === null) hash = String(childHash);
-      else if (hash !== String(childHash)) return null;     // disagreeing children
+      if (tag === 'update') {
+        steps.push({ tag, deviceId: null, hash: null, lidDeviceId: null, lidHash: null });
+        continue;
+      }
+      if (tag !== 'add' && tag !== 'remove') continue;   // not ours to interpret
+
+      const attrs = child.attrs || {};
+      const hash  = attrs.device_hash ? String(attrs.device_hash) : null;
+      if (!hash) return null;
 
       const deviceNode = findChild(child, 'device');
-      const attrs      = (deviceNode && deviceNode.attrs) || {};
-      const device     = deviceIdOf(attrs.jid);
-      if (device === null) return null;
-      changes.push({ tag, deviceId: device });
-
-      // LID half — optional, and giving up on it costs the number half nothing.
-      if (!lidOk) continue;
-      const childLidHash = child.attrs.device_lid_hash;
-      const lidDevice    = deviceIdOf(attrs.lid);
-      if (!childLidHash || lidDevice === null) { lidOk = false; continue; }
-      if (lidHash === null) lidHash = String(childLidHash);
-      else if (lidHash !== String(childLidHash)) { lidOk = false; continue; }
-      lidChanges.push({ tag, deviceId: lidDevice });
-    }
-
-    if (!changes.length || !hash) return null;
-    const haveLid = lidOk && lidHash && lidChanges.length === changes.length;
-    return {
-      changes,
-      hash,
-      lidChanges: haveLid ? lidChanges : null,
-      lidHash:    haveLid ? lidHash    : null
-    };
+      const dattrs     = (deviceNode && deviceNode.attrs) || {};
+      const deviceId   = deviceIdOf(dattrs.jid);
+      if (deviceId === null) return null;
+
+      // Both halves of the LID pair or neither: a hash with no device to apply
+      // it to, or a device with no hash to check it against, is not a step.
+      const lidHash     = attrs.device_lid_hash ? String(attrs.device_lid_hash) : null;
+      const lidDeviceId = deviceIdOf(dattrs.lid);
+      const haveLid     = !!lidHash && lidDeviceId !== null;
+
+      steps.push({
+        tag,
+        deviceId,
+        hash,
+        lidDeviceId: haveLid ? lidDeviceId : null,
+        lidHash:     haveLid ? lidHash     : null
+      });
+    }
+
+    return steps.length ? steps : null;
   }
 
   _processDeviceUpdate(devicesNode) {
@@ -6285,9 +6316,59 @@ class WhalibmobClient extends EventEmitter {
     const keyName = getMediaKeyName(KEY_NAME[d.type] || d.type);
     if (!keyName) throw new Error('downloadMedia: unsupported media type "' + d.type + '"');
 
+    // Both digests go down by default. The message says what the file should
+    // be; there is no reason to take the CDN's word for it. `verify: false`
+    // turns them off for a caller that wants the bytes whatever they are — the
+    // MAC is checked either way, and that is the one that authenticates.
     return downloadMedia(url, d.mediaKey, keyName, {
       web:           this._mode === 'web',
-      fileEncSha256: opts.verify ? d.fileEncSha256 : undefined
+      verify:        opts.verify !== false,
+      fileEncSha256: d.fileEncSha256,
+      fileSha256:    d.fileSha256
+    });
+  }
+
+  /**
+   * Download the preview image of a message that quoted a link.
+   *
+   * A link preview's thumbnail is a media file in its own right — its own
+   * directPath, its own mediaKey, its own digests — carried beside the text
+   * rather than inside it, and encrypted under a key name of its own. So
+   * `downloadMedia` cannot fetch it: that reads the message's own media, and a
+   * text message has none. This is whatsmeow's DownloadThumbnail.
+   *
+   * The small inline preview is a different thing and needs no download: it is
+   * already on the decoded message as `jpegThumbnail`.
+   *
+   * @param {object} decoded  a decoded message, or the `message` event payload
+   * @param {object} [opts]   `verify: false` to skip the digest checks
+   * @returns {Promise<Buffer>} the full-size preview image
+   */
+  async downloadThumbnail(decoded, opts) {
+    opts = opts || {};
+    const d = (decoded && decoded.decoded) ? decoded.decoded : decoded;
+    if (!d) throw new Error('downloadThumbnail: a decoded message is required');
+
+    const thumb = d.thumbnail;
+    if (!thumb || !thumb.mediaKey) {
+      throw new Error('downloadThumbnail: this message carries no downloadable ' +
+        'thumbnail (a link preview without one, or not a link at all)');
+    }
+
+    const { downloadMedia, getThumbnailKeyName, resolveMediaUrl } =
+      require('./MediaService');
+    const keyName = getThumbnailKeyName(d.type === 'text' ? 'text' : d.type);
+    if (!keyName) {
+      throw new Error('downloadThumbnail: no thumbnail key name for "' + d.type + '"');
+    }
+    const url = resolveMediaUrl(null, thumb.directPath);
+    if (!url) throw new Error('downloadThumbnail: the thumbnail has no CDN location');
+
+    return downloadMedia(url, thumb.mediaKey, keyName, {
+      web:           this._mode === 'web',
+      verify:        opts.verify !== false,
+      fileEncSha256: thumb.thumbnailEncSha256,
+      fileSha256:    thumb.thumbnailSha256
     });
   }
 
@@ -7290,6 +7371,169 @@ class WhalibmobClient extends EventEmitter {
     return this._sender.sendPoll(to, question, options, selectableCount, opts);
   }
 
+  /**
+   * Read a vote on a poll.
+   *
+   * A vote arrives as its own message and the ballot inside it is encrypted, so
+   * nothing about who voted for what is visible in the stanza. The key is
+   * derived from the poll's message secret — the `encKey` `sendPoll` returned,
+   * or `decoded.encKey` on a poll somebody else sent us:
+   *
+   *   key = HKDF-SHA256(secret, salt = ∅,
+   *                     info = pollId ‖ pollSender ‖ voter ‖ "Poll Vote", 32)
+   *   AAD = pollId ‖ 0x00 ‖ voter
+   *   ballot = AES-256-GCM-open(key, encIv, encPayload, AAD)
+   *
+   * The ballot names the chosen options by SHA-256 of their text, not by index
+   * or by name, so pass `options` — the poll's option strings, in any order —
+   * and the choices come back as text. Without them you get the hashes and can
+   * match them yourself.
+   *
+   * Both JIDs are taken without their device: a vote belongs to an account.
+   *
+   * This is whatsmeow's DecryptPollVote. Nothing here could read a vote before:
+   * `sendPoll` handed back the key and left the rest to the caller.
+   *
+   * @param {object} vote            the `message` event payload, or its `decoded`
+   * @param {object} opts
+   * @param {Buffer} opts.encKey     the poll's message secret (aka messageSecret)
+   * @param {string} [opts.voter]    who voted; defaults to the message's sender
+   * @param {string} [opts.pollSender] who sent the poll; defaults to the key's
+   *                                 remoteJid, or to the voter when the poll is
+   *                                 ours
+   * @param {string[]} [opts.options] the poll's options, to name the choices
+   * @returns {{selected: string[], selectedHashes: Buffer[], votedAt: number|null}}
+   */
+  decryptPollVote(vote, opts) {
+    opts = opts || {};
+    const d = (vote && vote.decoded) ? vote.decoded : vote;
+    if (!d || d.type !== 'pollVote') {
+      throw new Error('decryptPollVote: this is not a vote on a poll');
+    }
+    if (!d.encPayload || !d.encIv) {
+      throw new Error('decryptPollVote: the vote carries no encrypted ballot');
+    }
+    const secret = opts.encKey || opts.messageSecret;
+    if (!secret || secret.length !== 32) {
+      throw new Error('decryptPollVote: the poll\'s 32-byte encKey is required — ' +
+        'it is what sendPoll returned, or decoded.encKey on a poll we received');
+    }
+
+    const key    = d.pollKey || {};
+    const pollId = String(key.id || '');
+    if (!pollId) throw new Error('decryptPollVote: the vote does not name a poll');
+
+    // Who voted, and who the poll belongs to. `fromMe` on the key means the
+    // poll and the vote came from the same account, which is the one case the
+    // key's remoteJid names the chat rather than the poll's author.
+    const voter = toNonAdJid(String(
+      opts.voter || (vote && vote.participant) || (vote && vote.from) || ''));
+    if (!voter || voter.startsWith('@')) {
+      throw new Error('decryptPollVote: cannot tell who cast this vote — pass opts.voter');
+    }
+    const pollSender = toNonAdJid(String(
+      opts.pollSender || (key.fromMe ? voter : (key.remoteJid || voter))));
+
+    const info = Buffer.concat([
+      Buffer.from(pollId, 'utf8'),
+      Buffer.from(pollSender, 'utf8'),
+      Buffer.from(voter, 'utf8'),
+      Buffer.from('Poll Vote', 'utf8')
+    ]);
+    const { hkdfSha256 } = require('./hkdf');
+    const voteKey = hkdfSha256(Buffer.from(secret), Buffer.alloc(0), info, 32);
+
+    const aad = Buffer.concat([
+      Buffer.from(pollId, 'utf8'), Buffer.from([0]), Buffer.from(voter, 'utf8')
+    ]);
+
+    // GCM's tag is the last 16 bytes of the payload, as it is everywhere else
+    // in this protocol.
+    const payload    = Buffer.from(d.encPayload);
+    const ciphertext = payload.subarray(0, payload.length - 16);
+    const tag        = payload.subarray(payload.length - 16);
+
+    let plaintext;
+    try {
+      const dec = crypto.createDecipheriv('aes-256-gcm', voteKey, Buffer.from(d.encIv));
+      dec.setAAD(aad);
+      dec.setAuthTag(tag);
+      plaintext = Buffer.concat([dec.update(ciphertext), dec.final()]);
+    } catch (_) {
+      throw new Error('decryptPollVote: the ballot would not open — wrong encKey, ' +
+        'or the wrong voter/pollSender for this poll');
+    }
+
+    // PollVoteMessage { selectedOptions = 1, repeated bytes } — each entry is
+    // the SHA-256 of one option's text.
+    const { decodeFields } = require('./proto/MessageProto');
+    const parsed = decodeFields(plaintext);
+    const raw    = parsed[1] == null ? [] : (Array.isArray(parsed[1]) ? parsed[1] : [parsed[1]]);
+    const selectedHashes = raw.filter(Buffer.isBuffer);
+
+    let selected = [];
+    if (Array.isArray(opts.options) && opts.options.length) {
+      const byHash = new Map(opts.options.map(o => [
+        crypto.createHash('sha256').update(String(o), 'utf8').digest('hex'), String(o)
+      ]));
+      selected = selectedHashes
+        .map(h => byHash.get(h.toString('hex')))
+        .filter(o => o !== undefined);
+    }
+
+    return {
+      selected,
+      selectedHashes,
+      votedAt: d.senderTimestampMs != null ? d.senderTimestampMs : null
+    };
+  }
+
+  /**
+   * Unlink this device from the account.
+   *
+   * The companion asks the server to remove it, the same way the Linked Devices
+   * screen on the phone does, and then closes the connection. Everything on
+   * disk stays where it is — the session it describes no longer exists, so a
+   * later `connectWeb()` pairs afresh rather than trying to resume something
+   * the server has forgotten. Delete the session directory yourself if you want
+   * the keys gone as well.
+   *
+   * Web only: an account that registered its own number is not a companion and
+   * has nothing to unlink from.
+   *
+   * @returns {Promise<boolean>} whether the server accepted the removal
+   */
+  async logout() {
+    if (this._mode !== 'web') {
+      throw new Error('logout: only a companion can unlink itself — a session ' +
+        'that registered its own number has nothing to unlink from');
+    }
+    if (!this._socket || !this._connected) throw new Error('Not connected');
+
+    const ownJid = toNonAdJid(this._ownDeviceJid() || '');
+    if (!ownJid || ownJid.startsWith('@')) throw new Error('logout: not logged in');
+
+    let accepted = false;
+    try {
+      const resp = await this._sendIq(new BinaryNode('iq', {
+        id:    this._genMsgId(),
+        to:    's.whatsapp.net',
+        type:  'set',
+        xmlns: 'md'
+      }, [new BinaryNode('remove-companion-device', {
+        jid:    jidStrToObj(ownJid),
+        reason: 'user_initiated'
+      }, null)]));
+      accepted = !!(resp && !(resp.attrs && resp.attrs.type === 'error'));
+    } finally {
+      // The connection goes either way. A server that refused the removal is
+      // still a server we asked to be forgotten by, and staying connected on
+      // that basis is worse than dropping.
+      this.disconnect();
+    }
+    return accepted;
+  }
+
   // ─── Location ─────────────────────────────────────────────────────────────
   // sendLocation(to, latitude, longitude, opts)
   // opts: { name, address, url, id, contextInfo }

package/lib/DeviceManager.js

@@ -1206,57 +1206,123 @@ class DeviceManager {
    * and sends both hashes on the same notification — so each is verified on its
    * own, and one going wrong does not cost the other.
    *
-   * @param   {string} cacheKey     the cache entry: digits, or 'lid:<user>'
-   * @param   {string} user         the JID user part the ids belong to
-   * @param   {Array<{tag: string, deviceId: number}>} changes
-   * @param   {string} serverHash   device_hash, or device_lid_hash
-   * @param   {string} [server]     's.whatsapp.net' (default) or 'lid'
-   * @returns {boolean} whether the result verified and the cache was kept
+   * The steps are applied one at a time, and each is checked against its own
+   * hash: `device_hash` describes the list **after that change**, not after the
+   * notification as a whole. A contact linking two devices in one sitting sends
+   * two children with two different hashes, and reading them as one change with
+   * one hash — which is what this did — meant the notification could never
+   * verify and the cache was dropped every time. Stepping through them the way
+   * whatsmeow's handleDeviceNotification does keeps the cache across exactly
+   * the case that used to defeat it.
+   *
+   * A step that fails to verify drops the cache but not the running list, so a
+   * later step whose hash does match puts a proven list back — the same
+   * recovery whatsmeow gets from mutating its local copy after deleting the
+   * cached one.
+   *
+   * @param   {object} opts
+   * @param   {string} opts.priKey     the cache entry: digits, or 'lid:<user>'
+   * @param   {string} opts.priUser    the JID user part the ids belong to
+   * @param   {string} [opts.priServer] 's.whatsapp.net' (default) or 'lid'
+   * @param   {string} [opts.lidKey]   cache entry for the LID half, when known
+   * @param   {string} [opts.lidUser]  the LID user part
+   * @param   {Array}  opts.steps      from Client._parseDeviceDelta
+   * @returns {{primaryOk: boolean, lidOk: boolean}} which halves ended verified
    */
-  verifyDeviceDelta(cacheKey, user, changes, serverHash, server) {
-    server = server || 's.whatsapp.net';
-    if (!cacheKey || !user || !serverHash) return false;
-    if (!Array.isArray(changes) || !changes.length) return false;
+  applyDeviceDelta(opts) {
+    opts = opts || {};
+    const priKey    = opts.priKey;
+    const priUser   = opts.priUser;
+    const priServer = opts.priServer || 's.whatsapp.net';
+    const steps     = opts.steps;
+    const out       = { primaryOk: false, lidOk: false };
+
+    if (!priKey || !priUser) return out;
+    if (!Array.isArray(steps) || !steps.length) return out;
 
     // No baseline means there is nothing to apply a change to. Caching just the
     // one device named in the notification would make a list of one look
     // authoritative, which is how a recipient's other devices stop being
     // written to.
-    const cached = this._dcGet(cacheKey);
-    if (!cached || !cached.length) return false;
-
-    const next = new Set(cached);
-    for (const { tag, deviceId } of changes) {
-      if (!Number.isFinite(deviceId)) return false;
-      if (tag === 'add')         next.add(deviceId);
-      else if (tag === 'remove') next.delete(deviceId);
-      else return false;   // 'update' and anything unknown: do not guess
+    const cached = this._dcGet(priKey);
+    if (!cached || !cached.length) return out;
+
+    const haveLid = !!(opts.lidKey && opts.lidUser);
+    const pri = new Set(cached);
+    // The LID half starts from whatever is on file, empty included. It cannot
+    // go wrong the way the primary half could: a list built from nothing has to
+    // pass the server's hash before it is written anywhere.
+    const lid = haveLid ? new Set(this._dcGet(opts.lidKey) || []) : null;
+
+    for (const step of steps) {
+      if (!step) continue;
+
+      // `update` does not say what changed. The list on file cannot be trusted
+      // and cannot be repaired, so it goes — and the remaining steps still get
+      // their turn, as they do in whatsmeow.
+      if (step.tag === 'update') {
+        this._dcDel([priKey]);
+        out.primaryOk = false;
+        _whaDbg('[DBG] DEV_HASH update for ' + priKey + ' — cache dropped');
+        continue;
+      }
+      if (step.tag !== 'add' && step.tag !== 'remove') continue;
+      if (!Number.isFinite(step.deviceId) || !step.hash) continue;
+
+      if (step.tag === 'add') pri.add(step.deviceId);
+      else                    pri.delete(step.deviceId);
+
+      const ids  = [...pri].sort((a, b) => a - b);
+      const ours = this._phashOfDevices(priUser, ids, priServer);
+      if (ours && ours === step.hash) {
+        this._dcSet(priKey, ids);
+        out.primaryOk = true;
+        _whaDbg('[DBG] DEV_HASH verified for ' + priKey + ' ids=[' + ids.join(',') +
+          '] hash=' + ours);
+      } else {
+        this._dcDel([priKey]);
+        out.primaryOk = false;
+        _whaDbg('[DBG] DEV_HASH mismatch for ' + priKey + ' ours=' + ours +
+          ' server=' + step.hash + ' — dropping cache');
+      }
+
+      // The LID half of the same change, checked on its own. The server hashes
+      // the two lists separately and one going wrong does not cost the other.
+      if (!haveLid || step.lidDeviceId === null || !step.lidHash) continue;
+
+      if (step.tag === 'add') lid.add(step.lidDeviceId);
+      else                    lid.delete(step.lidDeviceId);
+
+      const lidIds  = [...lid].sort((a, b) => a - b);
+      const lidOurs = this._phashOfDevices(opts.lidUser, lidIds, 'lid');
+      if (lidOurs && lidOurs === step.lidHash) {
+        this._dcSet(opts.lidKey, lidIds);
+        out.lidOk = true;
+        _whaDbg('[DBG] DEV_HASH verified for ' + opts.lidKey + ' ids=[' +
+          lidIds.join(',') + '] hash=' + lidOurs);
+      } else {
+        this._dcDel([opts.lidKey]);
+        out.lidOk = false;
+        _whaDbg('[DBG] DEV_HASH mismatch for ' + opts.lidKey + ' ours=' + lidOurs +
+          ' server=' + step.lidHash + ' — dropping cache');
+      }
     }
 
-    const ids  = [...next].sort((a, b) => a - b);
-    const jids = ids.map(d => makeDeviceJid(user, d, server));
+    return out;
+  }
 
-    let ours;
+  // The participant hash of one user's device ids, or null when it cannot be
+  // computed. Same function the group fan-out and the server both use, which is
+  // the whole reason the comparison above means anything.
+  _phashOfDevices(user, deviceIds, server) {
     try {
       // Lazily required: MessageSender requires this file, so taking it at the
       // top would close the cycle before either module finishes loading.
       const { computePhash } = require('./messages/MessageSender');
-      ours = computePhash(jids);
+      return computePhash(deviceIds.map(d => makeDeviceJid(user, d, server)));
     } catch (_) {
-      return false;
-    }
-
-    if (ours !== String(serverHash)) {
-      _whaDbg('[DBG] DEV_HASH mismatch for ' + cacheKey + ' ours=' + ours +
-        ' server=' + serverHash + ' — dropping cache');
-      this._dcDel([cacheKey]);
-      return false;
+      return null;
     }
-
-    this._dcSet(cacheKey, ids);
-    _whaDbg('[DBG] DEV_HASH verified for ' + cacheKey + ' ids=[' + ids.join(',') +
-      '] hash=' + ours);
-    return true;
   }
 
   clearCache(phones) {

package/lib/MediaService.js

@@ -229,10 +229,6 @@ function _tryUpload(host, mediaPath, token, auth, encrypted, web) {
   });
 }
 
-// opts.fileEncSha256, when given, is checked against the blob as it arrived.
-// The MAC inside decryptMedia already proves the plaintext was not tampered
-// with, but this catches a truncated or substituted download before spending
-// the work on it, and tells the two failures apart.
 // Where a message's media actually lives. Most carry an absolute `url`, but a
 // message that arrived through history sync often has only the `directPath`,
 // which is that URL with the CDN host taken off the front.
@@ -245,19 +241,72 @@ function resolveMediaUrl(url, directPath) {
   return 'https://' + CDN_HOST + (p.startsWith('/') ? '' : '/') + p;
 }
 
+// Compare a digest against what the message said it should be. Returns null
+// when it matches or when there is nothing to compare against, and the reason
+// when it does not.
+function _digestMismatch(actual, expected, what) {
+  if (!expected || !expected.length) return null;
+  const want = Buffer.from(expected);
+  // timingSafeEqual throws on a length mismatch rather than returning false.
+  if (want.length !== actual.length) return what + ' is the wrong length';
+  return crypto.timingSafeEqual(actual, want) ? null : what + ' mismatch';
+}
+
+/**
+ * Download one media file and decrypt it.
+ *
+ * Three things are checked, and all three are checked by default — the message
+ * says what the file should be, so there is no reason to take the CDN's word
+ * for it:
+ *
+ *   fileEncSha256   the blob as it arrived off the CDN
+ *   the MAC         inside decryptMedia, the one that actually authenticates
+ *   fileSha256      the plaintext, after decrypting
+ *
+ * The MAC is the guarantee — its key comes from the mediaKey, which only the
+ * sender and the recipients hold — and it was always checked. The two digests
+ * were not: fileEncSha256 only when the caller asked for it, and fileSha256
+ * never at all, though it was written on every upload. whatsmeow checks both on
+ * every download (ErrInvalidMediaSHA256), and now so does this.
+ *
+ * They tell failures apart, too. A truncated or substituted download is caught
+ * before any work is spent decrypting it, and a plaintext that decrypts but is
+ * not the file the message described is a different fault from a corrupt blob.
+ *
+ * @param {object} [opts]
+ * @param {Buffer} [opts.fileEncSha256] digest of the encrypted blob
+ * @param {Buffer} [opts.fileSha256]    digest of the decrypted file
+ * @param {boolean} [opts.verify=true]  pass false to skip both digest checks;
+ *                                      the MAC is always checked either way
+ */
 async function downloadMedia(url, mediaKey, keyName, opts) {
+  opts = opts || {};
+  const check     = opts.verify !== false;
   const encrypted = await _httpGet(url, opts);
-  const expected  = opts && opts.fileEncSha256;
-  if (expected && expected.length) {
-    const actual = crypto.createHash('sha256').update(encrypted).digest();
-    const want   = Buffer.from(expected);
-    // timingSafeEqual throws on a length mismatch rather than returning false.
-    if (want.length !== actual.length || !crypto.timingSafeEqual(actual, want)) {
-      throw new Error('downloadMedia: the downloaded file does not match the message ' +
-        '(fileEncSha256 mismatch)');
+
+  if (check) {
+    const bad = _digestMismatch(
+      crypto.createHash('sha256').update(encrypted).digest(),
+      opts.fileEncSha256, 'fileEncSha256');
+    if (bad) {
+      throw new Error('downloadMedia: the downloaded file does not match the ' +
+        'message (' + bad + ')');
+    }
+  }
+
+  const plaintext = decryptMedia(encrypted, Buffer.from(mediaKey), keyName);
+
+  if (check) {
+    const bad = _digestMismatch(
+      crypto.createHash('sha256').update(plaintext).digest(),
+      opts.fileSha256, 'fileSha256');
+    if (bad) {
+      throw new Error('downloadMedia: the decrypted file is not the one the ' +
+        'message described (' + bad + ')');
     }
   }
-  return decryptMedia(encrypted, Buffer.from(mediaKey), keyName);
+
+  return plaintext;
 }
 
 // The CDN applies the same Origin check on the way down as on the way up, so a
@@ -307,11 +356,26 @@ function _httpGet(url, opts, depth) {
   });
 }
 
+// A thumbnail is encrypted under a key name of its own, not under the key name
+// of the message that carries it. The one in use is the link-preview thumbnail
+// on an extendedTextMessage — it has its own directPath and its own digests
+// beside the message's, and reading it with 'WhatsApp Image Keys' produces a
+// MAC failure and nothing else. There is no upload path because nothing here
+// uploads one; they arrive with a link preview the sender built.
+const THUMBNAIL_KEY_NAME = {
+  extendedText: 'WhatsApp Link Thumbnail Keys',
+  text:         'WhatsApp Link Thumbnail Keys'
+};
+
 function getMediaKeyName(mediaType) {
   const typeInfo = MEDIA_PATH[mediaType];
   return typeInfo ? typeInfo.keyName : null;
 }
 
+function getThumbnailKeyName(mediaType) {
+  return THUMBNAIL_KEY_NAME[mediaType] || null;
+}
+
 module.exports = {
   MEDIA_PATH,
   encryptMedia,
@@ -323,5 +387,6 @@ module.exports = {
   httpGetBuffer: _httpGet,
   deriveMediaKeyData,
   getMediaKeyName,
+  getThumbnailKeyName,
   resolveMediaUrl
 };

package/lib/proto/MessageProto.js

@@ -794,11 +794,47 @@ function decodeMessageContainer(buf, depth) {
     }
 
     // Field 6: extendedTextMessage — field 1 = text
+    //
+    // A text message with a link in it comes as one of these, and everything
+    // the sender's client built for the preview rides along: the title and
+    // description it scraped, and a thumbnail. The thumbnail is a media file of
+    // its own — its own directPath, its own digests, its own mediaKey — not a
+    // part of the message, which is why only the inline jpegThumbnail was ever
+    // reachable and the full-size one could not be fetched at all.
+    //
+    //   text=1 matchedText=2 description=5 title=6 jpegThumbnail=16
+    //   thumbnailDirectPath=19 thumbnailSha256=20 thumbnailEncSha256=21
+    //   mediaKey=22
     if (!msgResult && f[6] && Buffer.isBuffer(f[6])) {
       try {
-        const ext = _decodeFields(f[6]);
+        const ext  = _decodeFields(f[6]);
         const text = _str(ext[1]);
-        if (text) msgResult = { type: 'text', text };
+        if (text) {
+          msgResult = { type: 'text', text };
+
+          const matchedText = _str(ext[2]);
+          const description = _str(ext[5]);
+          const title       = _str(ext[6]);
+          if (matchedText) msgResult.matchedText = matchedText;
+          if (description) msgResult.description = description;
+          if (title)       msgResult.title       = title;
+          if (Buffer.isBuffer(ext[16]) && ext[16].length) {
+            msgResult.jpegThumbnail = ext[16];
+          }
+
+          // The downloadable preview image, when the sender attached one. All
+          // four are needed together: without the key it cannot be decrypted,
+          // and without the digests it cannot be checked.
+          const thumbPath = _str(ext[19]);
+          if (thumbPath && Buffer.isBuffer(ext[22]) && ext[22].length) {
+            msgResult.thumbnail = {
+              directPath:        thumbPath,
+              mediaKey:          ext[22],
+              thumbnailSha256:    Buffer.isBuffer(ext[20]) ? ext[20] : null,
+              thumbnailEncSha256: Buffer.isBuffer(ext[21]) ? ext[21] : null
+            };
+          }
+        }
       } catch (_) {}
     }
 
@@ -1044,9 +1080,42 @@ function decodeMessageContainer(buf, depth) {
       } catch (_) { msgResult = { type: 'poll', question: '', options: [] }; }
     }
 
-    // Field 50: pollUpdateMessage (a vote on an existing poll)
+    // Field 50: pollUpdateMessage — somebody voted on a poll.
+    //
+    //   PollUpdateMessage { pollCreationMessageKey=1, vote=2,
+    //                       senderTimestampMs=3 }
+    //   MessageKey        { remoteJid=1, fromMe=2, id=3 }
+    //   PollEncValue      { encPayload=1, encIV=2 }
+    //
+    // The vote itself is encrypted under a key derived from the poll's message
+    // secret, so the ballot cannot be read from the stanza alone — see
+    // decryptPollVote. Every one of these decoded to the bare word 'pollVote'
+    // and nothing else, which left no way to tell which poll had been voted on,
+    // let alone what the vote was.
     if (!msgResult && f[50] && Buffer.isBuffer(f[50])) {
       msgResult = { type: 'pollVote' };
+      try {
+        const upd = _decodeFields(f[50]);
+
+        if (Buffer.isBuffer(upd[1])) {
+          const key = _decodeFields(upd[1]);
+          msgResult.pollKey = {
+            remoteJid: _str(key[1]) || null,
+            fromMe:    !!key[2],
+            id:        _str(key[3]) || null
+          };
+        }
+
+        if (Buffer.isBuffer(upd[2])) {
+          const vote = _decodeFields(upd[2]);
+          if (Buffer.isBuffer(vote[1]) && Buffer.isBuffer(vote[2])) {
+            msgResult.encPayload = vote[1];
+            msgResult.encIv      = vote[2];
+          }
+        }
+
+        if (typeof upd[3] === 'number') msgResult.senderTimestampMs = upd[3];
+      } catch (_) { /* the bare type is still worth reporting */ }
     }
 
     // If we found a real message, attach skdmInfo / messageSecret and return.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.29.2",
+  "version": "5.29.3",
   "description": "Node.js library for WhatsApp — register a number over SMS, or link as a companion by QR. Signal E2E encryption, media, groups, channels.",
   "author": "Kunboruto20",
   "main": "index.js",