@itsliaaa/baileys 0.1.17 → 0.1.19

package/README.md

@@ -1,8 +1,36 @@
 # 🌱 @itsliaaa/baileys
 
-![Logo](https://files.catbox.moe/c5s9g0.jpg)
-
-A lightweight fork of Baileys with a few fixes and a small adjustment.
+[![Logo](https://files.catbox.moe/c5s9g0.jpg)](https://www.npmjs.com/package/@itsliaaa/baileys)
+
+<p align="center">
+   <a href="https://www.npmjs.com/package/@itsliaaa/baileys">
+      <img src="https://img.shields.io/npm/v/@itsliaaa/baileys?color=FFFFFF&labelColor=red&logo=npm&logoColor=white&style=for-the-badge"/>
+   </a>
+   <a href="https://www.npmjs.com/package/@itsliaaa/baileys">
+      <img src="https://img.shields.io/npm/dm/@itsliaaa/baileys?color=FFFFFF&labelColor=red&logo=npm&logoColor=white&style=for-the-badge"/>
+   </a>
+   <a href="https://github.com/itsliaaa/baileys">
+      <img src="https://img.shields.io/github/stars/itsliaaa/baileys?color=FFFFFF&labelColor=black&logo=github&logoColor=white&style=for-the-badge"/>
+   </a>
+   <a href="LICENSE">
+      <img src="https://img.shields.io/badge/license-MIT-blue?labelColor=black&style=for-the-badge"/>
+   </a>
+   <a href="https://nodejs.org">
+      <img src="https://img.shields.io/badge/node-%3E%3D20-339933?logo=node.js&labelColor=green&logoColor=white&style=for-the-badge"/>
+   </a>
+   <a href="#">
+      <img src="https://img.shields.io/badge/ESM-only?logo=javascript&labelColor=yellow&logoColor=black&style=for-the-badge"/>
+   </a>
+</p>
+
+A lightweight fork of Baileys with practical fixes and small but meaningful improvements.
+
+### ✨ Highlights
+
+This fork focuses on clarity and safety:
+
+- 🚫 No obfuscation. Easy to read and audit.
+- 🚫 No auto-follow channel (newsletter) behavior.
 
 ### ⚙️ Changes
 
@@ -10,12 +38,19 @@ A lightweight fork of Baileys with a few fixes and a small adjustment.
 - 🖼️ Fixed an issue where media could not be sent to newsletters due to an upstream issue.
 - 📁 Reintroduced [`makeInMemoryStore`](#%EF%B8%8F-implementing-a-data-store) with a minimal ESM adaptation and small adjustments for Baileys v7.
 - 📦 Switched FFmpeg execution from `exec` to `spawn` for safer process handling.
-- 🗃️ Added `@napi-rs/image` as a supported image processing backend in `getImageProcessingLibrary()`, offering a balance between performance and compatibility.
+- 🗃️ Added [`@napi-rs/image`](https://www.npmjs.com/package/@napi-rs/image) as a supported image processing backend in [`getImageProcessingLibrary()`](#%EF%B8%8F-image-processing), offering a balance between performance and compatibility.
 
 #### 📨 Message Handling & Compatibility
-- 👉🏻 Added support for sending [interactive message](#-sending-interactive-messages) types (button, list, interactive, template, carousel).
-- 📩 Added support for [album messages](#%EF%B8%8F-album-image--video), [group status messages](#4%EF%B8%8F⃣-group-status), [status mention messages](#%EF%B8%8F-status-mention), [sticker pack messages](#-sticker-pack), and several [payment-related messages](#-sending-payment-messages) (request payment, payment invite, order, invoice).
-- 📰 Simplified sending messages with ad thumbnails via [`externalAdReply`](#3%EF%B8%8F⃣-external-ad-reply) without requiring manual `contextInfo`.
+- 👉🏻 Added support for sending [interactive messages](#-sending-interactive-messages) (buttons, lists, interactive, templates, carousel).
+- 📩 Expanded message support for:
+   - [album messages](#%EF%B8%8F-album-image--video)
+   - [group status messages](#4%EF%B8%8F⃣-group-status)
+   - [status mention messages](#%EF%B8%8F-status-mention)
+   - [sticker pack messages](#-sticker-pack)
+   - [messages with code blocks](#-message-with-code-block)
+   - [messages with tables](#-message-with-table)
+   - [payment-related messages](#-sending-payment-messages) (payment requests, invites, orders, invoices).
+- 📰 Simplified sending messages with ad thumbnails using [`externalAdReply`](#3%EF%B8%8F⃣-external-ad-reply), without requiring manual `contextInfo`.
 
 #### 🧩 Additional Message Options
 - 👁️ Added optional boolean flags for message handling:  
@@ -370,6 +405,32 @@ sock.sendMessage([jidA, jidB, jidC], {
 })
 ```
 
+##### 🧾 Message with Code Block
+
+```javascript
+sock.sendMessage(jid, {
+   header: 'Example Usage',
+   code: 'console.log("Hello, World!")',
+   footer: 'Pretty simple, right?',
+   language: 'javascript'
+})
+```
+
+##### 📋 Message with Table
+
+```javascript
+sock.sendMessage(jid, {
+   header: 'Comparison between Node.js, Bun, and Deno',
+   title: 'Runtime Comparison',
+   table: [
+      ['', 'Node.js', 'Bun', 'Deno'],
+      ['Engine', 'V8 (C++)', 'JavaScriptCore (C++)', 'V8 (C++)'],
+      ['Performance', '4/5', '5/5', '4/5']
+   ],
+   footer: 'Does this help clarify the differences?'
+})
+```
+
 #### 📁 Sending Media Messages
 
 > [!NOTE]
@@ -662,7 +723,7 @@ sock.sendMessage(jid, {
       caption: '🖼️ Image 3',
       footer: '🏷️ Pinterest',
       optionText: '👉🏻 Select Options',
-      optionTitle: '📄 Select Options',
+      optionTitle: '👉🏻 Select Options',
       offerText: '🏷️ New Coupon!',
       offerCode: '@itsliaaa/baileys',
       offerUrl: 'https://www.npmjs.com/package/@itsliaaa/baileys',
@@ -959,6 +1020,62 @@ await sock.requestPairingCode(phoneNumber, customPairingCode)
 console.log('🔗 Pairing code', ':', customPairingCode)
 ```
 
+##### 🖼️ Image Processing
+
+> [!NOTE]
+Automatically use available image processing library: `sharp`, `@napi-rs/image`, or `jimp`
+
+```javascript
+import { getImageProcessingLibrary } from '@itsliaaa/baileys'
+import { readFile } from 'fs/promises'
+
+const lib = await getImageProcessingLibrary()
+
+const bufferOrFilePath = './path/to/image.jpg'
+const width = 512
+
+let output
+
+// --- If sharp installed
+if (lib.sharp?.default) {
+   const img = lib.sharp.default(bufferOrFilePath)
+
+   output = await img.resize(width)
+      .jpeg({ quality: 80 })
+      .toBuffer()
+}
+
+// --- If @napi-rs/image installed
+else if (lib.image?.Transformer) {
+   // --- Must in buffer format
+   const inputBuffer = Buffer.isBuffer(bufferOrFilePath)
+      ? bufferOrFilePath
+      : await readFile(bufferOrFilePath)
+
+   const img = new lib.image.Transformer(inputBuffer)
+
+   output = await img.resize(width, undefined, 0)
+      .jpeg(50)
+}
+
+// --- If jimp installed
+else if (lib.jimp?.Jimp) {
+   const img = await lib.jimp.Jimp.read(bufferOrFilePath)
+
+   output = await img
+      .resize({ w: width, mode: lib.jimp.ResizeStrategy.BILINEAR })
+      .getBuffer('image/jpeg', { quality: 50 });
+}
+
+// --- Fallback
+else {
+   throw new Error('No image processing available')
+}
+
+console.log('✅ Process completed!')
+console.dir(output, { depth: null })
+```
+
 ##### 📣 Newsletter Management
 
 ```javascript

package/lib/Defaults/index.js

@@ -26,6 +26,7 @@ export const NOISE_MODE = 'Noise_XX_25519_AESGCM_SHA256\0\0\0\0';
 export const DICT_VERSION = 3;
 export const KEY_BUNDLE_TYPE = Buffer.from([5]);
 export const NOISE_WA_HEADER = Buffer.from([87, 65, 6, DICT_VERSION]); // last is "DICT_VERSION"
+export const LEXER_REGEX = /(\/\/.*|\/\*[\s\S]*?\*\/|#.*)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`[\s\S]*?`)|(\b[a-zA-Z_]\w*\b)(?=\s*\()|(\b[a-zA-Z_]\w*\b)|(\b\d+(?:\.\d+)?\b)|(\s+|[^\w\s]+)/g;
 /** from: https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url */
 export const URL_REGEX = /https:\/\/(?![^:@\/\s]+:[^:@\/\s]+@)[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:\d+)?(\/[^\s]*)?/g;
 export const WA_CERT_DETAILS = {
@@ -140,4 +141,10 @@ export const TimeMs = {
     Hour: 60 * 60 * 1000,
     Day: 24 * 60 * 60 * 1000,
     Week: 7 * 24 * 60 * 60 * 1000
+};
+export const FORWARDED_AI_BOT_INFO = {
+    isForwarded: true,
+    forwardingScore: 1,
+    forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+    forwardOrigin: 4
 };

package/lib/Signal/libsignal.js

@@ -171,6 +171,10 @@ export function makeLibSignalRepository(auth, logger, pnToLIDFunc) {
                 await auth.keys.set({ session: sessionUpdates });
             }, `delete-${jids.length}-sessions`);
         },
+        close () {
+            migratedSessionCache.clear();
+            lidMapping.close();
+        },
         async migrateSession(fromJid, toJid) {
             // TODO: use usync to handle this entire mess
             if (!fromJid || (!isLidUser(toJid) && !isHostedLidUser(toJid)))

package/lib/Signal/lid-mapping.js

@@ -267,4 +267,10 @@ export class LIDMappingStore {
         }
         return Object.values(successfulPairs).length ? Object.values(successfulPairs) : null;
     }
+    /**
+    * Close the cache and release resources
+    */
+    close() {
+        this.mappingCache.clear();
+    }
 }

package/lib/Socket/chats.js

@@ -17,7 +17,7 @@ const USER_ID_CACHE = new Map();
 export const makeChatsSocket = (config) => {
     const { logger, markOnlineOnConnect, fireInitQueries, appStateMacVerification, shouldIgnoreJid, shouldSyncHistoryMessage, getMessage } = config;
     const sock = makeSocket(config);
-    const { ev, ws, authState, generateMessageTag, sendNode, query, signalRepository, onUnexpectedError, sendUnifiedSession } = sock;
+    const { ev, ws, authState, generateMessageTag, sendNode, query, signalRepository, onUnexpectedError, sendUnifiedSession, registerSocketEndHandler } = sock;
     let privacySettings;
     let syncState = SyncState.Connecting;
     /** this mutex ensures that messages are processed in order */
@@ -35,9 +35,9 @@ export const makeChatsSocket = (config) => {
             stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
             useClones: false
         });
-    if (!config.placeholderResendCache) {
-        config.placeholderResendCache = placeholderResendCache;
-    }
+    // if (!config.placeholderResendCache) {
+    //    config.placeholderResendCache = placeholderResendCache;
+    // }
     /** helper function to fetch the given app state sync key */
     const getAppStateSyncKey = async (keyId) => {
         const { [keyId]: key } = await authState.keys.get('app-state-sync-key', [keyId]);
@@ -997,6 +997,17 @@ export const makeChatsSocket = (config) => {
             logger.warn({ lid, pn, error }, 'Failed to store LID-PN mapping');
         }
     });
+    registerSocketEndHandler(() => {
+        if (awaitingSyncTimeout) {
+            clearTimeout(awaitingSyncTimeout);
+            awaitingSyncTimeout = undefined;
+        }
+        if (!config.placeholderResendCache && placeholderResendCache.close) {
+            placeholderResendCache.close();
+        }
+        syncState = SyncState.Connecting;
+        privacySettings = undefined;
+    });
     return {
         ...sock,
         createCallLink,

package/lib/Socket/messages-recv.js

@@ -15,7 +15,7 @@ import { makeMessagesSocket } from './messages-send.js';
 export const makeMessagesRecvSocket = (config) => {
     const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid, enableAutoSessionRecreation } = config;
     const sock = makeMessagesSocket(config);
-    const { ev, authState, ws, messageMutex, notificationMutex, receiptMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, generateMessageTag, messageRetryManager } = sock;
+    const { ev, authState, ws, messageMutex, notificationMutex, receiptMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, generateMessageTag, messageRetryManager, registerSocketEndHandler } = sock;
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex();
     const devicesMutex = makeMutex();
@@ -1449,6 +1449,19 @@ export const makeMessagesRecvSocket = (config) => {
             logger.trace(`sendActiveReceipts set to "${sendActiveReceipts}"`);
         }
     });
+    registerSocketEndHandler(() => {
+        if (!config.msgRetryCounterCache && msgRetryCache.close) {
+            msgRetryCache.close();
+        }
+        if (!config.callOfferCache && callOfferCache.close) {
+            callOfferCache.close();
+        }
+        if (!config.placeholderResendCache && placeholderResendCache.close) {
+            placeholderResendCache.close();
+        }
+        identityAssertDebounce.close();
+        sendActiveReceipts = false;
+    });
     return {
         ...sock,
         sendMessageAck,

package/lib/Socket/messages-send.js

@@ -14,7 +14,7 @@ import { makeNewsletterSocket } from './newsletter.js';
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
-    const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
+    const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler } = sock;
     const userDevicesCache = config.userDevicesCache ??=
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
@@ -939,6 +939,18 @@ export const makeMessagesSocket = (config) => {
     };
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
+    registerSocketEndHandler(() => {
+        if (!config.userDevicesCache && userDevicesCache.close) {
+            userDevicesCache.close();
+        }
+        if (peerSessionsCache.close) {
+            peerSessionsCache.close();
+        }
+        mediaConn = undefined;
+        if (messageRetryManager) {
+            messageRetryManager.clear();
+        }
+    });
     return {
         ...sock,
         getPrivacyTokens,

package/lib/Socket/socket.js

@@ -269,6 +269,7 @@ export const makeSocket = (config) => {
     let keepAliveReq;
     let qrTimer;
     let closed = false;
+    const socketEndHandlers = [];
     /** log & process any unexpected errors */
     const onUnexpectedError = (err, msg) => {
         logger.error({ err }, `unexpected error in '${msg}'`);
@@ -485,12 +486,21 @@ export const makeSocket = (config) => {
         ws.removeAllListeners('close');
         ws.removeAllListeners('open');
         ws.removeAllListeners('message');
+        signalRepository.close?.();
         if (!ws.isClosed && !ws.isClosing) {
             try {
                 await ws.close();
             }
             catch { }
         }
+        for (const handler of socketEndHandlers) {
+            try {
+                handler(error);
+            }
+            catch (err) {
+                logger.error({ err }, 'error in socket end handler');
+            }
+        }
         ev.emit('connection.update', {
             connection: 'close',
             lastDisconnect: {
@@ -499,6 +509,7 @@ export const makeSocket = (config) => {
             }
         });
         ev.removeAllListeners('connection.update');
+        ev.destroy();
     };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
@@ -890,6 +901,9 @@ export const makeSocket = (config) => {
             logger.debug({ error }, 'failed to send unified_session telemetry');
         }
     };
+    const registerSocketEndHandler = (handler) => {
+        socketEndHandlers.push(handler);
+    }
     return {
         type: 'md',
         ws,
@@ -907,6 +921,7 @@ export const makeSocket = (config) => {
         sendNode,
         logout,
         end,
+        registerSocketEndHandler,
         onUnexpectedError,
         uploadPreKeys,
         uploadPreKeysToServerIfRequired,

package/lib/Store/make-in-memory-store.js

@@ -1,6 +1,5 @@
 /**
- * Lia@Note 03-02-26
- * --- [WIP]
+ * Lia@Note 03-02-26 [WIP]
  * Manually converted to ESM and modified by me
  * Originally based on @whiskeysockets/baileys v6.7.16
  * Minor adjustments for compatibility with baileys v7 (⁠つ⁠≧⁠▽⁠≦⁠)⁠つ

package/lib/Types/RichType.js

@@ -0,0 +1,22 @@
+export var CodeHighlightType;
+(function (CodeHighlightType) {
+    CodeHighlightType[CodeHighlightType["DEFAULT"] = 0] = "DEFAULT";
+    CodeHighlightType[CodeHighlightType["KEYWORD"] = 1] = "KEYWORD";
+    CodeHighlightType[CodeHighlightType["METHOD"] = 2] = "METHOD";
+    CodeHighlightType[CodeHighlightType["STRING"] = 3] = "STRING";
+    CodeHighlightType[CodeHighlightType["NUMBER"] = 4] = "NUMBER";
+    CodeHighlightType[CodeHighlightType["COMMENT"] = 5] = "COMMENT";
+})(CodeHighlightType || (CodeHighlightType = {}));
+export var RichSubMessageType;
+(function (RichSubMessageType) {
+    RichSubMessageType[RichSubMessageType["UNKNOWN"] = 0] = "UNKNOWN";
+    RichSubMessageType[RichSubMessageType["GRID_IMAGE"] = 1] = "GRID_IMAGE";
+    RichSubMessageType[RichSubMessageType["TEXT"] = 2] = "TEXT";
+    RichSubMessageType[RichSubMessageType["INLINE_IMAGE"] = 3] = "INLINE_IMAGE";
+    RichSubMessageType[RichSubMessageType["TABLE"] = 4] = "TABLE";
+    RichSubMessageType[RichSubMessageType["CODE"] = 5] = "CODE";
+    RichSubMessageType[RichSubMessageType["DYNAMIC"] = 6] = "DYNAMIC";
+    RichSubMessageType[RichSubMessageType["MAP"] = 7] = "MAP";
+    RichSubMessageType[RichSubMessageType["LATEX"] = 8] = "LATEX";
+    RichSubMessageType[RichSubMessageType["CONTENT_ITEMS"] = 9] = "CONTENT_ITEMS";
+})(RichSubMessageType || (RichSubMessageType = {}));

package/lib/Utils/event-buffer.js

@@ -169,7 +169,23 @@ export const makeEventBuffer = (logger) => {
         },
         on: (...args) => ev.on(...args),
         off: (...args) => ev.off(...args),
-        removeAllListeners: (...args) => ev.removeAllListeners(...args)
+        removeAllListeners: (...args) => ev.removeAllListeners(...args),
+        destroy() {
+            // Clear buffer timeout
+            if (bufferTimeout) {
+                clearTimeout(bufferTimeout);
+                bufferTimeout = null;
+            }
+            // Clear history cache
+            historyCache.clear();
+            // Reset buffer data
+            data = makeBufferData();
+            isBuffering = false;
+            bufferCount = 0;
+            // Remove all listeners
+            ev.removeAllListeners();
+            logger.debug('Event buffer destroyed');
+        }
     };
 };
 const makeBufferData = () => {

package/lib/Utils/index.js

@@ -2,6 +2,7 @@ export * from './generics.js';
 export * from './decode-wa-message.js';
 export * from './messages.js';
 export * from './messages-media.js';
+export * from './rich-message-utils.js';
 export * from './validate-connection.js';
 export * from './crypto.js';
 export * from './signal.js';

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

@@ -210,6 +210,23 @@ export class MessageRetryManager {
             this.logger.debug(`Cancelled pending phone request for message ${messageId}`);
         }
     }
+    clear() {
+        this.recentMessagesMap.clear();
+        this.messageKeyIndex.clear();
+        this.sessionRecreateHistory.clear();
+        this.retryCounters.clear();
+        for (const messageId of Object.keys(this.pendingPhoneRequests)) {
+            this.cancelPendingPhoneRequest(messageId);
+        }
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        };
+    }
     keyToString(key) {
         return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`;
     }

package/lib/Utils/messages.js

@@ -10,6 +10,7 @@ import { isPnUser, isLidUser, isJidGroup, isJidNewsletter, isJidStatusBroadcast,
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
 import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getImageProcessingLibrary, getRawMediaUploadData, getStream, toBuffer } from './messages-media.js';
+import { generateRichCodeBlock, generateRichTable, wrapToBotForwardedMessage } from './rich-message-utils.js';
 import { shouldIncludeReportingToken } from './reporting-utils.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
@@ -692,7 +693,7 @@ export const generateWAMessageContent = async (message, options) => {
     // Lia@Changes 30-01-26 --- Add "raw" boolean to send raw messages directly via generateWAMessage()
     if (hasNonNullishProperty(message, 'raw')) {
         delete message.raw;
-        return proto.Message.create(message);
+        return message;
     }
     else if (hasNonNullishProperty(message, 'text')) {
         const extContent = { text: message.text };
@@ -726,27 +727,25 @@ export const generateWAMessageContent = async (message, options) => {
         m.extendedTextMessage = extContent;
     }
     else if (hasNonNullishProperty(message, 'contacts')) {
-        const { contacts } = message; // Lia@Changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
-        const contactLen = contacts.contacts.length;
+        const contactLen = message.contacts.contacts.length;
         if (!contactLen) {
             throw new Boom('require atleast 1 contact', { statusCode: 400 });
         }
         if (contactLen === 1) {
-            m.contactMessage = contacts.contacts[0];
+            m.contactMessage = message.contacts.contacts[0];
         }
         else {
-            m.contactsArrayMessage = contacts;
+            m.contactsArrayMessage = message.contacts;
         }
     }
     else if (hasNonNullishProperty(message, 'location')) {
         m.locationMessage = message.location;
     }
     else if (hasNonNullishProperty(message, 'react')) {
-        const { react } = message; // Lia@Changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
-        if (!react.senderTimestampMs) {
-            react.senderTimestampMs = Date.now();
+        if (!message.react.senderTimestampMs) {
+            message.react.senderTimestampMs = Date.now();
         }
-        m.reactionMessage = react;
+        m.reactionMessage = message.react;
     }
     else if (hasNonNullishProperty(message, 'delete')) {
         m.protocolMessage = {
@@ -758,26 +757,24 @@ export const generateWAMessageContent = async (message, options) => {
         m = generateForwardMessageContent(message.forward, message.force);
     }
     else if (hasNonNullishProperty(message, 'disappearingMessagesInChat')) {
-        const { disappearingMessagesInChat } = message; // Lia@Changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
-        const exp = typeof disappearingMessagesInChat === 'boolean'
-            ? disappearingMessagesInChat
+        const exp = typeof message.disappearingMessagesInChat === 'boolean'
+            ? message.disappearingMessagesInChat
                 ? WA_DEFAULT_EPHEMERAL
                 : 0
-            : disappearingMessagesInChat;
+            : message.disappearingMessagesInChat;
         m = prepareDisappearingMessageSettingContent(exp);
     }
     else if (hasNonNullishProperty(message, 'groupInvite')) {
-        const { groupInvite } = message; // Lia@Changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
         m.groupInviteMessage = {};
-        m.groupInviteMessage.inviteCode = groupInvite.inviteCode;
-        m.groupInviteMessage.inviteExpiration = groupInvite.inviteExpiration;
-        m.groupInviteMessage.caption = groupInvite.text;
-        m.groupInviteMessage.groupJid = groupInvite.jid;
-        m.groupInviteMessage.groupName = groupInvite.subject;
+        m.groupInviteMessage.inviteCode = message.groupInvite.inviteCode;
+        m.groupInviteMessage.inviteExpiration = message.groupInvite.inviteExpiration;
+        m.groupInviteMessage.caption = message.groupInvite.text;
+        m.groupInviteMessage.groupJid = message.groupInvite.jid;
+        m.groupInviteMessage.groupName = message.groupInvite.subject;
         //TODO: use built-in interface and get disappearing mode info etc.
         //TODO: cache / use store!?
         if (options.getProfilePicUrl) {
-            const pfpUrl = await options.getProfilePicUrl(groupInvite.jid, 'preview');
+            const pfpUrl = await options.getProfilePicUrl(message.groupInvite.jid, 'preview');
             if (pfpUrl) {
                 const resp = await fetch(pfpUrl, { method: 'GET', dispatcher: options?.options?.dispatcher });
                 if (resp.ok) {
@@ -805,47 +802,44 @@ export const generateWAMessageContent = async (message, options) => {
         m.keepInChatMessage.timestampMs = Date.now();
     }
     else if (hasNonNullishProperty(message, 'flowReply')) {
-        const { flowReply } = message; // Lia@Changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
         m.interactiveResponseMessage = {
             body: {
-                format: flowReply.format || proto.Message.InteractiveResponseMessage.Body.Format.DEFAULT,
-                text: flowReply.text
+                format: message.flowReply.format || proto.Message.InteractiveResponseMessage.Body.Format.DEFAULT,
+                text: message.flowReply.text
             },
             nativeFlowResponseMessage: {
-                name: flowReply.name,
-                paramsJson: flowReply.paramsJson || '{}',
-                version: flowReply.version || 1
+                name: message.flowReply.name,
+                paramsJson: message.flowReply.paramsJson || '{}',
+                version: message.flowReply.version || 1
             }
         };
     }
     else if (hasNonNullishProperty(message, 'buttonReply')) {
-        const { buttonReply } = message; // Lia@Changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
         switch (message.type) {
             case 'template':
                 m.templateButtonReplyMessage = {
-                    selectedDisplayText: buttonReply.displayText,
-                    selectedId: buttonReply.id,
-                    selectedIndex: buttonReply.index
+                    selectedDisplayText: message.buttonReply.displayText,
+                    selectedId: message.buttonReply.id,
+                    selectedIndex: message.buttonReply.index
                 };
                 break;
             case 'plain':
                 m.buttonsResponseMessage = {
-                    selectedButtonId: buttonReply.id,
-                    selectedDisplayText: buttonReply.displayText,
+                    selectedButtonId: message.buttonReply.id,
+                    selectedDisplayText: message.buttonReply.displayText,
                     type: proto.Message.ButtonsResponseMessage.Type.DISPLAY_TEXT
                 };
                 break;
         }
     }
     else if (hasNonNullishProperty(message, 'listReply')) {
-        const { listReply } = message; // Lia@Changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
         m.listResponseMessage = {
-            description: listReply.description,
+            description: message.listReply.description,
             listType: proto.Message.ListResponseMessage.ListType.SINGLE_SELECT,
             singleSelectReply: {
-                selectedRowId: listReply.id
+                selectedRowId: message.listReply.id
             },
-            title: listReply.title
+            title: message.listReply.title
         };
     }
     else if (hasOptionalProperty(message, 'ptv') && message.ptv) {
@@ -856,68 +850,66 @@ export const generateWAMessageContent = async (message, options) => {
         m.productMessage = await prepareProductMessage(message, options);
     }
     else if (hasNonNullishProperty(message, 'event')) {
-        const { event } = message; // Lia@Changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
         m.eventMessage = {};
-        const startTime = Math.floor(event.startDate.getTime() / 1000);
-        if (event.call && options.getCallLink) {
-            const token = await options.getCallLink(event.call, { startTime });
-            m.eventMessage.joinLink = (event.call === 'audio' ? CALL_AUDIO_PREFIX : CALL_VIDEO_PREFIX) + token;
+        const startTime = Math.floor(message.event.startDate.getTime() / 1000);
+        if (message.event.call && options.getCallLink) {
+            const token = await options.getCallLink(message.event.call, { startTime });
+            m.eventMessage.joinLink = (message.event.call === 'audio' ? CALL_AUDIO_PREFIX : CALL_VIDEO_PREFIX) + token;
         }
         m.messageContextInfo = {
             // encKey
-            messageSecret: event.messageSecret || randomBytes(32)
+            messageSecret: message.event.messageSecret || randomBytes(32)
         };
-        m.eventMessage.name = event.name;
-        m.eventMessage.description = event.description;
+        m.eventMessage.name = message.event.name;
+        m.eventMessage.description = message.event.description;
         m.eventMessage.startTime = startTime;
-        m.eventMessage.endTime = event.endDate ? event.endDate.getTime() / 1000 : undefined;
-        m.eventMessage.isCanceled = event.isCancelled ?? false;
-        m.eventMessage.extraGuestsAllowed = event.extraGuestsAllowed;
-        m.eventMessage.isScheduleCall = event.isScheduleCall ?? false;
-        m.eventMessage.location = event.location;
+        m.eventMessage.endTime = message.event.endDate ? message.event.endDate.getTime() / 1000 : undefined;
+        m.eventMessage.isCanceled = message.event.isCancelled ?? false;
+        m.eventMessage.extraGuestsAllowed = message.event.extraGuestsAllowed;
+        m.eventMessage.isScheduleCall = message.event.isScheduleCall ?? false;
+        m.eventMessage.location = message.event.location;
     }
     else if (hasNonNullishProperty(message, 'poll')) {
-        const { poll } = message; // Lia@Changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
-        (_a = poll).selectableCount || (_a.selectableCount = 0);
-        (_b = poll).toAnnouncementGroup || (_b.toAnnouncementGroup = false);
-        if (!Array.isArray(poll.values)) {
+        (_a = message.poll).selectableCount || (_a.selectableCount = 0);
+        (_b = message.poll).toAnnouncementGroup || (_b.toAnnouncementGroup = false);
+        if (!Array.isArray(message.poll.values)) {
             throw new Boom('Invalid poll values', { statusCode: 400 });
         }
-        if (poll.selectableCount < 0 || poll.selectableCount > poll.values.length) {
-            throw new Boom(`poll.selectableCount in poll should be >= 0 and <= ${poll.values.length}`, {
+        if (message.poll.selectableCount < 0 || message.poll.selectableCount > message.poll.values.length) {
+            throw new Boom(`poll.selectableCount in poll should be >= 0 and <= ${message.poll.values.length}`, {
                 statusCode: 400
             });
         }
         m.messageContextInfo = {
             // encKey
-            messageSecret: poll.messageSecret || randomBytes(32)
+            messageSecret: message.poll.messageSecret || randomBytes(32)
         };
         const pollCreationMessage = {
-            name: poll.name,
-            selectableOptionsCount: poll.selectableCount,
-            options: poll.values.map(optionName => ({ optionName }))
+            name: message.poll.name,
+            selectableOptionsCount: message.poll.selectableCount,
+            options: message.poll.values.map(optionName => ({ optionName }))
         };
-        if (poll.toAnnouncementGroup) {
+        if (message.poll.toAnnouncementGroup) {
             // poll v2 is for community announcement groups (single select and multiple)
             m.pollCreationMessageV2 = pollCreationMessage;
         }
         else {
             // Lia@Changes 08-02-26 --- Add quiz message support
-            if (poll.pollType === 1) {
-                if (!poll.correctAnswer) {
+            if (message.poll.pollType == 1) {
+                if (!message.poll.correctAnswer) {
                     throw new Boom('No "correctAnswer" provided for quiz', { statusCode: 400 });
                 }
                 m.pollCreationMessageV5 = {
                     // Lia@Note 08-02-26 --- quiz for newsletter only
                     ...pollCreationMessage,
                     correctAnswer: {
-                        optionName: poll.correctAnswer.toString()
+                        optionName: message.poll.correctAnswer.toString()
                     },
-                    pollType: poll.pollType,
+                    pollType: message.poll.pollType,
                     selectableOptionsCount: 1
                 };
             }
-            else if (poll.selectableCount === 1) {
+            else if (message.poll.selectableCount === 1) {
                 //poll v3 is for single select polls
                 m.pollCreationMessageV3 = pollCreationMessage;
             }
@@ -929,15 +921,14 @@ export const generateWAMessageContent = async (message, options) => {
     }
     // Lia@Changes 08-02-26 --- Add poll result snapshot message
     else if (hasNonNullishProperty(message, 'pollResult')) {
-        const { pollResult } = message;
         const pollResultSnapshotMessage = {
-            name: pollResult.name,
-            pollVotes: pollResult.votes.map(vote => ({
+            name: message.pollResult.name,
+            pollVotes: message.pollResult.votes.map(vote => ({
                 optionName: vote.name,
                 optionVoteCount: parseInt(vote.voteCount)
             }))
         };
-        if (pollResult.pollType === 1) {
+        if (message.pollResult.pollType == 1) {
             pollResultSnapshotMessage.pollType = proto.Message.PollType.QUIZ;
             m.pollResultSnapshotMessageV3 = pollResultSnapshotMessage;
         }
@@ -948,18 +939,17 @@ export const generateWAMessageContent = async (message, options) => {
     }
     // Lia@Changes 08-02-26 --- Add poll update message
     else if (hasNonNullishProperty(message, 'pollUpdate')) {
-        const { pollUpdate } = message;
-        if (!pollUpdate.key) {
+        if (!message.pollUpdate.key) {
             throw new Boom('Message key is required', { statusCode: 400 });
         }
-        if (!pollUpdate.vote) {
+        if (!message.pollUpdate.vote) {
             throw new Boom('Encrypted vote payload is required', { statusCode: 400 });
         }
         m.pollUpdateMessage = {
-            metadata: pollUpdate.metadata,
-            pollCreationMessageKey: pollUpdate.key,
+            metadata: message.pollUpdate.metadata,
+            pollCreationMessageKey: message.pollUpdate.key,
             senderTimestampMs: Date.now(),
-            vote: pollUpdate.vote
+            vote: message.pollUpdate.vote
         };
     }
     else if (hasNonNullishProperty(message, 'sharePhoneNumber')) {
@@ -1009,17 +999,16 @@ export const generateWAMessageContent = async (message, options) => {
     }
     // Lia@Changes 31-01-26 --- Add support for album messages
     else if (hasNonNullishProperty(message, 'album')) {
-        const { album } = message;
-        if (!Array.isArray(album)) {
+        if (!Array.isArray(message.album)) {
             throw new Boom('Invalid album type. Expected an array.', { statusCode: 400 });
         }
         let videoCount = 0;
-        for (let i = 0; i < album.length; i++) {
-            if (album[i].video) videoCount++;
+        for (let i = 0; i < message.album.length; i++) {
+            if (message.album[i].video) videoCount++;
         };
         let imageCount = 0;
-        for (let i = 0; i < album.length; i++) {
-            if (album[i].image) imageCount++;
+        for (let i = 0; i < message.album.length; i++) {
+            if (message.album[i].image) imageCount++;
         };
         if ((videoCount + imageCount) < 2) {
             throw new Boom('Minimum provide 2 media to upload album message', { statusCode: 400 });
@@ -1029,6 +1018,13 @@ export const generateWAMessageContent = async (message, options) => {
             expectedVideoCount: videoCount
         };
     }
+    // Lia@Changes 09-04-26 --- Add support for code block and table
+    else if (hasNonNullishProperty(message, 'code')) {
+        m.richResponseMessage = generateRichCodeBlock(message);
+    }
+    else if (hasNonNullishProperty(message, 'table')) {
+        m.richResponseMessage = generateRichTable(message);
+    }
     else {
         m = await prepareWAMessageMedia(message, options);
     }
@@ -1330,8 +1326,9 @@ export const generateWAMessageContent = async (message, options) => {
             ...content,
             body: content.body,
             mediaType: content.mediaType || 1,
-            mediaUrl: content.url + '?update=' + Date.now(),
+            mediaUrl: content.url,
             renderLargerThumbnail: content.largeThumbnail,
+            sourceUrl: content.url + '?update=' + Date.now(),
             thumbnail: content.thumbnail,
             thumbnailUrl: content.url,
             title: content.title || LIBRARY_NAME
@@ -1419,6 +1416,10 @@ export const generateWAMessageContent = async (message, options) => {
         m = { viewOnceMessageV2Extension: { message: m } };
         delete message.viewOnceV2Extension;
     }
+    // Lia@Note 09-04-26 --- Wrap richResponseMessage into botForwardedMessage
+    if (!!m.richResponseMessage) {
+        m = wrapToBotForwardedMessage(m)
+    }
     if (hasOptionalProperty(message, 'edit')) {
         m = {
             protocolMessage: {

package/lib/Utils/rich-message-utils.js

@@ -0,0 +1,182 @@
+/**
+ * Lia@Changes 09-04-26 [WIP]
+ * Add support for tables and code blocks in richResponseMessage (wrapped in botForwardedMessage)
+ */
+import { FORWARDED_AI_BOT_INFO, LEXER_REGEX } from '../Defaults/index.js';
+import { CodeHighlightType } from '../Types/RichType.js';
+const CPP_KEYWORDS = new Set([
+    'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor', 'bool', 'break', 'case',
+    'catch', 'char', 'class', 'compl', 'concept', 'const', 'consteval', 'constexpr', 'constinit',
+    'const_cast', 'continue', 'co_await', 'co_return', 'co_yield', 'decltype', 'default', 'delete',
+    'do', 'double', 'dynamic_cast', 'else', 'enum', 'explicit', 'export', 'extern', 'false', 'float',
+    'for', 'friend', 'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new', 'noexcept',
+    'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq', 'private', 'protected', 'public', 'register',
+    'reinterpret_cast', 'requires', 'return', 'short', 'signed', 'sizeof', 'static', 'static_assert',
+    'static_cast', 'struct', 'switch', 'template', 'this', 'thread_local', 'throw', 'true', 'try',
+    'typedef', 'typeid', 'typename', 'union', 'unsigned', 'using', 'virtual', 'void', 'volatile',
+    'wchar_t', 'while', 'xor', 'xor_eq'
+]);
+const CSS_KEYWORDS = new Set([
+    'import', 'media', 'font-face', 'keyframes', 'supports', 'charset',
+    'important', 'root', 'hover', 'active', 'focus', 'visited', 'before', 'after',
+    'not', 'nth-child', 'first-child', 'last-child', 'only-child',
+    'none', 'inherit', 'initial', 'unset', 'auto', 'transparent', 'currentcolor'
+]);
+const GO_KEYWORDS = new Set([
+    'break', 'default', 'func', 'interface', 'select', 'case', 'defer', 'go', 'map', 'struct',
+    'chan', 'else', 'goto', 'package', 'switch', 'const', 'fallthrough', 'if', 'range', 'type',
+    'continue', 'for', 'import', 'return', 'var', 'true', 'false', 'nil'
+]);
+const HTML_KEYWORDS = new Set([
+    'html', 'head', 'body', 'title', 'meta', 'link', 'script', 'style',
+    'header', 'footer', 'main', 'section', 'article', 'aside', 'nav',
+    'div', 'span', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'a', 'img',
+    'ul', 'ol', 'li', 'table', 'tr', 'td', 'th', 'thead', 'tbody',
+    'form', 'input', 'button', 'select', 'textarea', 'label', 'option',
+    'canvas', 'svg', 'iframe', 'video', 'audio', 'source'
+]);
+const JS_KEYWORDS = new Set([
+    'import', 'export', 'from', 'default', 'as',
+    'const', 'let', 'var', 'function', 'class', 'extends', 'new',
+    'return', 'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue',
+    'try', 'catch', 'finally', 'throw',
+    'async', 'await', 'yield',
+    'typeof', 'instanceof', 'in', 'of', 'delete', 'void',
+    'true', 'false', 'null', 'undefined', 'NaN', 'Infinity',
+    'this', 'super', 'static', 'get', 'set',
+    'debugger', 'with'
+]);
+const PYTHON_KEYWORDS = new Set([
+    'import', 'from', 'as', 'def', 'class', 'return', 'if', 'elif', 'else',
+    'for', 'while', 'break', 'continue', 'try', 'except', 'finally', 'raise',
+    'with', 'yield', 'lambda', 'pass', 'del', 'global', 'nonlocal', 'assert',
+    'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'async', 'await',
+    'self', 'print'
+]);
+const RUST_KEYWORDS = new Set([
+    'as', 'break', 'const', 'continue', 'crate', 'else', 'enum', 'extern', 'false', 'fn', 'for',
+    'if', 'impl', 'in', 'let', 'loop', 'match', 'mod', 'move', 'mut', 'pub', 'ref', 'return',
+    'self', 'Self', 'static', 'struct', 'super', 'trait', 'true', 'type', 'unsafe', 'use',
+    'where', 'while', 'async', 'await', 'dyn', 'abstract', 'become', 'box', 'do', 'final',
+    'macro', 'override', 'priv', 'typeof', 'unsized', 'virtual', 'yield'
+]);
+const NOOP = new Set([])
+export const LANGUAGE_KEYWORDS = {
+    css: CSS_KEYWORDS,
+    html: HTML_KEYWORDS,
+    javascript: JS_KEYWORDS,
+    typescript: JS_KEYWORDS,
+    js: JS_KEYWORDS,
+    ts: JS_KEYWORDS,
+    python: PYTHON_KEYWORDS,
+    py: PYTHON_KEYWORDS,
+    go: GO_KEYWORDS,
+    golang: GO_KEYWORDS,
+    cpp: CPP_KEYWORDS,
+    'c++': CPP_KEYWORDS,
+    rust: RUST_KEYWORDS,
+    rs: RUST_KEYWORDS,
+};
+export const tokenizeCode = (code, language = 'javascript') => {
+    const keywords = LANGUAGE_KEYWORDS[language] || NOOP;
+    const blocks = [];
+    LEXER_REGEX.lastIndex = 0;
+    let match;
+    while ((match = LEXER_REGEX.exec(code)) !== null) {
+        if (match[1]) {
+            blocks.push({ highlightType: CodeHighlightType.COMMENT, codeContent: match[1] });
+        }
+        else if (match[2]) {
+            blocks.push({ highlightType: CodeHighlightType.STRING, codeContent: match[2] });
+        }
+        else if (match[3]) {
+            blocks.push({
+                highlightType: keywords.has(match[3]) ? CodeHighlightType.KEYWORD : CodeHighlightType.METHOD,
+                codeContent: match[3],
+            });
+        }
+        else if (match[4]) {
+            blocks.push({
+                highlightType: keywords.has(match[4]) ? CodeHighlightType.KEYWORD : CodeHighlightType.DEFAULT,
+                codeContent: match[4],
+            });
+        }
+        else if (match[5]) {
+            blocks.push({ highlightType: CodeHighlightType.NUMBER, codeContent: match[5] });
+        }
+        else {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: match[6] });
+        }
+    }
+    return blocks;
+};
+export const wrapToBotForwardedMessage = (message) =>
+    ({
+        messageContextInfo: {
+            botMetadata: {
+                // Lia@Note 09-04-26 --- TODO: Fill verificationMetadata field
+                verificationMetadata: {},
+                botRenderingConfigMetadata: {}
+            }
+        },
+        botForwardedMessage: { message }
+    });
+export const generateRichCodeBlock = ({ header, code, footer, language } = {}) => {
+    language ??= 'javascript'
+    const submessages = [];
+    if (header) {
+        submessages.push({
+           messageType: 2,
+           messageText: header
+        });
+    }
+    submessages.push({
+        messageType: 5,
+        codeMetadata: {
+            codeLanguage: language,
+            codeBlocks: tokenizeCode(code, language)
+        }
+    });
+    if (footer) {
+        submessages.push({
+            messageType: 2,
+            messageText: footer
+        });
+    }
+    return ({
+        submessages,
+        messageType: 1,
+        contextInfo: FORWARDED_AI_BOT_INFO
+    });
+};
+export const generateRichTable = ({ header, title, table, footer } = {}) => {
+    const tableRows = table.map((items, index) => ({
+        isHeading: index == 0,
+        items
+    }));
+    const submessages = [];
+    if (header) {
+        submessages.push({
+            messageType: 2,
+            messageText: header
+        });
+    }
+    submessages.push({
+        messageType: 4,
+        tableMetadata: {
+            title,
+            rows: tableRows
+        }
+    });
+    if (footer) {
+        submessages.push({
+            messageType: 2,
+            messageText: footer
+        });
+    }
+    return ({
+        submessages,
+        messageType: 1,
+        contextInfo: FORWARDED_AI_BOT_INFO
+    });
+};

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@itsliaaa/baileys",
-   "version": "0.1.17",
-   "description": "A simple fork of Baileys for WhatsApp automation",
+   "version": "0.1.19",
+   "description": "A lightweight fork of Baileys with practical fixes and small but meaningful improvements.",
    "main": "lib/index.js",
    "type": "module",
    "scripts": {