@codexverified/baileys 2.12.12 → 2.13.13

package/README.md

@@ -27,6 +27,8 @@ The package is maintained by **Codex** under the **CodexVerified** organization.
 - [About Codex](#about-codex)
 - [Package layout](#package-layout)
 - [Security and responsible use](#security-and-responsible-use)
+- [Disclaimer](#disclaimer)
+- [Privacy policy](#privacy-policy)
 - [License and maintenance](#license-and-maintenance)
 - [Compatibility additions](#compatibility-additions)
 - [Comparison references](#comparison-references)
@@ -38,7 +40,7 @@ The package is maintained by **Codex** under the **CodexVerified** organization.
 | Property | Value |
 | --- | --- |
 | Package | `@codexverified/baileys` |
-| Version | `2.12.12` |
+| Version | `2.13.13` |
 | Runtime | Node.js 20 or newer |
 | Module format | ESM, with CommonJS compatibility where supported |
 | Type declarations | Included at `lib/index.d.ts` |
@@ -52,7 +54,7 @@ The package is maintained by **Codex** under the **CodexVerified** organization.
 | Method | Command | Notes |
 | --- | --- | --- |
 | From npm | `npm install @codexverified/baileys` | Standard install when published under your organization |
-| From local archive | `npm install ./codex-baileys-2.12.12.tgz` | Place the `.tgz` beside your application |
+| From local archive | `npm install ./codex-baileys-2.13.13.tgz` | Place the `.tgz` beside your application |
 | Source audit (no scripts) | `npm install --ignore-scripts` | Skips install hooks for local review |
 
 Both npm and archive installs use the same import name:
@@ -341,6 +343,59 @@ This library interacts with WhatsApp accounts and user communications.
 | Transparency | Provide clear notice when an application performs automated actions |
 | Dependency review | Review installation scripts and optional dependencies before deploying to production; use pinned versions for repeatable builds |
 
+## Disclaimer
+
+`@codexverified/baileys` is an independent, source-available Node.js library that communicates with WhatsApp using the Baileys protocol. It is not affiliated with, endorsed by, or officially connected to WhatsApp LLC or Meta Platforms, Inc. "WhatsApp" is a trademark of its respective owner, referenced here only for interoperability description.
+
+**No malware, no phishing, no hidden network calls.** As a matter of project policy and design:
+
+| Statement | Detail |
+| --- | --- |
+| No malicious payloads | The package does not contain, download, execute, or otherwise support malware, spyware, ransomware, keyloggers, or similar malicious code. |
+| No phishing or credential harvesting | The library does not construct, send, or facilitate phishing messages, fake login prompts, or credential-harvesting flows. It provides generic messaging primitives; how an application built on top of them is used is the responsibility of that application's developer. |
+| No covert data exfiltration | The package does not silently transmit your messages, contacts, media, or authentication state to Codex, CodexVerified, or any third party. The only network calls it makes are the ones necessary to connect to WhatsApp's own servers, plus explicitly caller-invoked helpers (such as `checkStatusWA`) that are never triggered automatically. |
+| No obfuscated code | The source is distributed as readable JavaScript/TypeScript with public type declarations, so it can be inspected line by line. Installs can be run with `--ignore-scripts` for an audit-first review, as noted in the [Installation](#installation) table. |
+| Not a guarantee, an invitation to verify | This statement describes the project's design intent and current source code. It is not a substitute for your own review, a third-party security audit, or a legal warranty. You are encouraged to read the source, pin dependency versions, and review any application built on top of this package before deploying it. |
+
+### Developer responsibility and acceptable use
+
+This package gives developers general-purpose building blocks for WhatsApp automation (messaging, groups, newsletters/channels, rich responses, and similar features). Like any general-purpose toolkit, those same building blocks can be pointed at abusive uses by a developer who chooses to. The table below names the patterns this project explicitly does **not** endorse, alongside why they're harmful:
+
+| Prohibited / discouraged use | Why it's a problem |
+| --- | --- |
+| Auto-following WhatsApp channels/newsletters on behalf of users without their explicit, informed consent | Misrepresents the user's intent, inflates follower counts artificially, and can violate WhatsApp's platform policies |
+| Sending unsolicited "channel pill" style promotional messages, forwarded rich-response spam, or bulk broadcast content to people who did not opt in | Standard spam/harassment; damages recipients' experience and violates most anti-spam and consumer-protection laws |
+| Using the bundled diagnostic helpers (e.g. `checkStatusWA`) for bulk number enumeration or unsolicited scanning of phone numbers | Enables targeting and abuse of people who never opted into any check; the helper's own documentation already flags this |
+| Impersonating WhatsApp, Meta, or another party; phishing; credential harvesting | Deceives end users and is illegal in most jurisdictions |
+| Evading WhatsApp's account-integrity enforcement, terms of service, or rate limits | Undermines platform trust and the safety of the messaging ecosystem for everyone |
+
+**Where responsibility sits.** CodexVerified builds and documents the library itself, not the applications developers build with it. If a developer chooses to use this package to do any of the above, **that developer — not CodexVerified or the `@codexverified/baileys` project — is solely responsible for that conduct**, including any legal, financial, or platform consequences that follow from it. The maintainers do not operate, monitor, or have visibility into third-party deployments of this code, and inclusion of a feature in this library is not an endorsement of every way it could be used.
+
+This project's own position is the opposite of the misuse above: CodexVerified is built around respecting user privacy and giving developers transparent, inspectable tools — not around helping anyone spam, deceive, or manipulate WhatsApp users. Developers who build on this package are expected to hold themselves to that same standard.
+
+**No warranty.** This software is provided "as is," without warranty of any kind, express or implied, including but not limited to warranties of merchantability, fitness for a particular purpose, and non-infringement, to the fullest extent permitted by the license declared in `package.json`. Use of this package to interact with WhatsApp may be subject to WhatsApp's own terms of service, which are outside the maintainers' control.
+
+## Privacy policy
+
+This section describes what the package itself does and does not do with data. It does not describe how any particular application built on top of this package handles data — that is determined by the developer of that application.
+
+**Data the package handles locally, on your own infrastructure:**
+
+| Data type | How it's handled |
+| --- | --- |
+| Authentication/session state | Generated and stored wherever your application configures it (e.g. `useMultiFileAuthState('./session')`). The package does not upload this elsewhere. Keep it private, as noted in [Security and responsible use](#security-and-responsible-use). |
+| Messages and media | Sent to and received from WhatsApp's own servers as part of normal protocol operation. The package does not copy, log, or relay this content to Codex, CodexVerified, or any other third party. |
+| Phone numbers passed to optional helpers | `checkStatusWA` sends a phone number to whatever endpoint you configure for that call. This only happens if your code explicitly calls it; the destination and its own privacy practices are your responsibility to review before use. |
+
+**What the package does not do:**
+- It does not phone home, run analytics/telemetry, or transmit usage data to Codex, CodexVerified, or any other party.
+- It does not embed hidden credentials, tracking identifiers, or remote "kill switches."
+- It does not access data outside of what your application explicitly wires it up to.
+
+**Your responsibilities as a developer.** If you build an application on top of this package that collects personal data (e.g. contacts, message content, phone numbers), you are the data controller for that application and are responsible for complying with applicable privacy laws (such as GDPR, CCPA, or Nigeria's NDPA) and with WhatsApp's own terms and business policies. This package is a communication toolkit, not a compliance framework.
+
+**Contact.** Questions about this policy or the project can be sent to codexauthorized@gmail.com or via [@codexverified](https://t.me/codexverified) on Telegram.
+
 ## License and maintenance
 
 This distribution is provided under the license declared in `package.json` and the accompanying license file. Review those terms before redistributing or combining this package with third-party code.
@@ -450,3 +505,121 @@ All networked helpers are opt-in. Website previews fetch only when explicitly ca
 | --- | --- |
 | `state` | Generation status: `GENERATING`, `COMPLETE`, or `ERROR` |
 | `mediaUrl` | URL of the generated media
+
+
+## CODEX-compatible rich messaging additions
+
+The Codex socket now includes the compatible rich-message helpers documented by [`CODEX`](https://github.com/codexverified/baileys), while retaining Codex-specific APIs and package identity. These helpers are opt-in convenience methods over the existing WhatsApp message relay layer.
+
+| Helper | Purpose |
+| --- | --- |
+| `sendRichMedia` | Sends a complete GenAI-style rich response envelope. |
+| `sendRichGeneration` | Sends an AI image/video generation card with a generation state. |
+| `updateRichGeneration` | Replaces an existing generation card using the message-edit protocol. |
+| `sendRichText` | Sends text inside a forwarded rich-response envelope. |
+| `sendRichImage` | Sends an image inside a forwarded rich-response envelope. |
+| `sendRichLink` | Sends inline links inside a forwarded rich-response envelope. |
+| `sendReels` | Sends rich response content containing reel metadata. |
+| `sendRichSources` | Sends rich response content with source metadata. |
+| `sendLink` / `sendLinkV2` | Convenience aliases for rich inline-link responses. |
+| `sendRichWebview` | Sends a native-flow URL CTA for a hosted WebView or Mini App. |
+
+### Rich text, images, and links
+
+```javascript
+await sock.sendRichText(jid, {
+  text: 'A rich response from Codex'
+})
+
+await sock.sendRichImage(jid, {
+  url: 'https://example.com/image.png',
+  mimeType: 'image/png'
+})
+
+await sock.sendRichLink(jid, {
+  text: 'Read the documentation',
+  links: [{ text: 'Documentation', url: 'https://example.com/docs' }]
+})
+```
+
+### AI generation cards
+
+```javascript
+const pending = await sock.sendRichGeneration(jid, {
+  text: 'Generating an image…',
+  mediaType: 'image',
+  status: 'GENERATING',
+  estimatedMs: 5000,
+  itemId: 'image-001'
+})
+
+await sock.updateRichGeneration(jid, pending.messageId, {
+  text: 'Generation complete',
+  mediaType: 'image',
+  status: 'READY',
+  url: 'https://example.com/generated.png',
+  itemId: 'image-001'
+})
+```
+
+`updateRichGeneration` requires the original message identifier returned by `sendRichGeneration`. Generation and rich-response payloads are protocol-sensitive and should be tested against the WhatsApp clients your application supports.
+
+### WebView or Mini App CTA
+
+```javascript
+await sock.sendRichWebview(jid, {
+  title: 'Open the dashboard',
+  text: 'Tap below to continue',
+  buttonText: 'Open dashboard',
+  url: 'https://example.com/dashboard',
+  useWebview: true,
+  toast: 'Opening dashboard'
+})
+```
+
+The URL is validated before serialization. Treat button replies and URL destinations as untrusted input, and perform authorization on the server rather than relying on a button identifier.
+
+### Reels and source metadata
+
+```javascript
+await sock.sendReels(jid, [{
+  url: 'https://example.com/reel.mp4',
+  title: 'Featured reel'
+}], quotedMessage, { text: 'Featured today' })
+
+await sock.sendRichSources(
+  jid,
+  'Useful references',
+  [{ title: 'Project site', url: 'https://example.com' }],
+  quotedMessage
+)
+```
+
+These helpers preserve the existing `quoted` and send-option arguments where supported. The package does not enable background automation or contact discovery as a side effect of using them.
+
+### References
+
+[1]: https://github.com/codexverified/baileys "codexverified/baileys repository"
+
+
+### Prepared-message relay targeting
+
+`relayMessage` now accepts optional delivery-scoping controls compatible with CODEX’s relay API. These controls are intended for prepared messages and retry handling; use them only when the application understands the device-level delivery consequences.
+
+```javascript
+await sock.relayMessage(jid, preparedMessage, {
+  messageId: 'message-id',
+  participant: { jid: '15551234567@s.whatsapp.net' },
+  protected: true
+})
+
+await sock.relayMessage(jid, preparedMessage, {
+  messageId: 'message-id',
+  retryParticipants: {
+    jid: '15551234567:2@s.whatsapp.net',
+    count: 1
+  }
+})
+```
+
+The `participant` option targets recipient-only delivery in a one-to-one chat. `retryParticipants` or `participants` identifies a device for retry resend, while `isSecret`, `protected`, and `me` restrict delivery to the corresponding device classes. These options do not bypass WhatsApp permissions or authorization checks.

package/lib/Defaults/index.js

@@ -2,7 +2,7 @@ import { proto } from '../../WAProto/index.js';
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
-const version = [2, 3000, 1040735178];
+const version = [2, 3000, 1043857760];
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const BIZ_BOT_SUPPORT_PAYLOAD = '{"version":1,"is_ai_message":true,"should_upload_client_logs":false,"should_show_system_message":false,"ticket_id":"7004947587700716","citation_items":[],"ticket_locale":"us"}';
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
@@ -48,13 +48,13 @@ export const DEFAULT_CONNECTION_CONFIG = {
     browser: Browsers.macOS('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
     connectTimeoutMs: 20000,
-    keepAliveIntervalMs: 15000,
+    keepAliveIntervalMs: 30000,
     logger: logger.child({ class: 'baileys' }),
     emitOwnEvents: true,
     defaultQueryTimeoutMs: 60000,
     customUploadHosts: [],
     retryRequestDelayMs: 250,
-    maxMsgRetryCount: 3,
+    maxMsgRetryCount: 5,
     fireInitQueries: true,
     auth: undefined,
     markOnlineOnConnect: true,
@@ -66,7 +66,7 @@ export const DEFAULT_CONNECTION_CONFIG = {
     shouldIgnoreJid: () => false,
     linkPreviewImageThumbnailWidth: 192,
     transactionOpts: { maxCommitRetries: 10, delayBetweenTriesMs: 3000 },
-    generateHighQualityLinkPreview: true,
+    generateHighQualityLinkPreview: false,
     enableAutoSessionRecreation: true,
     enableRecentMessageCache: true,
     options: {},

package/lib/Socket/messages-send.js

@@ -12,6 +12,10 @@ import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinar
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { captureUnifiedResponse, generateButtonGridContent, generateCodeBlockContent, generateLatexContent, generateListContent, generateRichMenuContent, generateTableContent, generateUnifiedResponseContent } from '../Utils/message-composer.js';
 import { Baron } from './interactive-handler.js';
+import { prepareRichResponseMessage, prepareRichGenerationMessage, prepareRichTextMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareHtmlMessage } from '../Utils/rich-message-utils.js';
+import { generateSlotMachineHtml } from '../Utils/games/slot-machine.js';
+import { generateWebsitePreviewHtml, generateLinkPreviewHtml } from '../Utils/website-preview.js';
+import { isViewOnceMessage, downloadViewOnceMedia, createRegularMessageFromViewOnce, parseViewOnceInfo } from '../Utils/view-once-utils.js';
 import { collectMetaAIBotParticipantJids, isMetaAIBotResponse, META_AI_BOT_JID } from './aigroups.js';
 import { makeUsernameSocket } from './username.js';
 
@@ -580,10 +584,12 @@ export const makeMessagesSocket = (config) => {
         return { nodes, shouldIncludeDeviceIdentity };
     };
 
-    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, addBizAttributes, statusJidList, statusPrivacy }) => {
+    const relayMessage = async (jid, message, { messageId: msgId, participant, participants: retryParticipantsOption, retryParticipants: retryParticipantsExplicit, isSecret = false, protected: protectedSend = false, me: meOnly = false, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, addBizAttributes, statusJidList, statusPrivacy }) => {
         const meId = assertMeId(authState.creds);
         const meLid = authState.creds.me?.lid;
-        const isRetryResend = Boolean(participant?.jid);
+        const retryParticipants = retryParticipantsExplicit || retryParticipantsOption || (participant?.count != null ? participant : undefined);
+        const isRetryResend = Boolean(retryParticipants?.jid && retryParticipants?.count != null);
+        const isRecipientOnly = Boolean(participant?.jid && !isRetryResend);
         let shouldIncludeDeviceIdentity = isRetryResend;
         const statusJid = 'status@broadcast';
         const { user, server } = jidDecode(jid);
@@ -601,6 +607,10 @@ export const makeMessagesSocket = (config) => {
         const binaryNodeContent = [];
         const devices = [];
         let reportingMessage;
+        const requiresViewOnce = !!(message.buttonsMessage || message.templateMessage || message.listMessage || message.interactiveMessage);
+        if (requiresViewOnce) {
+            message = { viewOnceMessage: { message: { ...message } } };
+        }
         const meMsg = {
             deviceSentMessage: {
                 destinationJid,
@@ -609,16 +619,15 @@ export const makeMessagesSocket = (config) => {
             messageContextInfo: message.messageContextInfo
         };
         const extraAttrs = {};
-        if (participant) {
+        if (isRetryResend) {
             if (!isGroup && !isStatus) {
                 additionalAttributes = { ...additionalAttributes, device_fanout: 'false' };
             }
-            const { user, device } = jidDecode(participant.jid);
-            devices.push({
-                user,
-                device,
-                jid: participant.jid
-            });
+            const { user, device } = jidDecode(retryParticipants.jid);
+            devices.push({ user, device, jid: retryParticipants.jid });
+        }
+        if ((isRecipientOnly || isSecret || protectedSend || meOnly) && !isGroup && !isStatus) {
+            additionalAttributes = { ...additionalAttributes, device_fanout: 'false' };
         }
         await authState.keys.transaction(async () => {
             const innerMessage = normalizeMessageContent(message);
@@ -824,6 +833,11 @@ export const makeMessagesSocket = (config) => {
                         continue;
                     }
                     const isMe = user === mePnUser || user === meLidUser;
+                    const hasDevice = jid.includes(':');
+                    if (isRecipientOnly && isMe) continue;
+                    if (isSecret && !(!isMe && !hasDevice)) continue;
+                    if (protectedSend && !isMe && hasDevice) continue;
+                    if (meOnly && !isMe) continue;
                     if (isMe) {
                         meRecipients.push(jid);
                     }
@@ -845,8 +859,8 @@ export const makeMessagesSocket = (config) => {
                 shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || s1 || s2;
             }
             if (isRetryResend) {
-                const isParticipantLid = isLidUser(participant.jid);
-                const isMe = areJidsSameUser(participant.jid, isParticipantLid ? meLid : meId);
+                const isParticipantLid = isLidUser(retryParticipants.jid);
+                const isMe = areJidsSameUser(retryParticipants.jid, isParticipantLid ? meLid : meId);
                 let messageToSend = message;
                 if (isGroupOrStatus) {
                     let groupSenderIdentity;
@@ -892,7 +906,7 @@ export const makeMessagesSocket = (config) => {
                     attrs: {
                         v: '2',
                         type,
-                        count: (participant.count || 0).toString()
+                        count: retryParticipants.count.toString()
                     },
                     content: encryptedContent
                 });
@@ -922,17 +936,17 @@ export const makeMessagesSocket = (config) => {
                 },
                 content: binaryNodeContent
             };
-            if (participant) {
+            if (isRetryResend) {
                 if (isJidGroup(destinationJid)) {
                     stanza.attrs.to = destinationJid;
-                    stanza.attrs.participant = participant.jid;
+                    stanza.attrs.participant = retryParticipants.jid;
                 }
-                else if (areJidsSameUser(participant.jid, meId)) {
-                    stanza.attrs.to = participant.jid;
+                else if (areJidsSameUser(retryParticipants.jid, meId)) {
+                    stanza.attrs.to = retryParticipants.jid;
                     stanza.attrs.recipient = destinationJid;
                 }
                 else {
-                    stanza.attrs.to = participant.jid;
+                    stanza.attrs.to = retryParticipants.jid;
                 }
             }
             else {
@@ -956,7 +970,7 @@ export const makeMessagesSocket = (config) => {
                         id: msgId,
                         fromMe: true,
                         remoteJid: destinationJid,
-                        participant: participant?.jid
+                        participant: retryParticipants?.jid
                     };
                     const reportingNode = await getMessageReportingToken(encoded, reportingMessage, reportingKey);
                     if (reportingNode) {
@@ -1046,7 +1060,7 @@ export const makeMessagesSocket = (config) => {
                     inFlightTcTokenIssuance.delete(tcTokenJid);
                 });
             }
-            if (messageRetryManager && !participant) {
+            if (messageRetryManager && !retryParticipants) {
                 messageRetryManager.addRecentMessage(destinationJid, msgId, message);
             }
         }, meId);
@@ -1179,7 +1193,7 @@ export const makeMessagesSocket = (config) => {
         followingCache.clear();
     });
 
-    return {
+    const socket = {
         ...sock,
         userDevicesCache,
         devicesMutex,
@@ -1265,6 +1279,105 @@ export const makeMessagesSocket = (config) => {
             await relayMessage(jid, message, { messageId });
             return { message, messageId };
         },
+        /** Send a complete GenAI-style rich response envelope. */
+        sendRichMedia: async (jid, content = {}, quoted, options = {}) => {
+            const message = prepareRichResponseMessage({ ...content, noDonation: options.noDonation ?? true });
+            const messageId = generateMessageIDV2(jid);
+            await relayMessage(jid, message, { messageId, quoted });
+            return { message, messageId };
+        },
+        /** Send a native AI image/video generation card. */
+        sendRichGeneration: async (jid, content = {}, quoted, options = {}) => {
+            const generated = prepareRichGenerationMessage({
+                ...content,
+                responseId: options.responseId,
+                forwarded: options.forwarded !== false
+            });
+            const messageId = generateMessageIDV2(jid);
+            await relayMessage(jid, generated.message, { messageId, quoted });
+            return { ...generated, messageId };
+        },
+        /** Edit an existing rich generation card in place. */
+        updateRichGeneration: async (jid, targetId, content = {}, options = {}) => {
+            if (!jid) throw new Boom('updateRichGeneration requires a target JID', { statusCode: 400 });
+            if (!targetId) throw new Boom('updateRichGeneration requires the original message ID', { statusCode: 400 });
+            const generated = prepareRichGenerationMessage({
+                ...content,
+                responseId: options.responseId,
+                itemId: options.itemId || content.itemId,
+                forwarded: options.forwarded !== false
+            });
+            const editedMessage = generateWAMessageFromContent(jid, {
+                botForwardedMessage: {
+                    message: {
+                        protocolMessage: {
+                            key: { remoteJid: jid, fromMe: true, id: targetId },
+                            type: proto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
+                            editedMessage: generated.message
+                        }
+                    }
+                }
+            }, { messageId: generateMessageIDV2(jid) });
+            await relayMessage(jid, editedMessage.message, { messageId: editedMessage.key.id });
+            return { ...generated, messageId: editedMessage.key.id, targetId };
+        },
+        /** Send plain text inside a forwarded GenAI rich response. */
+        sendRichText: async (jid, content = {}, options = {}) => {
+            const message = prepareRichTextMessage(content);
+            const messageId = generateMessageIDV2(jid);
+            await relayMessage(jid, message, { messageId, quoted: options.quoted });
+            return { message, messageId };
+        },
+        /** Send an image inside a forwarded GenAI rich response. */
+        sendRichImage: async (jid, content = {}, options = {}) => {
+            const message = prepareRichImageMessage(content);
+            const messageId = generateMessageIDV2(jid);
+            await relayMessage(jid, message, { messageId, quoted: options.quoted });
+            return { message, messageId };
+        },
+        /** Send inline hyperlinks inside a forwarded GenAI rich response. */
+        sendRichLink: async (jid, content = {}, options = {}) => {
+            const message = prepareRichLinkMessage(content);
+            const messageId = generateMessageIDV2(jid);
+            await relayMessage(jid, message, { messageId, quoted: options.quoted });
+            return { message, messageId };
+        },
+        sendReels: async (jid, reels, quoted, options = {}) => {
+            const message = prepareRichResponseMessage({ contentText: options.text || '', reels, noDonation: options.noDonation ?? true });
+            const messageId = generateMessageIDV2(jid);
+            await relayMessage(jid, message, { messageId, quoted });
+            return { message, messageId };
+        },
+        sendRichSources: async (jid, text, sources, quoted, options = {}) => {
+            const message = prepareRichResponseMessage({ contentText: text, sources, noDonation: options.noDonation ?? true });
+            const messageId = generateMessageIDV2(jid);
+            await relayMessage(jid, message, { messageId, quoted });
+            return { message, messageId };
+        },
+        sendLink: async (jid, text, links, quoted, options = {}) => {
+            const message = prepareRichLinkMessage({ text, links });
+            const messageId = generateMessageIDV2(jid);
+            await relayMessage(jid, message, { messageId, quoted });
+            return { message, messageId };
+        },
+        sendLinkV2: async (jid, text, links, quoted, options = {}) => {
+            const message = prepareRichLinkMessage({ text, links });
+            const messageId = generateMessageIDV2(jid);
+            await relayMessage(jid, message, { messageId, quoted });
+            return { message, messageId };
+        },
+        /** Send a native-flow URL CTA for a hosted WebView/Mini App. */
+        sendRichWebview: async (jid, content = {}, options = {}) => {
+            const { text = '', title, footer, image, caption, buttonText = 'Open', url, useWebview = true, toast, ...rest } = content;
+            if (!url || typeof url !== 'string') throw new Boom('sendRichWebview requires a URL', { statusCode: 400 });
+            const button = { text: buttonText, url, useWebview, ...(toast ? { toast } : {}), ...rest };
+            return sock.sendMessage(jid, {
+                ...(image ? { image, caption: caption || text || title || buttonText } : { text: text || title || buttonText }),
+                ...(footer ? { footer } : {}),
+                nativeFlow: [button],
+                ...(toast ? { toast } : {})
+            }, options);
+        },
         sendMetaAI: async (a, b, c = {}) => {
             // baron signature: (jid, text, opts)  README signature: (text, opts)
             let text;
@@ -2070,5 +2183,64 @@ export const makeMessagesSocket = (config) => {
                 return fullMsg;
             }
         }
-    }
+    };
+
+    socket.autoVV = async (message, options = {}) => {
+        if (!isViewOnceMessage(message)) return null;
+        const info = parseViewOnceInfo(message);
+        const mediaBuffer = await downloadViewOnceMedia(message, { logger, ...options });
+        const regularMessage = createRegularMessageFromViewOnce(message, mediaBuffer);
+        if (regularMessage) ev.emit('messages.upsert', { messages: [regularMessage], type: 'append' });
+        logger.info({ key: message?.key, ...info, bufferSize: mediaBuffer.length }, 'autoVV: successfully decrypted view-once message');
+        return regularMessage;
+    };
+
+    socket.antiVV = async (message) => {
+        if (!isViewOnceMessage(message)) return false;
+        const info = parseViewOnceInfo(message);
+        const jid = message.key.remoteJid;
+        const participant = message.key.participant || jid;
+        await sendReceipt(jid, participant, [message.key.id], 'sender');
+        ev.emit('messages.update', [{ key: message.key, update: { messageStubType: proto.WebMessageInfo.StubType.REVOKE, messageStubParameters: ['auto-vv-delete'] } }]);
+        logger.info({ key: message?.key, ...info }, 'antiVV: successfully deleted view-once message');
+        return true;
+    };
+
+    socket.isViewOnce = (message) => isViewOnceMessage(message);
+    socket.getViewOnceInfo = (message) => parseViewOnceInfo(message);
+
+    socket.sendLatexImage = async (jid, options = {}) => {
+        const { text, expressions = [], headerText, footer } = options;
+        const renderedExpressions = expressions.map(expr => {
+            const latex = expr?.latexExpression || expr?.expression || expr;
+            return { latexExpression: latex, url: `https://latex.codecogs.com/png.latex?${encodeURIComponent(latex).replace(/'/g, '%27')}`, width: expr?.width || 400, height: expr?.height || 100 };
+        });
+        const { message, messageId } = generateLatexContent(null, { text, expressions: renderedExpressions, headerText, footer });
+        await relayMessage(jid, message, { messageId });
+        return { message, messageId };
+    };
+
+    socket.sendHtmlMessage = async (jid, content = {}, options = {}) => {
+        if (!jid) throw new Boom('sendHtmlMessage requires a target JID', { statusCode: 400 });
+        if (!content.html) throw new Boom('sendHtmlMessage requires html content', { statusCode: 400 });
+        const fullMsg = await generateWAMessageFromContent(jid, prepareHtmlMessage(content), { logger, userJid: authState.creds.me?.id, messageId: options.messageId || generateMessageIDV2(authState.creds.me?.id), ...options });
+        await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, statusJidList: options.statusJidList });
+        return fullMsg;
+    };
+
+    socket.sendSlotMachine = async (jid, options = {}, sendOptions = {}) => {
+        return socket.sendHtmlMessage(jid, { html: generateSlotMachineHtml(options) }, sendOptions);
+    };
+
+    socket.sendWebsitePreview = async (jid, url, options = {}, sendOptions = {}) => {
+        if (!url) throw new Boom('sendWebsitePreview requires a URL', { statusCode: 400 });
+        return socket.sendHtmlMessage(jid, { html: await generateWebsitePreviewHtml(url, options) }, sendOptions);
+    };
+
+    socket.sendLinkPreview = async (jid, url, options = {}, sendOptions = {}) => {
+        if (!url) throw new Boom('sendLinkPreview requires a URL', { statusCode: 400 });
+        return socket.sendHtmlMessage(jid, { html: generateLinkPreviewHtml(url, options) }, sendOptions);
+    };
+
+    return socket;
 };

package/lib/Utils/history.js

@@ -1,5 +1,6 @@
 import { promisify } from 'util';
-import { inflate } from 'zlib';
+import { pipeline } from 'stream/promises';
+import { createInflate, inflate } from 'zlib';
 import { proto } from '../../WAProto/index.js';
 import { WAMessageStubType } from '../Types/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/index.js';
@@ -24,13 +25,13 @@ const extractPnFromMessages = (messages) => {
 };
 export const downloadHistory = async (msg, options) => {
     const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
-    const bufferArray = [];
-    for await (const chunk of stream) {
-        bufferArray.push(chunk);
-    }
-    let buffer = Buffer.concat(bufferArray);
-    // decompress buffer
-    buffer = await inflatePromise(buffer);
+    // Pipe the decrypted stream directly through zlib inflate to avoid
+    // allocating an additional intermediate compressed-data buffer.
+    const inflater = createInflate();
+    const chunks = [];
+    inflater.on('data', (chunk) => chunks.push(chunk));
+    await pipeline(stream, inflater);
+    const buffer = Buffer.concat(chunks);
     const syncData = proto.HistorySync.decode(buffer);
     return syncData;
 };
@@ -55,6 +56,7 @@ export const processHistoryMessage = (item, logger) => {
                 contacts.push({
                     id: chat.id,
                     name: chat.displayName || chat.name || chat.username || undefined,
+                    username: chat.username || undefined,
                     lid: chat.lidJid || chat.accountLid || undefined,
                     phoneNumber: chat.pnJid || undefined
                 });
@@ -95,7 +97,7 @@ export const processHistoryMessage = (item, logger) => {
                         });
                     }
                 }
-                chats.push({ ...chat });
+                chats.push(chat);
             }
             break;
         case proto.HistorySync.HistorySyncType.PUSH_NAME:
@@ -109,6 +111,7 @@ export const processHistoryMessage = (item, logger) => {
         contacts,
         messages,
         lidPnMappings,
+        pastParticipants: item.pastParticipants,
         syncType: item.syncType,
         progress: item.progress
     };
@@ -127,4 +130,4 @@ export const getHistoryMsg = (message) => {
     const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
     const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
     return anyHistoryMsg;
-};
+};

package/lib/Utils/message-retry-manager.js

@@ -52,6 +52,13 @@ export class MessageRetryManager {
             ttlAutopurge: true,
             updateAgeOnGet: true
         }); // 15 minutes TTL
+        // Cache Signal base keys briefly so duplicate retry receipts can be
+        // recognized without repeatedly recreating an otherwise valid session.
+        this.baseKeys = new LRUCache({
+            max: 1024,
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true
+        });
         this.pendingPhoneRequests = {};
         this.maxMsgRetryCount = 5;
         this.statistics = {
@@ -215,6 +222,7 @@ export class MessageRetryManager {
         this.messageKeyIndex.clear();
         this.sessionRecreateHistory.clear();
         this.retryCounters.clear();
+        this.baseKeys.clear();
         for (const messageId of Object.keys(this.pendingPhoneRequests)) {
             this.cancelPendingPhoneRequest(messageId);
         }
@@ -227,6 +235,24 @@ export class MessageRetryManager {
             phoneRequests: 0
         };
     }
+    saveBaseKey(addr, msgId, baseKey) {
+        this.baseKeys.set(`${addr}:${msgId}`, baseKey);
+    }
+    hasSameBaseKey(addr, msgId, baseKey) {
+        const stored = this.baseKeys.get(`${addr}:${msgId}`);
+        if (!stored || stored.length !== baseKey.length) {
+            return false;
+        }
+        for (let i = 0; i < stored.length; i++) {
+            if (stored[i] !== baseKey[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    deleteBaseKey(addr, msgId) {
+        this.baseKeys.delete(`${addr}:${msgId}`);
+    }
     keyToString(key) {
         return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`;
     }
@@ -238,4 +264,4 @@ export class MessageRetryManager {
         this.recentMessagesMap.delete(keyStr);
         this.messageKeyIndex.delete(messageId);
     }
-}
+}

package/lib/Utils/process-message.js

@@ -5,6 +5,7 @@ import { areJidsSameUser, isHostedLidUser, isHostedPnUser, isJidBroadcast, isJid
 import { aesDecryptGCM, hmacSign } from './crypto.js';
 import { getKeyAuthor, toNumber } from './generics.js';
 import { downloadAndProcessHistorySyncNotification } from './history.js';
+import { buildMergedTcTokenIndexWrite, resolveTcTokenJid } from './tc-token-utils.js';
 const REAL_MSG_STUB_TYPES = new Set([
     WAMessageStubType.CALL_MISSED_GROUP_VIDEO,
     WAMessageStubType.CALL_MISSED_GROUP_VOICE,
@@ -12,6 +13,52 @@ const REAL_MSG_STUB_TYPES = new Set([
     WAMessageStubType.CALL_MISSED_VOICE
 ]);
 const REAL_MSG_REQ_ME_STUB_TYPES = new Set([WAMessageStubType.GROUP_PARTICIPANT_ADD]);
+async function storeTcTokensFromHistorySync(chats, signalRepository, keyStore, logger) {
+    const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
+    const candidates = [];
+    for (const chat of chats || []) {
+        const ts = chat.tcTokenTimestamp ? toNumber(chat.tcTokenTimestamp) : 0;
+        if (chat.tcToken?.length && ts > 0) {
+            const jid = jidNormalizedUser(chat.id);
+            const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+            candidates.push({
+                storageJid,
+                token: Buffer.from(chat.tcToken),
+                ts,
+                senderTs: chat.tcTokenSenderTimestamp ? toNumber(chat.tcTokenSenderTimestamp) : undefined
+            });
+        }
+    }
+    if (!candidates.length) {
+        return;
+    }
+    const jids = candidates.map(candidate => candidate.storageJid);
+    const existing = await keyStore.get('tctoken', jids);
+    const entries = {};
+    for (const candidate of candidates) {
+        const existingEntry = existing[candidate.storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        if (existingTs > 0 && existingTs >= candidate.ts) {
+            continue;
+        }
+        entries[candidate.storageJid] = {
+            ...existingEntry,
+            token: candidate.token,
+            timestamp: String(candidate.ts),
+            ...(candidate.senderTs !== undefined ? { senderTimestamp: candidate.senderTs } : {})
+        };
+    }
+    if (Object.keys(entries).length) {
+        logger?.debug({ count: Object.keys(entries).length }, 'storing tctokens from history sync');
+        try {
+            const indexWrite = await buildMergedTcTokenIndexWrite(keyStore, Object.keys(entries));
+            await keyStore.set({ tctoken: { ...entries, ...indexWrite } });
+        }
+        catch (err) {
+            logger?.warn({ err }, 'failed to store tctokens from history sync');
+        }
+    }
+}
 /** Cleans a received message to further processing */
 export const cleanMessage = (message, meId, meLid) => {
     // ensure remoteJid and participant doesn't have device or agent in it
@@ -146,6 +193,22 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
     }
     const protocolMsg = content?.protocolMessage;
     if (protocolMsg) {
+        // These protocol messages are generated by the user’s primary device and
+        // must not be accepted from an arbitrary remote sender. Other protocol
+        // types, such as revokes and edits, legitimately originate from peers.
+        const SELF_ONLY_TYPES = new Set([
+            proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION,
+            proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE,
+            proto.Message.ProtocolMessage.Type.LID_MIGRATION_MAPPING_SYNC,
+            proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE
+        ]);
+        if (protocolMsg.type !== null &&
+            protocolMsg.type !== undefined &&
+            SELF_ONLY_TYPES.has(protocolMsg.type) &&
+            !message.key.fromMe) {
+            logger?.warn({ msgId: message.key.id, type: protocolMsg.type, from: message.key.participant || message.key.remoteJid }, 'dropping spoofed self-only protocolMessage from non-self origin');
+            return;
+        }
         switch (protocolMsg.type) {
             case proto.Message.ProtocolMessage.Type.HISTORY_SYNC_NOTIFICATION:
                 const histNotification = protocolMsg.historySyncNotification;
@@ -174,6 +237,7 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                             .storeLIDPNMappings(data.lidPnMappings)
                             .catch(err => logger?.warn({ err }, 'failed to store LID-PN mappings from history sync'));
                     }
+                    await storeTcTokensFromHistorySync(data.chats, signalRepository, keyStore, logger);
                     ev.emit('messaging-history.set', {
                         ...data,
                         isLatest: histNotification.syncType !== proto.HistorySync.HistorySyncType.ON_DEMAND ? isLatest : undefined,
@@ -383,12 +447,19 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             id: jid,
             author: message.key.participant,
             authorPn: message.key.participantAlt,
+            authorUsername: message.key.participantUsername,
             participants,
             action
         });
         const emitGroupUpdate = (update) => {
             ev.emit('groups.update', [
-                { id: jid, ...update, author: message.key.participant ?? undefined, authorPn: message.key.participantAlt }
+                {
+                    id: jid,
+                    ...update,
+                    author: message.key.participant ?? undefined,
+                    authorPn: message.key.participantAlt,
+                    authorUsername: message.key.participantUsername
+                }
             ]);
         };
         const emitGroupRequestJoin = (participant, action, method) => {
@@ -396,6 +467,7 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                 id: jid,
                 author: message.key.participant,
                 authorPn: message.key.participantAlt,
+                authorUsername: message.key.participantUsername,
                 participant: participant.lid,
                 participantPn: participant.pn,
                 action,
@@ -524,4 +596,4 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
         ev.emit('chats.update', [chat]);
     }
 };
-export default processMessage;
+export default processMessage;

package/lib/Utils/tc-token-utils.js

@@ -102,7 +102,8 @@ export async function buildTcTokenFromJid({ authState, jid, baseContent = [], ge
         const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
         const entry = tcTokenData?.[storageJid];
         const tcTokenBuffer = entry?.token;
-        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+        const timestamp = entry?.timestamp;
+        if (!tcTokenBuffer?.length || timestamp === undefined || isTcTokenExpired(timestamp)) {
             if (tcTokenBuffer) {
                 // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
                 // after we drop the unusable peer token. Only wipe the record entirely when
@@ -116,7 +117,7 @@ export async function buildTcTokenFromJid({ authState, jid, baseContent = [], ge
         }
         baseContent.push({
             tag: 'tctoken',
-            attrs: {},
+            attrs: { t: String(timestamp) },
             content: tcTokenBuffer
         });
         return baseContent;

package/lib/Utils/use-multi-file-auth-state.js

@@ -1,5 +1,5 @@
 import { Mutex } from 'async-mutex';
-import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
+import { mkdir, readFile, rename, stat, unlink, writeFile } from 'fs/promises';
 import { join } from 'path';
 import { proto } from '../../WAProto/index.js';
 import { initAuthCreds } from './auth-utils.js';
@@ -31,10 +31,14 @@ export const useMultiFileAuthState = async (folder) => {
         const filePath = join(folder, fixFileName(file));
         const mutex = getFileLock(filePath);
         return mutex.acquire().then(async (release) => {
+            const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
             try {
-                await writeFile(filePath, JSON.stringify(data, BufferJSON.replacer));
+                const serialized = JSON.stringify(data, BufferJSON.replacer);
+                await writeFile(tempPath, serialized, { encoding: 'utf8', mode: 0o600 });
+                await rename(tempPath, filePath);
             }
             finally {
+                await unlink(tempPath).catch(() => undefined);
                 release();
             }
         });
@@ -81,7 +85,7 @@ export const useMultiFileAuthState = async (folder) => {
         }
     }
     else {
-        await mkdir(folder, { recursive: true });
+        await mkdir(folder, { recursive: true, mode: 0o700 });
     }
     const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
     const creds = (await readData('creds.json')) || initAuthCreds();
@@ -117,4 +121,4 @@ export const useMultiFileAuthState = async (folder) => {
             return writeData(creds, 'creds.json');
         }
     };
-};
+};

package/lib/Utils/validate-connection.js

@@ -28,7 +28,7 @@ const getUserAgent = (config) => {
 };
 const PLATFORM_MAP = {
     'Mac OS': proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
-    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+    Windows: proto.ClientPayload.WebInfo.WebSubPlatform.WIN_HYBRID
 };
 const getWebInfo = (config) => {
     let webSubPlatform = proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
@@ -48,6 +48,9 @@ const getClientPayload = (config) => {
     if (!config.browser[1].toLocaleLowerCase().includes('android')) {
         payload.webInfo = getWebInfo(config);
     }
+    if (config.pushName) {
+        payload.pushName = config.pushName;
+    }
     return payload;
 };
 export const generateLoginNode = (userJid, config) => {
@@ -203,4 +206,4 @@ export const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
         account.accountSignatureKey = null;
     }
     return proto.ADVSignedDeviceIdentity.encode(account).finish();
-};
+};

package/lib/index.d.ts

@@ -121,8 +121,47 @@ export interface AIPromptOptions {
     [key: string]: unknown;
 }
 
+export interface RelayMessageOptions {
+    messageId?: string;
+    /** Recipient-only delivery: skip the sender’s own devices in a one-to-one chat. */
+    participant?: { jid: string };
+    /** Retry resend target with a device JID and retry count. */
+    participants?: { jid: string; count: number };
+    retryParticipants?: { jid: string; count: number };
+    /** Keep only the target’s primary device. */
+    isSecret?: boolean;
+    /** Skip the target’s linked devices. */
+    protected?: boolean;
+    /** Keep only the sender’s own devices. */
+    me?: boolean;
+    [key: string]: unknown;
+}
+
+export interface RichGenerationContent {
+    text?: string;
+    mediaType?: 'image' | 'video' | string;
+    url?: string;
+    thumbnail?: string | Uint8Array | Record<string, unknown>;
+    mimeType?: string;
+    fileLength?: number;
+    duration?: number;
+    status?: 'GENERATING' | 'READY' | 'FAILED' | string;
+    estimatedMs?: number;
+    itemId?: string;
+}
+
+export interface RichGenerationResult {
+    message: unknown;
+    messageId: string;
+    responseId?: string;
+    itemId?: string;
+    targetId?: string;
+}
+
 export interface WASocket {
     sendMessage(jid: string | string[], content: StatusContent | GroupStatusContent | Record<string, unknown>, options?: Partial<StatusOptions> & Record<string, unknown>): Promise<unknown>;
+    /** Relay a prepared message with optional recipient/device-scoping controls. */
+    relayMessage(jid: string, message: Record<string, unknown>, options?: RelayMessageOptions): Promise<unknown>;
     deleteGroupStatus(jid: string, key: WAMessageKey): Promise<unknown>;
     /** Reports the contact and blocks it after WhatsApp accepts the report. */
     reportContact(jid: string, messageKeys?: WAMessageKey[]): Promise<unknown>;
@@ -265,6 +304,41 @@ export interface WASocket {
     sendInteractiveTable(jid: string, table: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
     /** Send a WhatsApp native flow button. */
     sendWhatsAppFlow(jid: string, flow: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a complete GenAI-style rich response envelope. */
+    sendRichMedia(jid: string, content?: Record<string, unknown>, quoted?: unknown, options?: Record<string, unknown>): Promise<{ message: unknown; messageId: string }>;
+    /** Send a native AI image/video generation card. */
+    sendRichGeneration(jid: string, content?: RichGenerationContent, quoted?: unknown, options?: Record<string, unknown>): Promise<RichGenerationResult>;
+    /** Edit an existing rich generation card in place. */
+    updateRichGeneration(jid: string, targetId: string, content?: RichGenerationContent, options?: Record<string, unknown>): Promise<RichGenerationResult>;
+    /** Send plain text inside a forwarded GenAI rich response. */
+    sendRichText(jid: string, content?: { text?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send an image inside a forwarded GenAI rich response. */
+    sendRichImage(jid: string, content?: { url?: string; mimeType?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send inline hyperlinks inside a forwarded GenAI rich response. */
+    sendRichLink(jid: string, content?: { links?: Array<Record<string, unknown>>; text?: string }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send rich media with reels or source metadata. */
+    sendReels(jid: string, reels: unknown, quoted?: unknown, options?: Record<string, unknown>): Promise<unknown>;
+    sendRichSources(jid: string, text: string, sources: unknown, quoted?: unknown, options?: Record<string, unknown>): Promise<unknown>;
+    sendLink(jid: string, text: string, links: unknown, quoted?: unknown, options?: Record<string, unknown>): Promise<unknown>;
+    sendLinkV2(jid: string, text: string, links: unknown, quoted?: unknown, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send a native-flow URL CTA for a hosted WebView/Mini App. */
+    sendRichWebview(jid: string, content: { text?: string; title?: string; footer?: string; image?: unknown; caption?: string; buttonText?: string; url: string; useWebview?: boolean; toast?: string; [key: string]: unknown }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Decrypt a view-once message and emit the recovered regular message. */
+    autoVV(message: unknown, options?: Record<string, unknown>): Promise<unknown>;
+    /** Revoke a received view-once message and emit a local removal update. */
+    antiVV(message: unknown, options?: Record<string, unknown>): Promise<boolean>;
+    isViewOnce(message: unknown): boolean;
+    getViewOnceInfo(message: unknown): Record<string, unknown>;
+    /** Send LaTeX expressions using Codecogs PNG URLs. */
+    sendLatexImage(jid: string, options?: { text?: string; expressions?: Array<Record<string, unknown> | string>; headerText?: string; footer?: string }): Promise<unknown>;
+    /** Render and send HTML as a rich response. */
+    sendHtmlMessage(jid: string, content: { html: string; trustedSources?: string[] }, options?: Record<string, unknown>): Promise<unknown>;
+    /** Send the built-in HTML slot-machine payload. */
+    sendSlotMachine(jid: string, options?: { title?: string; startingCredits?: number }, sendOptions?: Record<string, unknown>): Promise<unknown>;
+    /** Send a fetched website preview as an HTML rich response. */
+    sendWebsitePreview(jid: string, url: string, options?: Record<string, unknown>, sendOptions?: Record<string, unknown>): Promise<unknown>;
+    /** Send a lightweight HTML link-preview card. */
+    sendLinkPreview(jid: string, url: string, options?: Record<string, unknown>, sendOptions?: Record<string, unknown>): Promise<unknown>;
 
     // ---- GraphQL layer ----
     setAccessToken(token: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@codexverified/baileys",
-   "version": "2.12.12",
+   "version": "2.13.13",
    "description": "CODEX TECHNOLOGY  a premium Baileys developed and built by Dev Codex, with Meta compositing, bot planning replay, welcome flow, rich messages, interactive messages, albums, and more.",
    "main": "lib/index.js",
    "type": "module",