whalibmob 5.22.0 → 5.23.1

package/README.md

@@ -181,6 +181,7 @@ npm install -g whalibmob
     - [When 463 Means the Account Is Restricted](#when-463-means-the-account-is-restricted)
     - [What Is Automatic vs What You Need to Do](#what-is-automatic-vs-what-you-need-to-do)
   - [Receiving Media](#receiving-media)
+    - [When the File Is Gone from the CDN](#when-the-file-is-gone-from-the-cdn)
   - [Sending Messages](#sending-messages)
     - [Text Message](#text-message)
     - [Quote Message](#quote-message)
@@ -573,7 +574,7 @@ After running `wa connect <phone>`, every feature of the library is available as
 #### Send Text
 
 ```sh
-wa> /send 919634847671@s.whatsapp.net Hello, how are you?
+wa> /send 919634847671 Hello, how are you?
 sent  3EB0ABCDEF123456
 
 # to a group
@@ -583,8 +584,8 @@ wa> /send 120363000000000000@g.us Hello everyone!
 #### Send Image
 
 ```sh
-wa> /image 919634847671@s.whatsapp.net ./photo.jpg
-wa> /image 919634847671@s.whatsapp.net ./photo.jpg Look at this!
+wa> /image 919634847671 ./photo.jpg
+wa> /image 919634847671 ./photo.jpg Look at this!
 ```
 
 The second argument is the file path. The optional third argument is the caption.
@@ -592,8 +593,8 @@ The second argument is the file path. The optional third argument is the caption
 #### Send Video
 
 ```sh
-wa> /video 919634847671@s.whatsapp.net ./clip.mp4
-wa> /video 919634847671@s.whatsapp.net ./clip.mp4 Watch this
+wa> /video 919634847671 ./clip.mp4
+wa> /video 919634847671 ./clip.mp4 Watch this
 ```
 
 #### Send Audio
@@ -601,7 +602,7 @@ wa> /video 919634847671@s.whatsapp.net ./clip.mp4 Watch this
 Sends the file as a regular audio attachment:
 
 ```sh
-wa> /audio 919634847671@s.whatsapp.net ./song.mp3
+wa> /audio 919634847671 ./song.mp3
 ```
 
 #### Send Voice Note
@@ -609,14 +610,14 @@ wa> /audio 919634847671@s.whatsapp.net ./song.mp3
 Sends the file as a push-to-talk voice note with waveform:
 
 ```sh
-wa> /ptt 919634847671@s.whatsapp.net ./voice.ogg
+wa> /ptt 919634847671 ./voice.ogg
 ```
 
 #### Send Document
 
 ```sh
-wa> /doc 919634847671@s.whatsapp.net ./report.pdf
-wa> /doc 919634847671@s.whatsapp.net ./report.pdf "Q1 Report.pdf"
+wa> /doc 919634847671 ./report.pdf
+wa> /doc 919634847671 ./report.pdf "Q1 Report.pdf"
 ```
 
 The optional third argument overrides the displayed filename.
@@ -626,7 +627,7 @@ The optional third argument overrides the displayed filename.
 The file must be in WebP format:
 
 ```sh
-wa> /sticker 919634847671@s.whatsapp.net ./sticker.webp
+wa> /sticker 919634847671 ./sticker.webp
 ```
 
 #### Send Poll (CLI)
@@ -635,7 +636,7 @@ Separate the question from the options using `|`. At least two options are requi
 
 ```sh
 # single-choice poll (selectable=1)
-wa> /poll 919634847671@s.whatsapp.net Best language? | JavaScript | Python | Rust | selectable=1
+wa> /poll 919634847671 Best language? | JavaScript | Python | Rust | selectable=1
 
 # unlimited-choice poll (default)
 wa> /poll 120363000000000000@g.us Pick your favourites | Red | Green | Blue
@@ -644,10 +645,10 @@ wa> /poll 120363000000000000@g.us Pick your favourites | Red | Green | Blue
 #### React to a Message
 
 ```sh
-wa> /react 919634847671@s.whatsapp.net 3EB0ABCDEF123456 👍
+wa> /react 919634847671 3EB0ABCDEF123456 👍
 
 # remove a reaction — pass a space or empty string
-wa> /react 919634847671@s.whatsapp.net 3EB0ABCDEF123456 " "
+wa> /react 919634847671 3EB0ABCDEF123456 " "
 ```
 
 The message ID is shown in the incoming message display as `id`.
@@ -658,17 +659,17 @@ The message ID is shown in the incoming message display as `id`.
 > Editing is only possible within 15 minutes of the original send.
 
 ```sh
-wa> /edit 919634847671@s.whatsapp.net 3EB0ABCDEF123456 Corrected text here
+wa> /edit 919634847671 3EB0ABCDEF123456 Corrected text here
 ```
 
 #### Delete a Message
 
 ```sh
 # delete for yourself only
-wa> /delete 919634847671@s.whatsapp.net 3EB0ABCDEF123456
+wa> /delete 919634847671 3EB0ABCDEF123456
 
 # delete for everyone (revoke)
-wa> /delete 919634847671@s.whatsapp.net 3EB0ABCDEF123456 all
+wa> /delete 919634847671 3EB0ABCDEF123456 all
 ```
 
 #### Post a Status / Story
@@ -684,7 +685,7 @@ wa> /status Good morning everyone!
 Sends a message with the forwarded flag set:
 
 ```sh
-wa> /forward 919634847671@s.whatsapp.net This message was forwarded
+wa> /forward 919634847671 This message was forwarded
 ```
 
 #### Reply to a Message (CLI)
@@ -693,10 +694,10 @@ Quote and reply to a specific message. You need the message ID (shown as `id:` i
 
 ```sh
 # DM — senderJid is the same as the chat JID
-wa> /reply 919634847671@s.whatsapp.net 3EB0XXXXXXXX 919634847671@s.whatsapp.net Got it, thanks!
+wa> /reply 919634847671 3EB0XXXXXXXX 919634847671 Got it, thanks!
 
 # Group — senderJid is the member who sent the original message
-wa> /reply 120363000000000000@g.us 3EB0XXXXXXXX 919634847671@s.whatsapp.net Agreed!
+wa> /reply 120363000000000000@g.us 3EB0XXXXXXXX 919634847671 Agreed!
 ```
 
 The message ID is printed when a message arrives:
@@ -710,13 +711,13 @@ Send a GPS location pin. Latitude and longitude are required; name and address (
 
 ```sh
 # lat/lon only
-wa> /location 919634847671@s.whatsapp.net 48.8566 2.3522
+wa> /location 919634847671 48.8566 2.3522
 
 # with name
-wa> /location 919634847671@s.whatsapp.net 48.8566 2.3522 Eiffel Tower
+wa> /location 919634847671 48.8566 2.3522 Eiffel Tower
 
 # with name and address (separate with |)
-wa> /location 919634847671@s.whatsapp.net 48.8566 2.3522 Eiffel Tower | Champ de Mars, Paris
+wa> /location 919634847671 48.8566 2.3522 Eiffel Tower | Champ de Mars, Paris
 
 # to a group
 wa> /location 120363000000000000@g.us 51.5074 -0.1278 London
@@ -727,7 +728,7 @@ wa> /location 120363000000000000@g.us 51.5074 -0.1278 London
 Send a contact card. The vCard string must follow the vCard v3 format. Wrap it in quotes in the shell:
 
 ```sh
-wa> /vcard 919634847671@s.whatsapp.net "Alice Smith" "BEGIN:VCARD\nVERSION:3.0\nFN:Alice Smith\nTEL;TYPE=CELL:+919634847671\nEND:VCARD"
+wa> /vcard 919634847671 "Alice Smith" "BEGIN:VCARD\nVERSION:3.0\nFN:Alice Smith\nTEL;TYPE=CELL:+919634847671\nEND:VCARD"
 ```
 
 For multi-line vCards it is easiest to store the string in a shell variable:
@@ -740,7 +741,7 @@ TEL;TYPE=CELL:+919634847671
 EMAIL:alice@example.com
 END:VCARD"
 
-wa> /vcard 919634847671@s.whatsapp.net "Alice Smith" "$VCARD"
+wa> /vcard 919634847671 "Alice Smith" "$VCARD"
 ```
 
 ---
@@ -758,13 +759,13 @@ wa> /offline
 
 ```sh
 # show "typing…" in a chat
-wa> /typing 919634847671@s.whatsapp.net
+wa> /typing 919634847671
 
 # show "recording audio…" in a chat
-wa> /recording 919634847671@s.whatsapp.net
+wa> /recording 919634847671
 
 # stop the indicator
-wa> /stop 919634847671@s.whatsapp.net
+wa> /stop 919634847671
 ```
 
 #### Subscribe to a Contact's Presence
@@ -772,7 +773,7 @@ wa> /stop 919634847671@s.whatsapp.net
 Subscribes to online/offline events for a contact. The shell will print presence updates as they arrive:
 
 ```sh
-wa> /subscribe 919634847671@s.whatsapp.net
+wa> /subscribe 919634847671
 subscribed to 919634847671@s.whatsapp.net
 
 # when they come online:
@@ -852,7 +853,7 @@ wa> /whatsapp 919634847671 12345678901
 Returns the CDN URL for a contact's or group's profile picture:
 
 ```sh
-wa> /picture 919634847671@s.whatsapp.net
+wa> /picture 919634847671
   https://mmg.whatsapp.net/v/...
 
 wa> /picture 120363000000000000@g.us
@@ -864,7 +865,7 @@ wa> /picture 120363000000000000@g.us
 Fetches the bio / about text for a contact:
 
 ```sh
-wa> /contact about 919634847671@s.whatsapp.net
+wa> /contact about 919634847671
   Available 24/7
 ```
 
@@ -881,42 +882,42 @@ send the request a primary makes for itself; `/pin`, `/archive` and `/star`
 update this session only. The command says which happened:
 
 ```sh
-wa> /pin 919634847671@s.whatsapp.net
+wa> /pin 919634847671
 pinned  (this session only — no app state key)
 ```
 
 #### Mark Read / Unread
 
 ```sh
-wa> /read   919634847671@s.whatsapp.net
-wa> /unread 919634847671@s.whatsapp.net
+wa> /read   919634847671
+wa> /unread 919634847671
 ```
 
 #### Mute / Unmute
 
 ```sh
 # mute for 60 minutes
-wa> /mute 919634847671@s.whatsapp.net 60
+wa> /mute 919634847671 60
 
 # mute indefinitely
-wa> /mute 919634847671@s.whatsapp.net
+wa> /mute 919634847671
 
 # unmute
-wa> /unmute 919634847671@s.whatsapp.net
+wa> /unmute 919634847671
 ```
 
 #### Pin / Unpin
 
 ```sh
-wa> /pin   919634847671@s.whatsapp.net
-wa> /unpin 919634847671@s.whatsapp.net
+wa> /pin   919634847671
+wa> /unpin 919634847671
 ```
 
 #### Archive / Unarchive
 
 ```sh
-wa> /archive   919634847671@s.whatsapp.net
-wa> /unarchive 919634847671@s.whatsapp.net
+wa> /archive   919634847671
+wa> /unarchive 919634847671
 ```
 
 #### Star / Unstar a Message (CLI)
@@ -925,8 +926,8 @@ Add `me` when the message is one you sent — it is part of how the star is file
 so leaving it off on your own message stars the wrong thing.
 
 ```sh
-wa> /star   919634847671@s.whatsapp.net 3EB0ABCDEF123456 me
-wa> /unstar 919634847671@s.whatsapp.net 3EB0ABCDEF123456
+wa> /star   919634847671 3EB0ABCDEF123456 me
+wa> /unstar 919634847671 3EB0ABCDEF123456
 ```
 
 <a id="cli-app-state"></a>
@@ -1051,13 +1052,13 @@ shell prints the change as it happens:
 
 ```sh
 # set 1-day timer on a DM
-wa> /ephemeral 919634847671@s.whatsapp.net 86400
+wa> /ephemeral 919634847671 86400
 
 # set 1-week timer on a group
 wa> /ephemeral 120363000000000000@g.us 604800
 
 # turn off
-wa> /ephemeral 919634847671@s.whatsapp.net 0
+wa> /ephemeral 919634847671 0
 ```
 
 #### Default Disappearing Timer
@@ -1078,10 +1079,10 @@ Accepts the same values as `/ephemeral`: 0, 86400, 604800, 7776000.
 #### Block / Unblock
 
 ```sh
-wa> /block   919634847671@s.whatsapp.net
+wa> /block   919634847671
 blocked  919634847671@s.whatsapp.net
 
-wa> /unblock 919634847671@s.whatsapp.net
+wa> /unblock 919634847671
 unblocked  919634847671@s.whatsapp.net
 ```
 
@@ -1101,7 +1102,7 @@ wa> /blocklist
 #### CLI Create a Group
 
 ```sh
-wa> /group create MyGroup 919634847671@s.whatsapp.net 12345678901@s.whatsapp.net
+wa> /group create MyGroup 919634847671 12345678901
 creating group...
 created  120363000000000000@g.us
   subject  MyGroup
@@ -1119,12 +1120,12 @@ left  120363000000000000@g.us
 
 ```sh
 # add participants
-wa> /group add 120363000000000000@g.us 919634847671@s.whatsapp.net 12345678901@s.whatsapp.net
+wa> /group add 120363000000000000@g.us 919634847671 12345678901
   added  919634847671@s.whatsapp.net
   failed  12345678901@s.whatsapp.net  — their privacy settings do not allow it (403)  · can be invited instead
 
 # remove participants
-wa> /group remove 120363000000000000@g.us 919634847671@s.whatsapp.net
+wa> /group remove 120363000000000000@g.us 919634847671
   removed  919634847671@s.whatsapp.net
 ```
 
@@ -1135,10 +1136,10 @@ reported on its own line, because the server decides each one separately.
 
 ```sh
 # promote to admin
-wa> /group promote 120363000000000000@g.us 919634847671@s.whatsapp.net
+wa> /group promote 120363000000000000@g.us 919634847671
 
 # demote from admin
-wa> /group demote 120363000000000000@g.us 919634847671@s.whatsapp.net
+wa> /group demote 120363000000000000@g.us 919634847671
 ```
 
 #### Change Group Name
@@ -1285,11 +1286,11 @@ wa> /group pending 120363000000000000@g.us
 
 ```sh
 # approve one or more pending members
-wa> /group approve 120363000000000000@g.us 919634847671@s.whatsapp.net
+wa> /group approve 120363000000000000@g.us 919634847671
   approved  919634847671@s.whatsapp.net
 
 # reject one or more pending members
-wa> /group reject 120363000000000000@g.us 919634847671@s.whatsapp.net
+wa> /group reject 120363000000000000@g.us 919634847671
   rejected  919634847671@s.whatsapp.net
 ```
 
@@ -1304,7 +1305,7 @@ For someone whose privacy settings do not let them be added to a group directly,
 `add-invite` adds whoever it can and sends the rest a personal invitation:
 
 ```sh
-wa> /group add-invite 120363000000000000@g.us 919634847671@s.whatsapp.net 12345678901@s.whatsapp.net
+wa> /group add-invite 120363000000000000@g.us 919634847671 12345678901
   added  919634847671@s.whatsapp.net
   failed  12345678901@s.whatsapp.net  — their privacy settings do not allow it (403)  · can be invited instead  · invitation sent
 ```
@@ -1320,17 +1321,17 @@ An invitation that arrives for you shows the command that accepts it:
 
 ```sh
 # look at the group without joining it
-wa> /group preview-invite 120363000000000000@g.us 919634847671@s.whatsapp.net AbCdEfGh 1790000000
+wa> /group preview-invite 120363000000000000@g.us 919634847671 AbCdEfGh 1790000000
 
 # join
-wa> /group accept-invite 120363000000000000@g.us 919634847671@s.whatsapp.net AbCdEfGh 1790000000
+wa> /group accept-invite 120363000000000000@g.us 919634847671 AbCdEfGh 1790000000
 joined 120363000000000000@g.us
 
 # send one by hand
-wa> /group send-invite 120363000000000000@g.us 12345678901@s.whatsapp.net AbCdEfGh 1790000000
+wa> /group send-invite 120363000000000000@g.us 12345678901 AbCdEfGh 1790000000
 
 # take one back before it is used
-wa> /group revoke-invite 120363000000000000@g.us 12345678901@s.whatsapp.net
+wa> /group revoke-invite 120363000000000000@g.us 12345678901
 ```
 
 #### Group Settings
@@ -1413,7 +1414,7 @@ wa> /newsletter post 120363000000000004@newsletter Breaking: WhatsApp adds polls
 Query the public business profile of any WhatsApp Business account:
 
 ```sh
-wa> /biz 919634847671@s.whatsapp.net
+wa> /biz 919634847671
   ────────────────────────────────────────────────────────
   jid           919634847671@s.whatsapp.net
   category      Software & IT Services
@@ -2162,7 +2163,7 @@ Everything after the scan is identical to the pairing-code path: `paired`, a str
 A few seconds after the code is accepted (or the QR is scanned) you will see `paired`, the server restarts the stream, and `connected` fires on the new connection. From that point on everything else in this document applies unchanged:
 
 ```js
-await client.sendText('919876543210@s.whatsapp.net', 'sent from a linked device')
+await client.sendText('919876543210', 'sent from a linked device')
 ```
 
 ### Reconnecting a Linked Session
@@ -2409,6 +2410,7 @@ Every event from the SMS primary API fires here too — `message`, `receipt`, `p
 | `pair_device` | `{ refs }` | the QR path produced reference strings |
 | `history_sync` | `{ syncTypeName, chats, contacts, pushNames, merged }` | a chunk of history arrived |
 | `history_sync_error` | `{ err, notification }` | a chunk could not be fetched or decrypted |
+| `media_retry` | `{ messageId, chatJid, fromMe, participant, ciphertext, iv, error }` | the sender's phone answered a `requestMediaRetry()`. Read it with `decryptMediaRetry()` and the original media key; an `error` instead of a payload means the phone no longer has the file either |
 | `client_rejected` | `{ reason, location, message }` | the server refused the client itself, not the session — `405` means the announced version is not accepted. Fires whether the refusal arrives during the handshake or once the stream is open, and the client stops retrying either way. Distinct from `auth_failure`, and there is nothing to re-pair. |
 | `version_update` | `{ from, to, source }` | the announced version was refreshed from the platform's store before a handshake. Fires on reconnects as well as the first connect |
 | `apk_material_stale` | `{ materialVersion, liveVersion, hint }` | Android only: the Play Store listing has moved past the APK the cached token material came from. Nothing is broken — registration is what reads that material — but the next number registered from this install would go out under an older build |
@@ -3129,7 +3131,7 @@ async function connect() {
 
   client.on('connected', async () => {
     console.log('connected')
-    await client.sendText('919634847671@s.whatsapp.net', 'Hello!')
+    await client.sendText('919634847671', 'Hello!')
   })
 
   client.on('disconnected', () => {
@@ -3663,12 +3665,56 @@ const bytes = await client.downloadMedia(d, { verify: true })
 with no media, no CDN location, an unsupported type, or a file that does not
 match the message all say so.
 
+### When the file is gone from the CDN
+
+Media is not carried inside the message — the message carries a URL, a hash and
+the key, and the bytes sit on WhatsApp's CDN for a limited time. A download that
+answers **404** or **410** has nothing left to fetch. This is most common for
+messages that arrive through history sync long after they were sent.
+
+The sender's phone still has the original, and can be asked to upload it again:
+
+```js
+client.on('media_retry', (notification) => {
+  const result = client.decryptMediaRetry(notification, mediaKey)
+  if (result.ok) {
+    // fresh location — download it the usual way
+    console.log('re-uploaded at', result.directPath)
+  } else {
+    // the phone no longer has it either; nothing further to try
+  }
+})
+
+try {
+  await client.downloadMedia(msg)
+} catch (err) {
+  if (/404|410/.test(err.message)) {
+    await client.requestMediaRetry({
+      id:          msg.key.id,
+      chatJid:     msg.key.remoteJid,
+      fromMe:      msg.key.fromMe,
+      // groups only — the member who sent it
+      participant: msg.key.participant
+    }, mediaKey)
+  }
+}
+```
+
+`requestMediaRetry` resolves as soon as the request is on the wire; the answer
+arrives later on the `media_retry` event, which is why the two halves are
+written separately. Keep the `mediaKey` — the reply is encrypted under a key
+derived from it, and without it the fresh location cannot be read.
+
+That derivation is also what makes the request safe to send: it proves the
+asker was a recipient of the message rather than someone who merely knows a
+message id, so no phone can be made to re-upload a file on request.
+
 ## Sending Messages
 
 ### Text Message
 
 ```js
-await client.sendText('919634847671@s.whatsapp.net', 'Hello!')
+await client.sendText('919634847671', 'Hello!')
 ```
 
 ### Quote Message
@@ -3704,10 +3750,10 @@ await client.sendText(
 
 ```js
 // react to a message
-await client.sendReaction('919634847671@s.whatsapp.net', 'MSGID123', '👍')
+await client.sendReaction('919634847671', 'MSGID123', '👍')
 
 // remove a reaction — pass empty string
-await client.sendReaction('919634847671@s.whatsapp.net', 'MSGID123', '')
+await client.sendReaction('919634847671', 'MSGID123', '')
 ```
 
 ### Edit Message
@@ -3727,10 +3773,10 @@ await client.editMessage(
 
 ```js
 // delete for yourself only
-await client.deleteMessage('MSGID123', '919634847671@s.whatsapp.net', true, false)
+await client.deleteMessage('MSGID123', '919634847671', true, false)
 
 // delete for everyone (revoke)
-await client.deleteMessage('MSGID123', '919634847671@s.whatsapp.net', true, true)
+await client.deleteMessage('MSGID123', '919634847671', true, true)
 ```
 
 ### Forward Message
@@ -3740,12 +3786,12 @@ re-uploading.  Pass a decoded message object from the `message` event to forward
 
 ```js
 // Forward text
-await client.forwardMessage('919634847671@s.whatsapp.net', 'text to forward')
+await client.forwardMessage('919634847671', 'text to forward')
 
 // Forward any received message (full media, no re-upload)
 client.on('message', async (msg) => {
   if (msg.decoded && msg.decoded.type !== 'text') {
-    await client.forwardMessage('919634847671@s.whatsapp.net', msg)
+    await client.forwardMessage('919634847671', msg)
   }
 })
 ```
@@ -3795,10 +3841,10 @@ Send a GPS location pin. `name` and `address` are optional labels shown below th
 
 ```js
 // minimal — lat/lon only
-await client.sendLocation('919634847671@s.whatsapp.net', 48.8566, 2.3522)
+await client.sendLocation('919634847671', 48.8566, 2.3522)
 
 // with name and address
-await client.sendLocation('919634847671@s.whatsapp.net', 48.8566, 2.3522, {
+await client.sendLocation('919634847671', 48.8566, 2.3522, {
   name:    'Eiffel Tower',
   address: 'Champ de Mars, 5 Av. Anatole France, Paris'
 })
@@ -3809,7 +3855,7 @@ await client.sendLocation('120363000000000000@g.us', 51.5074, -0.1278, {
 })
 
 // with a map image for the bubble — WhatsApp draws a blank card without one
-await client.sendLocation('919634847671@s.whatsapp.net', 48.8566, 2.3522, {
+await client.sendLocation('919634847671', 48.8566, 2.3522, {
   name: 'Eiffel Tower',
   thumbnail: jpegBuffer
 })
@@ -3829,7 +3875,7 @@ const vcard = [
   'END:VCARD'
 ].join('\n')
 
-await client.sendContact('919634847671@s.whatsapp.net', 'Alice Smith', vcard)
+await client.sendContact('919634847671', 'Alice Smith', vcard)
 ```
 
 ### Call Link
@@ -3848,7 +3894,7 @@ const audio = await client.createCallLink()
 await client.createCallLink('video', { startTime: 1800000000 })
 
 // create it and send it in one step
-await client.sendCallLink('919634847671@s.whatsapp.net', 'video', {
+await client.sendCallLink('919634847671', 'video', {
   text: 'Join me here:'
 })
 ```
@@ -3869,10 +3915,10 @@ the preview.
 
 ```js
 // from file path
-await client.sendImage('919634847671@s.whatsapp.net', './photo.jpg', { caption: 'Look at this' })
+await client.sendImage('919634847671', './photo.jpg', { caption: 'Look at this' })
 
 // from Buffer
-await client.sendImage('919634847671@s.whatsapp.net', buffer, {
+await client.sendImage('919634847671', buffer, {
   caption: 'Photo',
   mimetype: 'image/jpeg'
 })
@@ -3881,26 +3927,26 @@ await client.sendImage('919634847671@s.whatsapp.net', buffer, {
 ### Video Message
 
 ```js
-await client.sendVideo('919634847671@s.whatsapp.net', './clip.mp4', { caption: 'Watch this' })
+await client.sendVideo('919634847671', './clip.mp4', { caption: 'Watch this' })
 ```
 
 ### Audio Message
 
 ```js
-await client.sendAudio('919634847671@s.whatsapp.net', './song.mp3')
+await client.sendAudio('919634847671', './song.mp3')
 ```
 
 ### Voice Note
 
 ```js
 // ptt: true renders the audio as a push-to-talk voice note with waveform
-await client.sendAudio('919634847671@s.whatsapp.net', './voice.ogg', { ptt: true })
+await client.sendAudio('919634847671', './voice.ogg', { ptt: true })
 ```
 
 ### Document Message
 
 ```js
-await client.sendDocument('919634847671@s.whatsapp.net', './report.pdf', {
+await client.sendDocument('919634847671', './report.pdf', {
   fileName: 'Q1 Report.pdf'
 })
 ```
@@ -3908,7 +3954,7 @@ await client.sendDocument('919634847671@s.whatsapp.net', './report.pdf', {
 ### Sticker Message
 
 ```js
-await client.sendSticker('919634847671@s.whatsapp.net', './sticker.webp')
+await client.sendSticker('919634847671', './sticker.webp')
 ```
 
 ## Status / Stories
@@ -3931,7 +3977,7 @@ await client.sendStatus({ audio: './voice.ogg' })
 await client.sendStatus('Colorful', { backgroundArgb: 0xFF25D366, font: 3 })
 
 // post to an explicit list instead of the privacy-derived one
-await client.sendStatus('Hi', { recipients: ['919634847671@s.whatsapp.net'] })
+await client.sendStatus('Hi', { recipients: ['919634847671'] })
 ```
 
 ### Status Privacy
@@ -3956,7 +4002,7 @@ pass `recipients` in that case.
 
 ```js
 // mark all messages in a chat as read (sends IQ to server)
-await client.markChatRead('919634847671@s.whatsapp.net')
+await client.markChatRead('919634847671')
 ```
 
 ### Mark Voice Message Played
@@ -3965,7 +4011,7 @@ Send a `played` receipt for a received voice note (push-to-talk audio). This tel
 
 ```js
 // msgId: ID of the audio message, from: JID of the sender
-client.markMessagePlayed('3EB0ABCDEF123456', '919634847671@s.whatsapp.net')
+client.markMessagePlayed('3EB0ABCDEF123456', '919634847671')
 ```
 
 ### Update Presence
@@ -3976,9 +4022,9 @@ client.setOnline(true)
 client.setOnline(false)
 
 // show typing or recording in a specific chat
-client.setChatPresence('919634847671@s.whatsapp.net', 'composing')   // typing
-client.setChatPresence('919634847671@s.whatsapp.net', 'recording')   // recording audio
-client.setChatPresence('919634847671@s.whatsapp.net', 'paused')      // stopped
+client.setChatPresence('919634847671', 'composing')   // typing
+client.setChatPresence('919634847671', 'recording')   // recording audio
+client.setChatPresence('919634847671', 'paused')      // stopped
 ```
 
 ## Modifying Chats
@@ -3996,7 +4042,7 @@ They return a boolean: **whether the change reached app state**, and so whether
 other devices will see it.
 
 ```js
-const synced = await client.pinChat('919634847671@s.whatsapp.net')
+const synced = await client.pinChat('919634847671')
 if (!synced) console.log('pinned here, but your phone will not know')
 ```
 
@@ -4023,16 +4069,16 @@ if (!synced) console.log('pinned here, but your phone will not know')
 ### Archive / Unarchive a Chat
 
 ```js
-await client.archiveChat('919634847671@s.whatsapp.net')
-await client.unarchiveChat('919634847671@s.whatsapp.net')
+await client.archiveChat('919634847671')
+await client.unarchiveChat('919634847671')
 ```
 
 ### Mute / Unmute a Chat
 
 ```js
-await client.muteChat('919634847671@s.whatsapp.net', 8 * 60 * 60 * 1000)  // 8 hours
-await client.muteChat('919634847671@s.whatsapp.net', 0)                   // until unmuted
-await client.unmuteChat('919634847671@s.whatsapp.net')
+await client.muteChat('919634847671', 8 * 60 * 60 * 1000)  // 8 hours
+await client.muteChat('919634847671', 0)                   // until unmuted
+await client.unmuteChat('919634847671')
 ```
 
 ### Mark a Chat Read / Unread
@@ -4041,15 +4087,15 @@ This is the chat's own unread badge. To send read receipts (blue ticks) for
 particular messages, use `markRead()` instead.
 
 ```js
-await client.markChatRead('919634847671@s.whatsapp.net')
-await client.markChatUnread('919634847671@s.whatsapp.net')
+await client.markChatRead('919634847671')
+await client.markChatUnread('919634847671')
 ```
 
 ### Pin / Unpin a Chat
 
 ```js
-await client.pinChat('919634847671@s.whatsapp.net')
-await client.unpinChat('919634847671@s.whatsapp.net')
+await client.pinChat('919634847671')
+await client.unpinChat('919634847671')
 ```
 
 ### Star / Unstar a Message
@@ -4058,8 +4104,8 @@ The third argument says whether the message being starred is one you sent. It is
 part of how the star is filed, so getting it wrong stars a different message.
 
 ```js
-await client.starMessage('MSGID123', '919634847671@s.whatsapp.net', true)   // yours
-await client.unstarMessage('MSGID123', '919634847671@s.whatsapp.net', false) // theirs
+await client.starMessage('MSGID123', '919634847671', true)   // yours
+await client.unstarMessage('MSGID123', '919634847671', false) // theirs
 ```
 
 <a id="app-state-sync"></a>
@@ -4146,11 +4192,11 @@ client.on('app_state_mutation', ({ collection, index, action, removed }) => {
 
 ```js
 // set disappearing timer for a specific chat (DM or group)
-await client.changeEphemeralTimer('919634847671@s.whatsapp.net', 86400)
+await client.changeEphemeralTimer('919634847671', 86400)
 await client.changeEphemeralTimer('120363000000000000@g.us', 604800)
 
 // remove disappearing messages
-await client.changeEphemeralTimer('919634847671@s.whatsapp.net', 0)
+await client.changeEphemeralTimer('919634847671', 0)
 ```
 
 ## User Queries
@@ -4175,7 +4221,7 @@ const results = await client.hasWhatsapp(['919634847671', '12345678901'])
 ### Fetch Profile About
 
 ```js
-const about = await client.queryAbout('919634847671@s.whatsapp.net')
+const about = await client.queryAbout('919634847671')
 console.log(about)
 
 // your own, asked the same way
@@ -4185,7 +4231,7 @@ console.log(await client.queryOwnAbout())
 ### Fetch Profile Picture
 
 ```js
-const url = await client.queryPicture('919634847671@s.whatsapp.net')
+const url = await client.queryPicture('919634847671')
 // also works for groups
 const groupUrl = await client.queryPicture('120363000000000000@g.us')
 ```
@@ -4194,7 +4240,7 @@ const groupUrl = await client.queryPicture('120363000000000000@g.us')
 
 ```js
 // triggers 'presence' events when the contact comes online or goes offline
-client.subscribeToPresence('919634847671@s.whatsapp.net')
+client.subscribeToPresence('919634847671')
 
 client.on('presence', ({ from, available }) => {
   console.log(from, available ? 'online' : 'offline')
@@ -4303,8 +4349,8 @@ await client.changeProfilePicture(buf, { size: 640, quality: 50 })
 
 ```js
 // both return the updated block list, and throw if the server refuses
-const blocked = await client.blockContact('919634847671@s.whatsapp.net')
-await client.unblockContact('919634847671@s.whatsapp.net')
+const blocked = await client.blockContact('919634847671')
+await client.unblockContact('919634847671')
 
 // the block list is addressed by LID; a phone number is resolved to one first,
 // looking it up if it is not already known
@@ -4426,9 +4472,9 @@ for (const r of results) {
   else      console.log('failed', r.jid, r.status, r.needsInvite ? '(invite instead)' : '')
 }
 
-await client.removeGroupParticipants(groupJid,  ['919634847671@s.whatsapp.net'])
-await client.promoteGroupParticipants(groupJid, ['919634847671@s.whatsapp.net'])
-await client.demoteGroupParticipants(groupJid,  ['919634847671@s.whatsapp.net'])
+await client.removeGroupParticipants(groupJid,  ['919634847671'])
+await client.promoteGroupParticipants(groupJid, ['919634847671'])
+await client.demoteGroupParticipants(groupJid,  ['919634847671'])
 ```
 
 Each result looks like this:
@@ -4709,7 +4755,7 @@ groupName, jpegThumbnail, caption, isCommunity }`.
 To withdraw an invitation you sent before it is used:
 
 ```js
-await client.revokeGroupInviteForParticipant(groupJid, '919634847671@s.whatsapp.net')
+await client.revokeGroupInviteForParticipant(groupJid, '919634847671')
 ```
 
 An expired or already-spent invitation throws rather than resolving to nothing,
@@ -4801,7 +4847,7 @@ await client.sendNewsletterText('120363000000000004@newsletter', 'Breaking: What
 Query the public business profile of any WhatsApp Business account:
 
 ```js
-const bp = await client.queryBusinessProfile('919634847671@s.whatsapp.net')
+const bp = await client.queryBusinessProfile('919634847671')
 if (bp) {
   console.log(bp.category)     // e.g. "Software & IT Services"
   console.log(bp.email)        // business email (if set)

package/lib/Client.js

@@ -571,7 +571,10 @@ class WhalibmobClient extends EventEmitter {
     const device   = this._store.device || getDeviceConfig();
     const business = !!device.business;
     const android  = device.os === 'android';
-    const source   = android ? 'Play Store listing' : 'App Store listing';
+    // Named for where the answer comes from, since that is the first thing
+    // anyone reading a version line wants to know. Android is answered by
+    // Play's API now, not by the store page it used to scrape.
+    const source   = android ? 'Play Store' : 'App Store listing';
 
     try {
       const { compareVersions, fetchAndroidVersionLive } = require('./Registration');
@@ -1420,6 +1423,71 @@ class WhalibmobClient extends EventEmitter {
     this.emit('close');
   }
 
+  /**
+   * Ask the sender's phone to upload a media file again.
+   *
+   * Media lives on the CDN for a while, not forever, and the message only ever
+   * carried the URL and the key. A download that comes back 404 or 410 — most
+   * often for something that arrived through history sync long after it was
+   * sent — has nothing left to fetch, and until now that was where it ended:
+   * the message looked fine and the file was simply gone.
+   *
+   * The sender still has the original. This asks for it back.
+   *
+   * The request is encrypted under a key derived from the message's own media
+   * key, so it is proof that we were a recipient rather than merely someone who
+   * knows a message id — no phone can be made to re-upload on request.
+   *
+   * Resolves once the request is on the wire. The answer arrives later as a
+   * `media_retry` event; pass it and the same media key to
+   * decryptMediaRetry() for the fresh path.
+   *
+   *   client.on('media_retry', (n) => {
+   *     const r = client.decryptMediaRetry(n, mediaKey)
+   *     if (r.ok) // re-download from r.directPath
+   *   })
+   *
+   * @param {object} info      { id, chatJid, fromMe, participant }
+   *        `participant` only for a group — the member who sent it.
+   * @param {Buffer} mediaKey  the media key off the original message
+   * @returns {Promise<void>}
+   */
+  async requestMediaRetry(info, mediaKey) {
+    if (!this._socket || !this._connected) {
+      throw new Error('Not connected — cannot request a media retry');
+    }
+    if (!info || !info.id)    throw new Error('requestMediaRetry: info.id is required');
+    if (!info.chatJid)        throw new Error('requestMediaRetry: info.chatJid is required');
+    if (!mediaKey || !mediaKey.length) {
+      throw new Error('requestMediaRetry: the original message\'s mediaKey is required');
+    }
+
+    const { buildRetryReceiptNode } = require('./messages/MediaRetry');
+    // Addressed to ourselves: the receipt is a report about a message we hold,
+    // and the server routes it on to the sender.
+    const node = buildRetryReceiptNode(info, mediaKey, this._ownDeviceJid(), BinaryNode);
+    this._socket.sendNode(node);
+    _whaDbg('[DBG] MEDIA_RETRY requested id=' + info.id + ' chat=' + info.chatJid +
+      (info.participant ? ' participant=' + info.participant : ''));
+  }
+
+  /**
+   * Read the answer to requestMediaRetry().
+   *
+   * @param {object} notification  a `media_retry` event payload
+   * @param {Buffer} mediaKey      the same key the request was made with
+   * @returns {{ok: boolean, result: number|null, directPath: string|null}}
+   *          `ok` false means the phone answered but could not oblige — it no
+   *          longer has the file either, and there is nothing further to try.
+   */
+  decryptMediaRetry(notification, mediaKey) {
+    const { decryptRetryNotification } = require('./messages/MediaRetry');
+    if (notification && notification.error) {
+      return { ok: false, result: null, directPath: null, error: notification.error };
+    }
+    return decryptRetryNotification(notification, mediaKey);
+  }
+
   /**
    * Ask the server whether this session's registration is still alive.
    *
@@ -3529,6 +3597,27 @@ class WhalibmobClient extends EventEmitter {
       this._checkAndReplenishPreKeys();
     }
 
+    // The sender's phone answering a re-upload request — see
+    // requestMediaRetry(). Surfaced raw as well as decrypted, since only the
+    // caller holds the media key the payload is encrypted under.
+    if (type === 'mediaretry') {
+      try {
+        const { parseRetryNotification } = require('./messages/MediaRetry');
+        const parsed = parseRetryNotification(node, {
+          findChild, getContent: getNodeContent
+        });
+        if (parsed) {
+          _whaDbg('[DBG] MEDIA_RETRY notification id=' + parsed.messageId +
+            (parsed.error ? ' error=' + parsed.error.code : ' payload=' +
+              (parsed.ciphertext ? parsed.ciphertext.length + 'B' : 'none')));
+          this.emit('media_retry', parsed);
+        }
+      } catch (err) {
+        _whaDbg('[DBG] MEDIA_RETRY parse failed: ' + (err && err.message));
+      }
+      return;
+    }
+
     if (type === 'account_sync') {
       // Account sync notification — may contain device list updates
       const devicesNode = findChildDeep(node, 'devices');

package/lib/Registration.js

@@ -655,8 +655,29 @@ async function fetchPlayVersion(business) {
 async function fetchAndroidVersionLive(business) {
   const fromPlay = await fetchPlayVersion(business);
   if (fromPlay) return fromPlay;
-  _whaDbg('[DBG] PLAY_VERSION unavailable — falling back to the store page');
-  return fetchAndroidVersion(business);
+
+  // Play did not answer. That happens on any host it will not serve — a
+  // datacenter IP is the usual one, since the dispenser handing out the
+  // anonymous account rate-limits them hard — so this path is what a bot on
+  // hosting actually runs, every time.
+  //
+  // The store page is tried next, but it cannot be trusted on its own: it has
+  // been observed answering 2.26.27.85 while Play was serving 2.26.31.77. Left
+  // as-is that is worse than useless, because a value older than the pinned
+  // version still counts as an answer and shadows it — the caller's "never go
+  // backwards" guard then reads it as "already current" and the session sits
+  // on whatever it had, with the newer pinned version never once applied.
+  //
+  // So the pinned version is a floor, not a last resort: anything the page
+  // says that is older than it is discarded in its favour.
+  const fromPage = await fetchAndroidVersion(business);
+  if (fromPage && compareVersions(fromPage, ANDROID_VERSION_FALLBACK) > 0) {
+    _whaDbg('[DBG] PLAY_VERSION unavailable — the store page says ' + fromPage);
+    return fromPage;
+  }
+  _whaDbg('[DBG] PLAY_VERSION unavailable, and the store page said ' +
+    (fromPage || 'nothing') + ' — using the pinned ' + ANDROID_VERSION_FALLBACK);
+  return ANDROID_VERSION_FALLBACK;
 }
 
 async function fetchIosVersion(business) {

package/lib/messages/MediaRetry.js

@@ -0,0 +1,228 @@
+'use strict';
+
+// Asking the sender's phone to upload a media file again.
+//
+// Media is not carried in the message. The message carries a URL, a SHA-256 of
+// the encrypted bytes and the key to decrypt them, and the bytes themselves sit
+// on WhatsApp's CDN with a limited life. A file that has aged out, or one whose
+// message arrived through history sync long after the fact, answers the
+// download with 404 or 410 — and at that point the media is gone as far as this
+// client is concerned, however healthy the message looks.
+//
+// The sender's phone still has the original. This is how it is asked to put it
+// back: a <receipt type="server-error"> naming the message, carrying a small
+// encrypted payload that proves we are the intended recipient. The phone
+// re-uploads, and the answer comes back as a <notification type="mediaretry">
+// with a fresh URL — encrypted the same way, so only we can read it.
+//
+// The proof is what makes this safe. The receipt encrypts the message id under
+// a key derived from the message's own media key, which only the sender and the
+// recipients hold. Someone who merely knows a message id cannot produce a valid
+// one, so this cannot be used to make a phone re-upload anything on request.
+//
+//   receipt key = HKDF-SHA256(mediaKey, info = "WhatsApp Media Retry Notification", 32)
+//   ciphertext  = AES-256-GCM(receipt key, iv = random 12B, ServerErrorReceipt,
+//                             aad = message id)
+//
+// The notification comes back under the same key, with the same message id as
+// the additional data.
+
+const crypto     = require('crypto');
+const { hkdf }   = require('@noble/hashes/hkdf');
+const { sha256 } = require('@noble/hashes/sha256');
+
+const RETRY_KEY_INFO = 'WhatsApp Media Retry Notification';
+const IV_SIZE        = 12;
+
+// ─── protobuf helpers ───────────────────────────────────────────────────────
+//
+// Two tiny messages, hand-encoded rather than pulled through the schema — the
+// whole of what travels here is one string out and a handful of fields back.
+
+function pbString(field, str) {
+  const buf = Buffer.from(str, 'utf8');
+  return Buffer.concat([Buffer.from([(field << 3) | 2]), varint(buf.length), buf]);
+}
+
+function varint(n) {
+  const out = [];
+  do { let b = n & 0x7f; n >>>= 7; if (n) b |= 0x80; out.push(b); } while (n);
+  return Buffer.from(out);
+}
+
+function readVarint(buf, pos) {
+  let result = 0, shift = 0, byte;
+  do {
+    if (pos >= buf.length) throw new Error('truncated varint');
+    byte = buf[pos++];
+    result |= (byte & 0x7f) << shift;
+    shift += 7;
+  } while (byte & 0x80);
+  return [result, pos];
+}
+
+// Every field of the notification, by number. Unknown ones are kept rather than
+// dropped so a schema that grows does not read as a corrupt message here.
+function readFields(buf) {
+  const out = {};
+  let pos = 0;
+  while (pos < buf.length) {
+    let key; [key, pos] = readVarint(buf, pos);
+    const num = key >> 3, wire = key & 7;
+    if (wire === 2) {
+      let len; [len, pos] = readVarint(buf, pos);
+      out[num] = buf.slice(pos, pos + len);
+      pos += len;
+    } else if (wire === 0) {
+      let val; [val, pos] = readVarint(buf, pos);
+      out[num] = val;
+    } else if (wire === 5) { pos += 4; }
+    else if (wire === 1)   { pos += 8; }
+    else break;
+  }
+  return out;
+}
+
+// ─── key derivation ─────────────────────────────────────────────────────────
+
+/** The AES key both halves of the exchange are encrypted under. */
+function mediaRetryKey(mediaKey) {
+  const ikm = Buffer.isBuffer(mediaKey) ? mediaKey : Buffer.from(mediaKey);
+  return Buffer.from(
+    hkdf(sha256, ikm, Buffer.alloc(0), Buffer.from(RETRY_KEY_INFO, 'utf8'), 32));
+}
+
+/**
+ * Encrypt the receipt that asks for a re-upload.
+ *
+ * @param {string} msgId    the message whose media is missing
+ * @param {Buffer} mediaKey that message's media key
+ * @returns {{ciphertext: Buffer, iv: Buffer}}
+ */
+function encryptRetryReceipt(msgId, mediaKey) {
+  // ServerErrorReceipt { stanzaId = 1 }
+  const plaintext = pbString(1, msgId);
+  const iv        = crypto.randomBytes(IV_SIZE);
+  const cipher    = crypto.createCipheriv('aes-256-gcm', mediaRetryKey(mediaKey), iv);
+  // The message id is the additional data, so a receipt cannot be lifted from
+  // one message and replayed against another.
+  cipher.setAAD(Buffer.from(msgId, 'utf8'));
+  const enc = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  return { ciphertext: Buffer.concat([enc, cipher.getAuthTag()]), iv };
+}
+
+/**
+ * Decrypt the notification that answers one.
+ *
+ * @param {object} notif    { messageId, ciphertext, iv } off the wire
+ * @param {Buffer} mediaKey the same media key the receipt was sent with
+ * @returns {{result: number, directPath: string|null, url: string|null,
+ *            handle: string|null, ciphertextSha256: Buffer|null}}
+ */
+function decryptRetryNotification(notif, mediaKey) {
+  const { messageId, ciphertext, iv } = notif;
+  if (!ciphertext || !iv) throw new Error('media retry notification carried no payload');
+
+  const key      = mediaRetryKey(mediaKey);
+  const tag      = ciphertext.slice(ciphertext.length - 16);
+  const body     = ciphertext.slice(0, ciphertext.length - 16);
+  const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+  decipher.setAuthTag(tag);
+  decipher.setAAD(Buffer.from(messageId, 'utf8'));
+  const plaintext = Buffer.concat([decipher.update(body), decipher.final()]);
+
+  // MediaRetryNotification { stanzaId = 1, directPath = 2, result = 3 }
+  const fields = readFields(plaintext);
+  const result = typeof fields[3] === 'number' ? fields[3] : null;
+
+  return {
+    result,
+    // 1 = SUCCESS in the enum; anything else means the phone could not oblige.
+    ok:         result === 1,
+    directPath: fields[2] ? fields[2].toString('utf8') : null,
+    stanzaId:   fields[1] ? fields[1].toString('utf8') : messageId
+  };
+}
+
+/**
+ * The <receipt> that asks the sender's phone for a re-upload.
+ *
+ * @param {object}   info        { id, chatJid, fromMe, participant }
+ * @param {Buffer}   mediaKey
+ * @param {string}   ownJid      who the receipt is addressed to — ourselves
+ * @param {Function} BinaryNode
+ */
+function buildRetryReceiptNode(info, mediaKey, ownJid, BinaryNode) {
+  const { ciphertext, iv } = encryptRetryReceipt(info.id, mediaKey);
+
+  const rmrAttrs = {
+    jid:      info.chatJid,
+    from_me:  String(!!info.fromMe)
+  };
+  // Only a group receipt names the member the message came from; on a DM the
+  // chat jid already says it, and sending it anyway is a shape no real client
+  // produces.
+  if (info.participant) rmrAttrs.participant = info.participant;
+
+  return new BinaryNode('receipt', {
+    id:   info.id,
+    to:   ownJid,
+    type: 'server-error'
+  }, [
+    new BinaryNode('encrypt', {}, [
+      new BinaryNode('enc_p',  {}, ciphertext),
+      new BinaryNode('enc_iv', {}, iv)
+    ]),
+    new BinaryNode('rmr', rmrAttrs, null)
+  ]);
+}
+
+/**
+ * Read a <notification type="mediaretry"> into the pieces the caller needs.
+ *
+ * Returns null when the node is not one, so a caller can hand it every
+ * notification without checking first. An `error` in the result means the phone
+ * answered but declined — usually because it no longer has the file either.
+ */
+function parseRetryNotification(node, helpers) {
+  const { findChild, getContent } = helpers;
+  const attrs = (node && node.attrs) || {};
+
+  const rmr = findChild(node, 'rmr');
+  if (!rmr) return null;
+
+  const out = {
+    messageId:   attrs.id || null,
+    timestamp:   attrs.t ? Number(attrs.t) : null,
+    chatJid:     (rmr.attrs && rmr.attrs.jid) || null,
+    fromMe:      !!(rmr.attrs && rmr.attrs.from_me === 'true'),
+    participant: (rmr.attrs && rmr.attrs.participant) || null,
+    error:       null,
+    ciphertext:  null,
+    iv:          null
+  };
+
+  const errNode = findChild(node, 'error');
+  if (errNode) {
+    out.error = { code: (errNode.attrs && Number(errNode.attrs.code)) || 0 };
+    return out;
+  }
+
+  const encrypt = findChild(node, 'encrypt');
+  if (encrypt) {
+    const p  = findChild(encrypt, 'enc_p');
+    const ivN = findChild(encrypt, 'enc_iv');
+    out.ciphertext = p   ? getContent(p)   : null;
+    out.iv         = ivN ? getContent(ivN) : null;
+  }
+  return out;
+}
+
+module.exports = {
+  mediaRetryKey,
+  encryptRetryReceipt,
+  decryptRetryNotification,
+  buildRetryReceiptNode,
+  parseRetryNotification,
+  RETRY_KEY_INFO
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "whalibmob",
-  "version": "5.22.0",
-  "description": "WhatsApp library for interaction with WhatsApp Mobile API and web ",
+  "version": "5.23.1",
+  "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",
   "bin": {
@@ -23,13 +23,29 @@
   },
   "keywords": [
     "whatsapp",
+    "whatsapp-api",
+    "whatsapp-bot",
+    "whatsapp-client",
+    "whatsapp-web",
+    "sms-registration",
+    "pairing-code",
+    "qr-code",
+    "companion",
+    "multi-device",
     "signal-protocol",
-    "mobile",
-    "client",
-    "encryption",
     "e2e",
+    "e2ee",
+    "encryption",
+    "mobile",
+    "android",
     "ios",
-    "multi-device"
+    "messaging",
+    "chatbot",
+    "automation",
+    "whatsapp-mobile", 
+    "media",
+    "groups",
+    "channels"
   ],
   "repository": {
     "type": "git",