violetics 7.0.7-alpha → 7.0.8-alpha

package/lib/Socket/messages-send.js

@@ -2,20 +2,24 @@ import NodeCache from '@cacheable/node-cache';
 import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
-import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessageFromContent, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
-import { AssociationType } from '../Types/index.js';
+import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, prepareWAMessageMedia, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex } from '../Utils/make-mutex.js';
 import { getMessageReportingToken, shouldIncludeReportingToken } from '../Utils/reporting-utils.js';
-import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinaryNode, isHostedLidUser, isHostedPnUser, isJidGroup, isJidNewsletter, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { areJidsSameUser, getBinaryFilteredBizBot, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidGroup, isJidUser, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET, STORIES_JID } from '../WABinary/index.js';
+import { delay } from '../Utils/generics.js';
+
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
+// Inline helper — no external import needed
+const _isNewsletterJid = (jid) => typeof jid === 'string' && jid.endsWith('@newsletter');
+
 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 userDevicesCache = config.userDevicesCache ??=
+    const userDevicesCache = config.userDevicesCache ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
             useClones: false
@@ -242,7 +246,7 @@ export const makeMessagesSocket = (config) => {
             const userDeviceUpdates = {};
             for (const [userId, devices] of Object.entries(deviceMap)) {
                 if (devices && devices.length > 0) {
-                    userDeviceUpdates[userId] = devices.map(d => d.device?.toString());
+                    userDeviceUpdates[userId] = devices.map(d => d.device?.toString() || '0');
                 }
             }
             if (Object.keys(userDeviceUpdates).length > 0) {
@@ -429,10 +433,10 @@ export const makeMessagesSocket = (config) => {
         }
         return { nodes, shouldIncludeDeviceIdentity };
     };
-    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, addBizAttributes, statusJidList }) => {
+    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList, AI = false }) => {
         const meId = authState.creds.me.id;
         const meLid = authState.creds.me?.lid;
-        const isRetryResend = !!participant?.jid;
+        const isRetryResend = Boolean(participant?.jid);
         let shouldIncludeDeviceIdentity = isRetryResend;
         const statusJid = 'status@broadcast';
         const { user, server } = jidDecode(jid);
@@ -470,50 +474,110 @@ export const makeMessagesSocket = (config) => {
             });
         }
         await authState.keys.transaction(async () => {
-            // Lia@Changes 02-02-26 --- Normalize message first to extract the original message and valid media type
-            const innerMessage = normalizeMessageContent(message);
-            const mediaType = getMediaType(innerMessage);
+            const mediaType = getMediaType(message);
             if (mediaType) {
                 extraAttrs['mediatype'] = mediaType;
             }
             if (isNewsletter) {
-                if (innerMessage.productMessage) {
-                    extraAttrs['mediatype'] = 'image'; // Lia@Note 02-02-26 --- Treat product message as image message to avoid the "479" error (⁠✷⁠‿⁠✷⁠)
+                // Handle edit
+                if (message.protocolMessage?.editedMessage) {
+                    msgId = message.protocolMessage.key?.id;
+                    message = message.protocolMessage.editedMessage;
                 }
+                // Handle delete/revoke
+                if (message.protocolMessage?.type === proto.Message.ProtocolMessage.Type.REVOKE) {
+                    msgId = message.protocolMessage.key?.id;
+                    message = {};
+                }
+                // ── Newsletter Button Compatibility Patch ──────────────────────
+                // interactiveMessage (quick_reply / single_select / cta_url) bisa
+                // dikirim ke newsletter langsung — WA menerima via proto encoding.
+                // listMessage & buttonsMessage dikonversi ke interactiveMessage
+                // supaya konsisten dengan cara bot menulis pesan.
+                // ──────────────────────────────────────────────────────────────
+                if (message.listMessage) {
+                    const list = message.listMessage;
+                    message = {
+                        interactiveMessage: {
+                            nativeFlowMessage: {
+                                buttons: [{
+                                    name: 'single_select',
+                                    buttonParamsJson: JSON.stringify({
+                                        title: list.buttonText || 'Select',
+                                        sections: (list.sections || []).map(sec => ({
+                                            title: sec.title || '',
+                                            highlight_label: '',
+                                            rows: (sec.rows || []).map(row => ({
+                                                header: '',
+                                                title: row.title || '',
+                                                description: row.description || '',
+                                                id: row.rowId || row.id || ''
+                                            }))
+                                        }))
+                                    })
+                                }],
+                                messageParamsJson: '',
+                                messageVersion: 1
+                            },
+                            body: { text: list.description || '' },
+                            ...(list.footerText ? { footer: { text: list.footerText } } : {}),
+                            ...(list.title ? { header: { title: list.title, hasMediaAttachment: false, subtitle: '' } } : {})
+                        }
+                    };
+                }
+                else if (message.buttonsMessage) {
+                    const bMsg = message.buttonsMessage;
+                    message = {
+                        interactiveMessage: {
+                            nativeFlowMessage: {
+                                buttons: (bMsg.buttons || []).map(btn => ({
+                                    name: 'quick_reply',
+                                    buttonParamsJson: JSON.stringify({
+                                        display_text: btn.buttonText?.displayText || btn.buttonText || '',
+                                        id: btn.buttonId || btn.buttonText?.displayText || ''
+                                    })
+                                })),
+                                messageParamsJson: '',
+                                messageVersion: 1
+                            },
+                            body: { text: bMsg.contentText || bMsg.text || '' },
+                            ...(bMsg.footerText ? { footer: { text: bMsg.footerText } } : {}),
+                        }
+                    };
+                }
+                // ── End Newsletter Button Compatibility Patch ──────────────────
                 const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
+                if (Array.isArray(patched)) {
+                    throw new Error('Per-jid patching is not supported in channel');
+                }
                 const bytes = encodeNewsletterMessage(patched);
-                // Lia@Changes 08-02-26 --- Add "additionalNodes" for newsletter too (⁠っ⁠˘̩⁠╭⁠╮⁠˘̩⁠)⁠っ
-                if (additionalNodes && additionalNodes.length > 0) {
-                    ;
-                    binaryNodeContent.push(...additionalNodes);
+                // Set mediatype for interactive messages
+                if (patched.interactiveMessage && !extraAttrs['mediatype']) {
+                    extraAttrs['mediatype'] = 'interactive';
                 }
+                // extraAttrs already has mediatype set above if media message
                 binaryNodeContent.push({
                     tag: 'plaintext',
-                    attrs: extraAttrs, // Lia@Changes 02-02-26 --- Add extraAttrs to fix media being rejected when sending to newsletter (⁠◠⁠‿⁠◕⁠)
+                    attrs: extraAttrs,
                     content: bytes
                 });
+                logger.debug({ msgId, extraAttrs }, `sending newsletter message to ${jid}`);
                 const stanza = {
                     tag: 'message',
                     attrs: {
                         to: jid,
                         id: msgId,
-                        type: getMessageType(innerMessage),
+                        type: getMessageType(message),
                         ...(additionalAttributes || {})
                     },
                     content: binaryNodeContent
                 };
-                logger.debug({ msgId }, `sending newsletter message to ${jid}`);
                 await sendNode(stanza);
                 return;
             }
-            // Lia@Changes 02-02-26 --- Add keepInChat, editedMessage, mediaNotifyMessage and pollUpdateMessage
-            if (innerMessage?.pinInChatMessage || innerMessage?.pollUpdateMessage || innerMessage?.keepInChatMessage || innerMessage?.protocolMessage?.editedMessage || innerMessage?.protocolMessage?.mediaNotifyMessage || innerMessage?.reactionMessage) {
+            if (normalizeMessageContent(message)?.pinInChatMessage || normalizeMessageContent(message)?.reactionMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
             }
-            // Lia@Changes 02-02-26 --- Add native_flow_name to extraAttrs when sending interactiveResponseMessage
-            if (innerMessage?.interactiveResponseMessage?.nativeFlowResponseMessage) {
-                extraAttrs['native_flow_name'] = innerMessage.interactiveResponseMessage.nativeFlowResponseMessage.name;
-            }
             if (isGroupOrStatus && !isRetryResend) {
                 const [groupData, senderKeyMap] = await Promise.all([
                     (async () => {
@@ -554,6 +618,147 @@ export const makeMessagesSocket = (config) => {
                         addressing_mode: groupData?.addressingMode || 'lid'
                     };
                 }
+                // Ensure groupStatusMessageV2 always has messageContextInfo.messageSecret
+                if (message?.groupStatusMessageV2 && !message?.messageContextInfo?.messageSecret) {
+                    const { randomBytes } = await import('node:crypto');
+                    message = {
+                        ...message,
+                        messageContextInfo: {
+                            ...(message.messageContextInfo || {}),
+                            messageSecret: randomBytes(32)
+                        },
+                        groupStatusMessageV2: {
+                            ...message.groupStatusMessageV2,
+                            message: {
+                                ...(message.groupStatusMessageV2.message || {}),
+                                messageContextInfo: {
+                                    ...(message.groupStatusMessageV2.message?.messageContextInfo || {}),
+                                    messageSecret: message.messageContextInfo?.messageSecret || randomBytes(32)
+                                }
+                            }
+                        }
+                    };
+                }
+                // ── Group Interactive Message Compatibility Patch ──────────────
+                // WhatsApp groups do NOT render listMessage, buttonsMessage, or
+                // templateMessage natively in MD protocol. All must be converted
+                // to interactiveMessage with nativeFlowMessage so they display
+                // and are interactive in group chats.
+                // ──────────────────────────────────────────────────────────────
+
+                // 1. listMessage → interactiveMessage single_select
+                if (message.listMessage) {
+                    const list = message.listMessage;
+                    const interactiveMessage = {
+                        nativeFlowMessage: {
+                            buttons: [{
+                                name: 'single_select',
+                                buttonParamsJson: JSON.stringify({
+                                    title: list.buttonText || 'Select',
+                                    sections: (list.sections || []).map(section => ({
+                                        title: section.title || '',
+                                        highlight_label: '',
+                                        rows: (section.rows || []).map(row => ({
+                                            header: '',
+                                            title: row.title || '',
+                                            description: row.description || '',
+                                            id: row.rowId || row.id || ''
+                                        }))
+                                    }))
+                                })
+                            }],
+                            messageParamsJson: '',
+                            messageVersion: 1
+                        },
+                        body: { text: list.description || '' },
+                        footer: list.footerText ? { text: list.footerText } : undefined,
+                        header: list.title ? { title: list.title, hasMediaAttachment: false, subtitle: '' } : undefined,
+                        contextInfo: list.contextInfo
+                    };
+                    message = { interactiveMessage };
+                }
+
+                // 2. buttonsMessage → interactiveMessage nativeFlowMessage quick_reply buttons
+                else if (message.buttonsMessage) {
+                    const bMsg = message.buttonsMessage;
+                    const buttons = (bMsg.buttons || []).map(btn => ({
+                        name: 'quick_reply',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: btn.buttonText?.displayText || btn.buttonText || '',
+                            id: btn.buttonId || btn.buttonText?.displayText || ''
+                        })
+                    }));
+                    const interactiveMessage = {
+                        nativeFlowMessage: {
+                            buttons,
+                            messageParamsJson: '',
+                            messageVersion: 1
+                        },
+                        body: { text: bMsg.contentText || bMsg.text || '' },
+                        footer: bMsg.footerText ? { text: bMsg.footerText } : undefined,
+                        header: bMsg.text
+                            ? { title: bMsg.text, hasMediaAttachment: false, subtitle: '' }
+                            : (bMsg.imageMessage || bMsg.videoMessage || bMsg.documentMessage
+                                ? { hasMediaAttachment: true, ...(bMsg.imageMessage ? { imageMessage: bMsg.imageMessage } : {}), ...(bMsg.videoMessage ? { videoMessage: bMsg.videoMessage } : {}) }
+                                : undefined),
+                        contextInfo: bMsg.contextInfo
+                    };
+                    message = { interactiveMessage };
+                }
+
+                // 3. templateMessage (hydratedFourRowTemplate) → interactiveMessage nativeFlowMessage
+                else if (message.templateMessage) {
+                    const tmpl = message.templateMessage.hydratedTemplate || message.templateMessage.fourRowTemplate;
+                    if (tmpl) {
+                        const hydratedButtons = tmpl.hydratedButtons || [];
+                        const buttons = hydratedButtons.map(hBtn => {
+                            if (hBtn.quickReplyButton) {
+                                return {
+                                    name: 'quick_reply',
+                                    buttonParamsJson: JSON.stringify({
+                                        display_text: hBtn.quickReplyButton.displayText || '',
+                                        id: hBtn.quickReplyButton.id || hBtn.quickReplyButton.displayText || ''
+                                    })
+                                };
+                            } else if (hBtn.urlButton) {
+                                return {
+                                    name: 'cta_url',
+                                    buttonParamsJson: JSON.stringify({
+                                        display_text: hBtn.urlButton.displayText || '',
+                                        url: hBtn.urlButton.url || '',
+                                        merchant_url: hBtn.urlButton.url || ''
+                                    })
+                                };
+                            } else if (hBtn.callButton) {
+                                return {
+                                    name: 'cta_call',
+                                    buttonParamsJson: JSON.stringify({
+                                        display_text: hBtn.callButton.displayText || '',
+                                        phone_number: hBtn.callButton.phoneNumber || ''
+                                    })
+                                };
+                            }
+                            return null;
+                        }).filter(Boolean);
+                        const interactiveMessage = {
+                            nativeFlowMessage: {
+                                buttons,
+                                messageParamsJson: '',
+                                messageVersion: 1
+                            },
+                            body: { text: tmpl.hydratedContentText || tmpl.contentText || '' },
+                            footer: tmpl.hydratedFooterText ? { text: tmpl.hydratedFooterText } : undefined,
+                            header: tmpl.hydratedTitleText
+                                ? { title: tmpl.hydratedTitleText, hasMediaAttachment: false, subtitle: '' }
+                                : (tmpl.imageMessage || tmpl.videoMessage || tmpl.documentMessage
+                                    ? { hasMediaAttachment: true, ...(tmpl.imageMessage ? { imageMessage: tmpl.imageMessage } : {}), ...(tmpl.videoMessage ? { videoMessage: tmpl.videoMessage } : {}) }
+                                    : undefined),
+                            contextInfo: tmpl.contextInfo
+                        };
+                        message = { interactiveMessage };
+                    }
+                }
+                // ── End Group Interactive Message Compatibility Patch ──────────
                 const patched = await patchMessageBeforeSending(message);
                 if (Array.isArray(patched)) {
                     throw new Boom('Per-jid patching is not supported in groups');
@@ -706,7 +911,7 @@ export const makeMessagesSocket = (config) => {
                     attrs: {
                         v: '2',
                         type,
-                        count: participant.count?.toString() || '0'
+                        count: participant.count.toString()
                     },
                     content: encryptedContent
                 });
@@ -731,7 +936,7 @@ export const makeMessagesSocket = (config) => {
                 attrs: {
                     id: msgId,
                     to: destinationJid,
-                    type: getMessageType(innerMessage),
+                    type: getMessageType(message),
                     ...(additionalAttributes || {})
                 },
                 content: binaryNodeContent
@@ -797,15 +1002,22 @@ export const makeMessagesSocket = (config) => {
                     content: tcTokenBuffer
                 });
             }
-            if (additionalNodes && additionalNodes.length > 0) {
+            if (AI && !isGroup && !isStatus && !isNewsletter) {
+                const existingBizBot = getBinaryFilteredBizBot(additionalNodes || []);
+                if (existingBizBot) {
+                    if (additionalNodes && additionalNodes.length > 0) {
+                        stanza.content.push(...additionalNodes);
+                    }
+                } else {
+                    stanza.content.push({ tag: 'bot', attrs: { biz_bot: '1' } });
+                    if (additionalNodes && additionalNodes.length > 0) {
+                        stanza.content.push(...additionalNodes);
+                    }
+                }
+            } else if (additionalNodes && additionalNodes.length > 0) {
                 ;
                 stanza.content.push(...additionalNodes);
             }
-            // Lia@Changes 30-01-26 --- Add Biz Binary Node to support button messages
-            if (shouldIncludeBizBinaryNode(innerMessage) || addBizAttributes) {
-                const bizNode = getBizBinaryNode(innerMessage, addBizAttributes);
-                stanza.content.push(bizNode);
-            }
             logger.debug({ msgId }, `sending message to ${participants.length} devices`);
             await sendNode(stanza);
             // Add message to retry cache if enabled
@@ -816,23 +1028,30 @@ export const makeMessagesSocket = (config) => {
         return msgId;
     };
     const getMessageType = (message) => {
-        if (!message)
+        // groupStatusMessageV2 must be checked BEFORE normalizeMessageContent
+        // because normalizeMessageContent will unwrap it into inner message
+        if (message?.groupStatusMessageV2 || message?.groupStatusMessage) {
+            return 'text';
+        }
+        const normalizedMessage = normalizeMessageContent(message);
+        if (!normalizedMessage)
             return 'text';
-        if (message.reactionMessage || message.encReactionMessage) {
+        if (normalizedMessage.reactionMessage || normalizedMessage.encReactionMessage) {
             return 'reaction';
         }
-        if (message.pollCreationMessage ||
-            message.pollCreationMessageV2 ||
-            message.pollCreationMessageV3 ||
-            message.pollCreationMessageV5 ||
-            message.pollCreationMessageV6 ||
-            message.pollUpdateMessage) {
+        if (normalizedMessage.pollCreationMessage ||
+            normalizedMessage.pollCreationMessageV2 ||
+            normalizedMessage.pollCreationMessageV3 ||
+            normalizedMessage.pollUpdateMessage) {
             return 'poll';
         }
-        if (message.eventMessage) {
+        if (normalizedMessage.eventMessage) {
             return 'event';
         }
-        if (getMediaType(message) !== '') {
+        if (normalizedMessage.interactiveMessage) {
+            return 'text';
+        }
+        if (getMediaType(normalizedMessage) !== '') {
             return 'media';
         }
         return 'text';
@@ -844,15 +1063,12 @@ export const makeMessagesSocket = (config) => {
         else if (message.videoMessage) {
             return message.videoMessage.gifPlayback ? 'gif' : 'video';
         }
-        else if (message.stickerMessage) {
-            return message.stickerMessage.isLottie ? '1p_sticker' : message.stickerMessage.isAvatar ? 'avatar_sticker' : 'sticker';
+        else if (message.ptvMessage) {
+            return 'video';
         }
         else if (message.audioMessage) {
             return message.audioMessage.ptt ? 'ptt' : 'audio';
         }
-        else if (message.albumMessage) {
-            return 'collection';
-        }
         else if (message.contactMessage) {
             return 'vcard';
         }
@@ -865,6 +1081,9 @@ export const makeMessagesSocket = (config) => {
         else if (message.liveLocationMessage) {
             return 'livelocation';
         }
+        else if (message.stickerMessage) {
+            return 'sticker';
+        }
         else if (message.stickerPackMessage) {
             return 'sticker_pack';
         }
@@ -886,17 +1105,10 @@ export const makeMessagesSocket = (config) => {
         else if (message.interactiveResponseMessage) {
             return 'native_flow_response';
         }
-        else if (message.extendedTextMessage?.matchedText || message.groupInviteMessage) {
+        else if (message.groupInviteMessage) {
             return 'url';
         }
-        // Lia@Note 02-02-26 --- Add more message type here
-        else if ((message.extendedTextMessage?.text || message.conversation || '').includes('://wa.me/c/')) {
-            return 'cataloglink';
-        }
-        else if ((message.extendedTextMessage?.text || message.conversation || '').includes('://wa.me/p/')) {
-            return 'productlink';
-        }
-        return ''
+        return '';
     };
     const getPrivacyTokens = async (jids) => {
         const t = unixTimestampSeconds().toString();
@@ -926,6 +1138,64 @@ export const makeMessagesSocket = (config) => {
     };
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
+    // ── Button type helpers (ported from itsukichan) ──────────────────────────
+    const getButtonType = (message) => {
+        if (message.listMessage) return 'list';
+        if (message.buttonsMessage) return 'buttons';
+        if (message.templateMessage) return 'template';
+        if (message.interactiveMessage?.nativeFlowMessage) return 'native_flow';
+        if (message.interactiveMessage?.shopStorefrontMessage) return 'shop';
+        if (message.interactiveMessage?.collectionMessage) return 'collection';
+        if (message.interactiveMessage?.carouselMessage) return 'carousel';
+        if (message.interactiveMessage) return 'interactive';
+        return null;
+    };
+    const getButtonArgs = (message) => {
+        const nativeFlow = message.interactiveMessage?.nativeFlowMessage;
+        const firstButtonName = nativeFlow?.buttons?.[0]?.name;
+        const nativeFlowSpecials = [
+            'mpm', 'cta_catalog', 'send_location',
+            'call_permission_request', 'wa_payment_transaction_details',
+            'automated_greeting_message_view_catalog'
+        ];
+        const ts = unixTimestampSeconds().toString();
+        const bizBase = { actual_actors: '2', host_storage: '2', privacy_mode_ts: ts };
+        const qualityControl = { tag: 'quality_control', attrs: { source_type: 'third_party' } };
+        if (nativeFlow && (firstButtonName === 'review_and_pay' || firstButtonName === 'payment_info')) {
+            return {
+                tag: 'biz',
+                attrs: { native_flow_name: firstButtonName === 'review_and_pay' ? 'order_details' : firstButtonName }
+            };
+        } else if (nativeFlow && nativeFlowSpecials.includes(firstButtonName)) {
+            return {
+                tag: 'biz', attrs: bizBase,
+                content: [{
+                    tag: 'interactive', attrs: { type: 'native_flow', v: '1' },
+                    content: [{ tag: 'native_flow', attrs: { v: '2', name: firstButtonName } }]
+                }, qualityControl]
+            };
+        } else if (nativeFlow || message.buttonsMessage || message.templateMessage || message.interactiveMessage) {
+            // All interactive types in groups use native_flow biz node
+            // This covers: nativeFlowMessage, buttonsMessage→interactiveMessage,
+            // templateMessage→interactiveMessage, and direct interactiveMessage
+            return {
+                tag: 'biz', attrs: bizBase,
+                content: [{
+                    tag: 'interactive', attrs: { type: 'native_flow', v: '1' },
+                    content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }]
+                }, qualityControl]
+            };
+        } else if (message.listMessage) {
+            // Standalone listMessage (private chat) keeps the list biz node
+            return {
+                tag: 'biz', attrs: bizBase,
+                content: [{ tag: 'list', attrs: { v: '2', type: 'product_list' } }, qualityControl]
+            };
+        } else {
+            return { tag: 'biz', attrs: bizBase };
+        }
+    };
+    // ── End button type helpers ───────────────────────────────────────────────
     return {
         ...sock,
         getPrivacyTokens,
@@ -984,105 +1254,263 @@ export const makeMessagesSocket = (config) => {
             ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
             return message;
         },
-        // Lia@Changes 30-01-26 --- Add support for modifying additionalNodes and additionalAttributes using "options" in sendMessage()
-        sendMessage: async (jid, content, options = {}) => {
-            const userJid = authState.creds.me.id;
-            // Lia@Changes 13-03-26 --- Add status mentions!
-            if (Array.isArray(jid)) {
-                const { delayMs = 1500 } = options;
-                const allUsers = new Set();
-                const fullMsg = await generateWAMessage('status@broadcast', content, {
+        resize: async (media, width, height) => {
+            const { getStream, toBuffer } = await import('../Utils/messages-media.js');
+            let sharp;
+            try { sharp = (await import('sharp')).default; } catch (_) {}
+            if (!sharp) throw new Error('sharp is required for resize');
+            const { stream } = await getStream(media);
+            const buf = await toBuffer(stream);
+            return sharp(buf).resize(width, height, { fit: 'cover' }).toBuffer();
+        },
+        sendStatusMentions: async (content, jids = []) => {
+            const userJid = jidNormalizedUser(authState.creds.me.id);
+            let allUsers = new Set();
+            allUsers.add(userJid);
+
+            for (const id of jids) {
+                const isGroup = isJidGroup(id);
+                const isPrivate = isJidUser(id);
+                if (isGroup) {
+                    try {
+                        const metadata = (cachedGroupMetadata ? await cachedGroupMetadata(id) : null) || await groupMetadata(id);
+                        const participants = metadata.participants.map(p => jidNormalizedUser(p.id));
+                        participants.forEach(j => allUsers.add(j));
+                    } catch (error) {
+                        logger.error(`Error getting metadata for group ${id}: ${error}`);
+                    }
+                } else if (isPrivate) {
+                    allUsers.add(jidNormalizedUser(id));
+                }
+            }
+
+            const uniqueUsers = Array.from(allUsers);
+            const getRandomHexColor = () => '#' + Math.floor(Math.random() * 16777215).toString(16).padStart(6, '0');
+
+            const isMedia = content.image || content.video || content.audio;
+            const isAudio = !!content.audio;
+
+            const messageContent = { ...content };
+
+            if (isMedia && !isAudio) {
+                if (messageContent.text) {
+                    messageContent.caption = messageContent.text;
+                    delete messageContent.text;
+                }
+                delete messageContent.ptt;
+                delete messageContent.font;
+                delete messageContent.backgroundColor;
+                delete messageContent.textColor;
+            }
+            if (isAudio) {
+                delete messageContent.text;
+                delete messageContent.caption;
+                delete messageContent.font;
+                delete messageContent.textColor;
+            }
+
+            const font = !isMedia ? (content.font ?? Math.floor(Math.random() * 9)) : undefined;
+            const textColor = !isMedia ? (content.textColor ?? getRandomHexColor()) : undefined;
+            const backgroundColor = (!isMedia || isAudio) ? (content.backgroundColor ?? getRandomHexColor()) : undefined;
+            const ptt = isAudio ? (typeof content.ptt === 'boolean' ? content.ptt : true) : undefined;
+
+            let msg;
+            let mediaHandle;
+            try {
+                msg = await generateWAMessage(STORIES_JID, messageContent, {
                     logger,
                     userJid,
-                    upload: waUploadToServer,
+                    getUrlInfo: text => getUrlInfo(text, {
+                        thumbnailWidth: linkPreviewImageThumbnailWidth,
+                        fetchOpts: { timeout: 3000 },
+                        logger,
+                        uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
+                    }),
+                    upload: async (encFilePath, opts) => {
+                        const up = await waUploadToServer(encFilePath, { ...opts });
+                        mediaHandle = up.handle;
+                        return up;
+                    },
                     mediaCache: config.mediaCache,
                     options: config.options,
-                    ...options,
-                    messageId: generateMessageIDV2(userJid)
-                });
-                for (const id of jid) {
-                    if (isJidGroup(id)) {
-                        try {
-                            const groupData = (cachedGroupMetadata ? await cachedGroupMetadata(id) : null) || await groupMetadata(id);
-                            for (const participant of groupData.participants) {
-                                if (allUsers.has(participant.id))
-                                    continue;
-                                allUsers.add(participant.id);
-                            }
-                        }
-                        catch (error) {
-                            logger.error(`Error getting metadata group from ${id}: ${error}`);
-                        }
-                    }
-                    else if (!allUsers.has(id)) {
-                        allUsers.add(id);
-                    }
-                }
-                await relayMessage('status@broadcast', fullMsg.message, {
-                    messageId: fullMsg.key.id,
-                    statusJidList: Array.from(allUsers),
-                    additionalNodes: [
-                        {
-                            tag: 'meta',
-                            attrs: {},
-                            content: [
-                                {
-                                    tag: 'mentioned_users',
-                                    attrs: {},
-                                    content: jid.map(id => ({
-                                        tag: 'to',
-                                        attrs: { jid: id },
-                                        content: undefined
-                                    }))
-                                }
-                            ]
-                        }
-                    ]
+                    font,
+                    textColor,
+                    backgroundColor,
+                    ptt
                 });
-                if (config.emitOwnEvents) {
-                    process.nextTick(async () => {
-                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
-                    });
-                }
-                for (const id of jid) {
-                    const isGroup = isJidGroup(id)
-                    const sendType = isGroup ? 'groupStatusMentionMessage' : 'statusMentionMessage';
-                    const mentionMsg = generateWAMessageFromContent(id, {
-                        messageContextInfo: {
-                            messageSecret: randomBytes(32)
-                        },
-                        [sendType]: {
+            } catch (error) {
+                logger.error(`Error generating status message: ${error}`);
+                throw error;
+            }
+
+            await relayMessage(STORIES_JID, msg.message, {
+                messageId: msg.key.id,
+                statusJidList: uniqueUsers,
+                additionalNodes: [{
+                    tag: 'meta',
+                    attrs: {},
+                    content: [{
+                        tag: 'mentioned_users',
+                        attrs: {},
+                        content: jids.map(jid => ({
+                            tag: 'to',
+                            attrs: { jid: jidNormalizedUser(jid) }
+                        }))
+                    }]
+                }]
+            });
+
+            for (const id of jids) {
+                try {
+                    const normalizedId = jidNormalizedUser(id);
+                    const isPrivate = isJidUser(normalizedId);
+                    const type = isPrivate ? 'statusMentionMessage' : 'groupStatusMentionMessage';
+                    const protocolMessage = {
+                        [type]: {
                             message: {
                                 protocolMessage: {
-                                    key: fullMsg.key,
+                                    key: msg.key,
                                     type: 25
                                 }
                             }
+                        },
+                        messageContextInfo: {
+                            messageSecret: randomBytes(32)
                         }
-                    }, {
-                        userJid
-                    });
-                    await relayMessage(id, mentionMsg.message, {
-                        additionalNodes: [
-                            {
-                                tag: 'meta',
-                                attrs: isGroup ?
-                                    { is_group_status_mention: 'true' } :
-                                    { is_status_mention: 'true' },
-                                content: undefined
-                            }
-                        ]
+                    };
+                    const statusMsg = await generateWAMessageFromContent(normalizedId, protocolMessage, {});
+                    await relayMessage(normalizedId, statusMsg.message, {
+                        additionalNodes: [{
+                            tag: 'meta',
+                            attrs: isPrivate
+                                ? { is_status_mention: 'true' }
+                                : { is_group_status_mention: 'true' }
+                        }]
                     });
-                    if (config.emitOwnEvents) {
-                        process.nextTick(async () => {
-                            await messageMutex.mutex(() => upsertMessage(mentionMsg, 'append'));
-                        });
+                    await delay(2000);
+                } catch (error) {
+                    logger.error(`Error sending status mention to ${id}: ${error}`);
+                }
+            }
+
+            return msg;
+        },
+        sendMessage: async (jid, content, options = {}) => {
+            const userJid = authState.creds.me.id;
+            // ── Normalize: buttons[].nativeFlowInfo -> interactiveButtons ──────
+            if (
+                typeof content === 'object' &&
+                Array.isArray(content.buttons) &&
+                content.buttons.length > 0 &&
+                content.buttons.some(b => b.nativeFlowInfo)
+            ) {
+                const interactiveButtons = content.buttons.map(b => {
+                    if (b.nativeFlowInfo) {
+                        return {
+                            name: b.nativeFlowInfo.name,
+                            buttonParamsJson: b.nativeFlowInfo.paramsJson || '{}'
+                        };
                     }
-                    await delay(delayMs);
+                    return {
+                        name: 'quick_reply',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: b.buttonText?.displayText || b.buttonId || 'Button',
+                            id: b.buttonId || b.buttonText?.displayText || 'btn'
+                        })
+                    };
+                });
+                const { buttons, headerType, viewOnce, ...rest } = content;
+                content = { ...rest, interactiveButtons };
+            }
+            // ── Interactive Button (sendButton logic) ──────────────────────────
+            if (typeof content === 'object' && Array.isArray(content.interactiveButtons) && content.interactiveButtons.length > 0) {
+                const {
+                    text = '',
+                    caption = '',
+                    title = '',
+                    footer = '',
+                    interactiveButtons,
+                    hasMediaAttachment = false,
+                    image = null,
+                    video = null,
+                    document = null,
+                    mimetype = null,
+                    jpegThumbnail = null,
+                    location = null,
+                    product = null,
+                    businessOwnerJid = null,
+                    externalAdReply = null,
+                } = content;
+                // Normalize buttons
+                const processedButtons = [];
+                for (let i = 0; i < interactiveButtons.length; i++) {
+                    const btn = interactiveButtons[i];
+                    if (!btn || typeof btn !== 'object') throw new Error(`interactiveButtons[${i}] must be an object`);
+                    if (btn.name && btn.buttonParamsJson) { processedButtons.push(btn); continue; }
+                    if (btn.id || btn.text || btn.displayText) {
+                        processedButtons.push({ name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: btn.text || btn.displayText || `Button ${i + 1}`, id: btn.id || `quick_${i + 1}` }) });
+                        continue;
+                    }
+                    if (btn.buttonId && btn.buttonText?.displayText) {
+                        processedButtons.push({ name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: btn.buttonText.displayText, id: btn.buttonId }) });
+                        continue;
+                    }
+                    throw new Error(`interactiveButtons[${i}] has invalid shape`);
                 }
-                return fullMsg;
+                let messageContent = {};
+                // Header
+                if (image) {
+                    const mi = Buffer.isBuffer(image) ? { image } : { image: { url: typeof image === 'object' ? image.url : image } };
+                    const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                    messageContent.header = { title: title || '', hasMediaAttachment: true, imageMessage: pm.imageMessage };
+                } else if (video) {
+                    const mi = Buffer.isBuffer(video) ? { video } : { video: { url: typeof video === 'object' ? video.url : video } };
+                    const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                    messageContent.header = { title: title || '', hasMediaAttachment: true, videoMessage: pm.videoMessage };
+                } else if (document) {
+                    const mi = Buffer.isBuffer(document) ? { document } : { document: { url: typeof document === 'object' ? document.url : document } };
+                    if (mimetype && typeof mi.document === 'object') mi.document.mimetype = mimetype;
+                    if (jpegThumbnail) {
+                        const thumb = Buffer.isBuffer(jpegThumbnail) ? jpegThumbnail : await (async () => { try { const r = await fetch(jpegThumbnail); return Buffer.from(await r.arrayBuffer()); } catch { return undefined; } })();
+                        if (thumb) mi.document.jpegThumbnail = thumb;
+                    }
+                    const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                    messageContent.header = { title: title || '', hasMediaAttachment: true, documentMessage: pm.documentMessage };
+                } else if (location && typeof location === 'object') {
+                    messageContent.header = { title: title || location.name || 'Location', hasMediaAttachment: false, locationMessage: { degreesLatitude: location.degreesLatitude || location.degressLatitude || 0, degreesLongitude: location.degreesLongitude || location.degressLongitude || 0, name: location.name || '', address: location.address || '' } };
+                } else if (product && typeof product === 'object') {
+                    let productImageMessage = null;
+                    if (product.productImage) {
+                        const mi = Buffer.isBuffer(product.productImage) ? { image: product.productImage } : { image: { url: typeof product.productImage === 'object' ? product.productImage.url : product.productImage } };
+                        const pm = await prepareWAMessageMedia(mi, { upload: waUploadToServer });
+                        productImageMessage = pm.imageMessage;
+                    }
+                    messageContent.header = { title: title || product.title || 'Product', hasMediaAttachment: false, productMessage: { product: { productImage: productImageMessage, productId: product.productId || '', title: product.title || '', description: product.description || '', currencyCode: product.currencyCode || 'USD', priceAmount1000: parseInt(product.priceAmount1000) || 0, retailerId: product.retailerId || '', url: product.url || '', productImageCount: product.productImageCount || 1 }, businessOwnerJid: businessOwnerJid || product.businessOwnerJid || userJid } };
+                } else if (title) {
+                    messageContent.header = { title, hasMediaAttachment: false };
+                }
+                const hasMedia = !!(image || video || document || location || product);
+                const bodyText = hasMedia ? caption : text || caption;
+                if (bodyText) messageContent.body = { text: bodyText };
+                if (footer) messageContent.footer = { text: footer };
+                messageContent.nativeFlowMessage = { buttons: processedButtons };
+                // Context info
+                if (externalAdReply && typeof externalAdReply === 'object') {
+                    messageContent.contextInfo = { externalAdReply: { title: externalAdReply.title || '', body: externalAdReply.body || '', mediaType: externalAdReply.mediaType || 1, sourceUrl: externalAdReply.sourceUrl || externalAdReply.url || '', thumbnailUrl: externalAdReply.thumbnailUrl || externalAdReply.thumbnail || '', renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false, showAdAttribution: externalAdReply.showAdAttribution !== false, containsAutoReply: externalAdReply.containsAutoReply || false, ...(externalAdReply.mediaUrl && { mediaUrl: externalAdReply.mediaUrl }), ...(Buffer.isBuffer(externalAdReply.thumbnail) && { thumbnail: externalAdReply.thumbnail }), ...(externalAdReply.jpegThumbnail && { jpegThumbnail: externalAdReply.jpegThumbnail }) }, ...(options.mentionedJid && { mentionedJid: options.mentionedJid }) };
+                } else if (options.mentionedJid) {
+                    messageContent.contextInfo = { mentionedJid: options.mentionedJid };
+                }
+                const payload = proto.Message.InteractiveMessage.create(messageContent);
+                const msg = generateWAMessageFromContent(jid, { viewOnceMessage: { message: { interactiveMessage: payload } } }, { userJid, quoted: options?.quoted || null });
+                const additionalNodes = [{ tag: 'biz', attrs: {}, content: [{ tag: 'interactive', attrs: { type: 'native_flow', v: '1' }, content: [{ tag: 'native_flow', attrs: { v: '9', name: 'mixed' } }] }] }];
+                await relayMessage(jid, msg.message, { messageId: msg.key.id, additionalNodes });
+                return msg;
             }
-            else if ('disappearingMessagesInChat' in content && isJidGroup(jid)) {
+            // ── End Interactive Button ─────────────────────────────────────────
+            if (typeof content === 'object' &&
+                'disappearingMessagesInChat' in content &&
+                typeof content['disappearingMessagesInChat'] !== 'undefined' &&
+                isJidGroup(jid)) {
                 const { disappearingMessagesInChat } = content;
                 const value = typeof disappearingMessagesInChat === 'boolean'
                     ? disappearingMessagesInChat
@@ -1092,6 +1520,7 @@ export const makeMessagesSocket = (config) => {
                 await groupToggleEphemeral(jid, value);
             }
             else {
+                let mediaHandle;
                 const fullMsg = await generateWAMessage(jid, content, {
                     logger,
                     userJid,
@@ -1107,28 +1536,45 @@ export const makeMessagesSocket = (config) => {
                     //TODO: CACHE
                     getProfilePicUrl: sock.profilePictureUrl,
                     getCallLink: sock.createCallLink,
-                    upload: waUploadToServer,
+                    newsletter: _isNewsletterJid(jid),
+                    upload: async (encFilePath, opts) => {
+                        const up = await waUploadToServer(encFilePath, { ...opts, newsletter: _isNewsletterJid(jid) });
+                        mediaHandle = up.handle;
+                        return up;
+                    },
                     mediaCache: config.mediaCache,
                     options: config.options,
-                    ...options,
-                    messageId: generateMessageIDV2(userJid)
+                    messageId: generateMessageIDV2(sock.user?.id),
+                    ...options
                 });
-                const isNewsletter = isJidNewsletter(jid);
+                if (content?.audio && options?.contextInfo) {
+                    const msgContent = fullMsg.message;
+                    if (msgContent?.audioMessage) {
+                        msgContent.audioMessage.contextInfo = options.contextInfo;
+                    }
+                }
+                // Extract handle from newsletter upload (set by prepareWAMessageMedia)
+                if (!mediaHandle) {
+                    const msgContent = fullMsg.message;
+                    const msgTypes = ['audioMessage','imageMessage','videoMessage','documentMessage','stickerMessage'];
+                    for (const t of msgTypes) {
+                        if (msgContent?.[t]?._uploadHandle) {
+                            mediaHandle = msgContent[t]._uploadHandle;
+
+                            delete msgContent[t]._uploadHandle;
+                            break;
+                        }
+                    }
+                }
                 const isEventMsg = 'event' in content && !!content.event;
                 const isDeleteMsg = 'delete' in content && !!content.delete;
                 const isEditMsg = 'edit' in content && !!content.edit;
                 const isPinMsg = 'pin' in content && !!content.pin;
-                const isKeepMsg = 'keep' in content && !!content.keep;
-                const isPollMsg = 'poll' in content && !!content.poll;
-                const isQuizMsg = 'poll' in content && !!content.poll.pollType;
-                const isPollResultMsg = 'pollResult' in content && !!content.pollResult;
-                const isPollUpdateMsg = 'pollUpdate' in content && !!content.pollUpdate;
-                const isAiMsg = 'ai' in content && !!content.ai;
-                const isNeedBizAttrs = 'secureMetaServiceLabel' in content && !!content.secureMetaServiceLabel;
-                const additionalAttributes = options.additionalAttributes || {};
-                const additionalNodes = options.additionalNodes || [];
+                const isPollMessage = 'poll' in content && !!content.poll;
+                const additionalAttributes = {};
+                const additionalNodes = [];
                 // required for delete
-                if (isDeleteMsg || isKeepMsg) {
+                if (isDeleteMsg) {
                     // if the chat is a group, and I am not the author, then delete the message as an admin
                     if (isJidGroup(content.delete?.remoteJid) && !content.delete?.fromMe) {
                         additionalAttributes.edit = '8';
@@ -1138,23 +1584,17 @@ export const makeMessagesSocket = (config) => {
                     }
                 }
                 else if (isEditMsg) {
-                    additionalAttributes.edit = isNewsletter ? '3' : '1';
+                    additionalAttributes.edit = '1';
                 }
                 else if (isPinMsg) {
                     additionalAttributes.edit = '2';
                 }
-                else if (isPollMsg) {
-                    if (!isNewsletter && isQuizMsg) {
-                        throw new Boom('Quiz are only allowed for newsletter', { statusCode: 400 });
-                    }
+                else if (isPollMessage) {
                     additionalNodes.push({
                         tag: 'meta',
                         attrs: {
-                            // Lia@Note 08-02-26 --- Still a hypothesis regarding PollResult ༎ຶ⁠‿⁠༎ຶ
-                            polltype: isQuizMsg ? 'quiz_creation' : isPollResultMsg || isPollUpdateMsg ? 'vote' : 'creation',
-                            contenttype: isPollMsg && isNewsletter ? 'text' : undefined
-                        },
-                        content: undefined
+                            polltype: 'creation'
+                        }
                     });
                 }
                 else if (isEventMsg) {
@@ -1162,80 +1602,34 @@ export const makeMessagesSocket = (config) => {
                         tag: 'meta',
                         attrs: {
                             event_type: 'creation'
-                        },
-                        content: undefined
+                        }
                     });
                 }
-                // Lia@Changes 30-01-26 --- Add support for AI label in message when "ai" is true, but works only in private chat
-                else if (isAiMsg) {
-                    if (!(isPnUser(jid) || isLidUser(jid))) {
-                        throw new Boom('AI labeled message are only allowed in private chat', { statusCode: 400 });
-                    }
-                    if ('messageContextInfo' in fullMsg.message && !!fullMsg.message.messageContextInfo) {
-                        fullMsg.message.messageContextInfo.supportPayload = BIZ_BOT_SUPPORT_PAYLOAD;
-                    };
-                    additionalNodes.push({
-                        tag: 'bot',
-                        attrs: {
-                            biz_bot: '1'
-                        },
-                        content: undefined
-                    });
-                    delete content.ai;
+                // Auto-attach biz node for button/list/interactive messages
+                const buttonType = getButtonType(fullMsg.message);
+                if (buttonType) {
+                    const btnNode = getButtonArgs(fullMsg.message);
+                    if (btnNode) additionalNodes.push(btnNode);
+                }
+                if (mediaHandle) {
+                    additionalAttributes['media_id'] = mediaHandle;
                 }
                 await relayMessage(jid, fullMsg.message, {
                     messageId: fullMsg.key.id,
                     useCachedGroupMetadata: options.useCachedGroupMetadata,
-                    addBizAttributes: isNeedBizAttrs,
-                    statusJidList: options.statusJidList,
                     additionalAttributes,
-                    additionalNodes
+                    statusJidList: options.statusJidList,
+                    additionalNodes,
+                    AI: options.ai || false
                 });
                 if (config.emitOwnEvents) {
                     process.nextTick(async () => {
                         await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
                     });
                 }
-                // Lia@Changes 31-01-26 --- Add support for album messages
-                // Lia@Note 06-02-26 --- Refactored to reduce high RSS usage (⁠╥⁠﹏⁠╥⁠)
-                if ('album' in content) {
-                    const { delayMs = 1500 } = options;
-                    for (const albumMedia of content.album) {
-                        const albumMsg = await generateWAMessage(jid, albumMedia, {
-                            logger,
-                            userJid,
-                            upload: waUploadToServer,
-                            mediaCache: config.mediaCache,
-                            options: config.options,
-                            ...options,
-                            messageId: generateMessageIDV2(userJid)
-                        });
-                        if (!hasValidAlbumMedia(normalizeMessageContent(albumMsg.message))) {
-                            throw new Boom('Invalid message type for album', { statusCode: 400 });
-                        }
-                        albumMsg.message.messageContextInfo ||= {};
-                        albumMsg.message.messageContextInfo.messageAssociation = {
-                            parentMessageKey: fullMsg.key,
-                            associationType: AssociationType.MEDIA_ALBUM
-                        };
-                        await relayMessage(jid, albumMsg.message, {
-                            messageId: albumMsg.key.id,
-                            useCachedGroupMetadata: options.useCachedGroupMetadata,
-                            addBizAttributes: isNeedBizAttrs,
-                            statusJidList: options.statusJidList,
-                            additionalAttributes,
-                            additionalNodes
-                        });
-                        if (config.emitOwnEvents) {
-                            process.nextTick(async () => {
-                                await messageMutex.mutex(() => upsertMessage(albumMsg, 'append'));
-                            });
-                        }
-                        await delay(delayMs);
-                    }
-                }
                 return fullMsg;
             }
         }
     };
-};
+};
+//# sourceMappingURL=messages-send.js.map