@queenanya/baileys 9.2.1 → 9.4.1

package/lib/Utils/messages.js

@@ -3,12 +3,14 @@ import { randomBytes } from 'crypto';
 import { promises as fs } from 'fs';
 import {} from 'stream';
 import { proto } from '../../WAProto/index.js';
+import { buildAdminInviteMessage, buildCallMessage, buildPaymentInviteMessage, buildStickerPackMessage } from '../addons/from-messages.js';
 import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
 import { WAMessageStatus, WAProto } from '../Types/index.js';
 import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
 import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getRawMediaUploadData } from './messages-media.js';
+import { shouldIncludeReportingToken } from './reporting-utils.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
     video: 'video/mp4',
@@ -100,19 +102,22 @@ export const prepareWAMessageMedia = async (message, options) => {
         logger?.info({ key: cacheableKey }, 'Preparing raw media for newsletter');
         const { filePath, fileSha256, fileLength } = await getRawMediaUploadData(uploadData.media, options.mediaTypeOverride || mediaType, logger);
         const fileSha256B64 = fileSha256.toString('base64');
-        const { mediaUrl, directPath } = await options.upload(filePath, {
+        const { directPath, thumbnailDirectPath, thumbnailSha256 } = await options.upload(filePath, {
             fileEncSha256B64: fileSha256B64,
             mediaType: mediaType,
-            timeoutMs: options.mediaUploadTimeoutMs
+            timeoutMs: options.mediaUploadTimeoutMs,
+            newsletter: true
         });
         await fs.unlink(filePath);
         const obj = WAProto.Message.fromObject({
             // todo: add more support here
             [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
-                url: mediaUrl,
+                // url intentionally omitted — newsletters use directPath only
                 directPath,
                 fileSha256,
                 fileLength,
+                thumbnailDirectPath,
+                thumbnailSha256: thumbnailSha256 ? Buffer.from(thumbnailSha256, 'base64') : undefined,
                 ...uploadData,
                 media: undefined
             })
@@ -132,7 +137,7 @@ export const prepareWAMessageMedia = async (message, options) => {
     }
     const requiresDurationComputation = mediaType === 'audio' && typeof uploadData.seconds === 'undefined';
     const requiresThumbnailComputation = (mediaType === 'image' || mediaType === 'video') && typeof uploadData['jpegThumbnail'] === 'undefined';
-    const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true;
+    const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true && typeof uploadData.waveform === 'undefined';
     const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
     const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation;
     const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
@@ -154,7 +159,7 @@ export const prepareWAMessageMedia = async (message, options) => {
         (async () => {
             try {
                 if (requiresThumbnailComputation) {
-                    const { thumbnail, originalImageDimensions } = await generateThumbnail(originalFilePath, mediaType, options);
+                    const { thumbnail, originalImageDimensions } = await generateThumbnail(originalFilePath, mediaType, { ...options, hdMode: !!message.hd });
                     uploadData.jpegThumbnail = thumbnail;
                     if (!uploadData.width && originalImageDimensions) {
                         uploadData.width = originalImageDimensions.width;
@@ -259,10 +264,20 @@ export const generateForwardMessageContent = (message, forceForward) => {
     }
     return content;
 };
+export const hasNonNullishProperty = (message, key) => {
+    return (typeof message === 'object' &&
+        message !== null &&
+        key in message &&
+        message[key] !== null &&
+        message[key] !== undefined);
+};
+function hasOptionalProperty(obj, key) {
+    return typeof obj === 'object' && obj !== null && key in obj && obj[key] !== null;
+}
 export const generateWAMessageContent = async (message, options) => {
     var _a, _b;
     let m = {};
-    if ('text' in message) {
+    if (hasNonNullishProperty(message, 'text')) {
         const extContent = { text: message.text };
         let urlInfo = message.linkPreview;
         if (typeof urlInfo === 'undefined') {
@@ -293,7 +308,7 @@ export const generateWAMessageContent = async (message, options) => {
         }
         m.extendedTextMessage = extContent;
     }
-    else if ('contacts' in message) {
+    else if (hasNonNullishProperty(message, 'contacts')) {
         const contactLen = message.contacts.contacts.length;
         if (!contactLen) {
             throw new Boom('require atleast 1 contact', { statusCode: 400 });
@@ -305,25 +320,25 @@ export const generateWAMessageContent = async (message, options) => {
             m.contactsArrayMessage = WAProto.Message.ContactsArrayMessage.create(message.contacts);
         }
     }
-    else if ('location' in message) {
+    else if (hasNonNullishProperty(message, 'location')) {
         m.locationMessage = WAProto.Message.LocationMessage.create(message.location);
     }
-    else if ('react' in message) {
+    else if (hasNonNullishProperty(message, 'react')) {
         if (!message.react.senderTimestampMs) {
             message.react.senderTimestampMs = Date.now();
         }
         m.reactionMessage = WAProto.Message.ReactionMessage.create(message.react);
     }
-    else if ('delete' in message) {
+    else if (hasNonNullishProperty(message, 'delete')) {
         m.protocolMessage = {
             key: message.delete,
             type: WAProto.Message.ProtocolMessage.Type.REVOKE
         };
     }
-    else if ('forward' in message) {
+    else if (hasNonNullishProperty(message, 'forward')) {
         m = generateForwardMessageContent(message.forward, message.force);
     }
-    else if ('disappearingMessagesInChat' in message) {
+    else if (hasNonNullishProperty(message, 'disappearingMessagesInChat')) {
         const exp = typeof message.disappearingMessagesInChat === 'boolean'
             ? message.disappearingMessagesInChat
                 ? WA_DEFAULT_EPHEMERAL
@@ -331,7 +346,7 @@ export const generateWAMessageContent = async (message, options) => {
             : message.disappearingMessagesInChat;
         m = prepareDisappearingMessageSettingContent(exp);
     }
-    else if ('groupInvite' in message) {
+    else if (hasNonNullishProperty(message, 'groupInvite')) {
         m.groupInviteMessage = {};
         m.groupInviteMessage.inviteCode = message.groupInvite.inviteCode;
         m.groupInviteMessage.inviteExpiration = message.groupInvite.inviteExpiration;
@@ -351,7 +366,7 @@ export const generateWAMessageContent = async (message, options) => {
             }
         }
     }
-    else if ('pin' in message) {
+    else if (hasNonNullishProperty(message, 'pin')) {
         m.pinInChatMessage = {};
         m.messageContextInfo = {};
         m.pinInChatMessage.key = message.pin;
@@ -359,7 +374,7 @@ export const generateWAMessageContent = async (message, options) => {
         m.pinInChatMessage.senderTimestampMs = Date.now();
         m.messageContextInfo.messageAddOnDurationInSecs = message.type === 1 ? message.time || 86400 : 0;
     }
-    else if ('buttonReply' in message) {
+    else if (hasNonNullishProperty(message, 'buttonReply')) {
         switch (message.type) {
             case 'template':
                 m.templateButtonReplyMessage = {
@@ -375,13 +390,36 @@ export const generateWAMessageContent = async (message, options) => {
                     type: proto.Message.ButtonsResponseMessage.Type.DISPLAY_TEXT
                 };
                 break;
+            case 'list':
+                m.listResponseMessage = {
+                    title: message.buttonReply.title,
+                    description: message.buttonReply.description,
+                    singleSelectReply: {
+                        selectedRowId: message.buttonReply.rowId
+                    },
+                    listType: proto.Message.ListResponseMessage.ListType.SINGLE_SELECT
+                };
+                break;
+            case 'interactive':
+                m.interactiveResponseMessage = {
+                    body: {
+                        text: message.buttonReply.displayText,
+                        format: proto.Message.InteractiveResponseMessage.Body.Format.EXTENSIONS_1
+                    },
+                    nativeFlowResponseMessage: {
+                        name: message.buttonReply.nativeFlows?.name,
+                        paramsJson: message.buttonReply.nativeFlows?.paramsJson,
+                        version: message.buttonReply.nativeFlows?.version
+                    }
+                };
+                break;
         }
     }
-    else if ('ptv' in message && message.ptv) {
+    else if (hasOptionalProperty(message, 'ptv') && message.ptv) {
         const { videoMessage } = await prepareWAMessageMedia({ video: message.video }, options);
         m.ptvMessage = videoMessage;
     }
-    else if ('product' in message) {
+    else if (hasNonNullishProperty(message, 'product')) {
         const { imageMessage } = await prepareWAMessageMedia({ image: message.product.productImage }, options);
         m.productMessage = WAProto.Message.ProductMessage.create({
             ...message,
@@ -391,10 +429,10 @@ export const generateWAMessageContent = async (message, options) => {
             }
         });
     }
-    else if ('listReply' in message) {
+    else if (hasNonNullishProperty(message, 'listReply')) {
         m.listResponseMessage = { ...message.listReply };
     }
-    else if ('event' in message) {
+    else if (hasNonNullishProperty(message, 'event')) {
         m.eventMessage = {};
         const startTime = Math.floor(message.event.startDate.getTime() / 1000);
         if (message.event.call && options.getCallLink) {
@@ -414,7 +452,7 @@ export const generateWAMessageContent = async (message, options) => {
         m.eventMessage.isScheduleCall = message.event.isScheduleCall ?? false;
         m.eventMessage.location = message.event.location;
     }
-    else if ('poll' in message) {
+    else if (hasNonNullishProperty(message, 'poll')) {
         (_a = message.poll).selectableCount || (_a.selectableCount = 0);
         (_b = message.poll).toAnnouncementGroup || (_b.toAnnouncementGroup = false);
         if (!Array.isArray(message.poll.values)) {
@@ -425,10 +463,13 @@ export const generateWAMessageContent = async (message, options) => {
                 statusCode: 400
             });
         }
-        m.messageContextInfo = {
-            // encKey
-            messageSecret: message.poll.messageSecret || randomBytes(32)
-        };
+        // messageSecret must NOT be set for newsletter polls —
+        // newsletters handle encryption differently and a secret causes send failures
+        if (!options.jid || !isJidNewsletter(options.jid)) {
+            const providedSecret = message.poll.messageSecret;
+            const messageSecret = providedSecret instanceof Uint8Array && providedSecret.length === 32 ? providedSecret : randomBytes(32);
+            m.messageContextInfo = { messageSecret };
+        }
         const pollCreationMessage = {
             name: message.poll.name,
             selectableOptionsCount: message.poll.selectableCount,
@@ -449,15 +490,40 @@ export const generateWAMessageContent = async (message, options) => {
             }
         }
     }
-    else if ('sharePhoneNumber' in message) {
+    else if ('adminInvite' in message && !!message.adminInvite) {
+        // addons/from-messages.ts → buildAdminInviteMessage
+        m.newsletterAdminInviteMessage = await buildAdminInviteMessage(message.adminInvite, message.contextInfo, options);
+    }
+    else if ('order' in message && !!message.order) {
+        // order → OrderMessage (from addons)
+        m.orderMessage = WAProto.Message.OrderMessage.fromObject(message.order);
+    }
+    else if ('keep' in message && !!message.keep) {
+        // keep → KeepInChatMessage (from addons)
+        const k = message.keep;
+        m.keepInChatMessage = {
+            key: k.key,
+            keepType: k.type ?? 1,
+            timestampMs: k.time ?? Date.now()
+        };
+    }
+    else if ('call' in message && !!message.call) {
+        // addons/from-messages.ts → buildCallMessage
+        m.scheduledCallCreationMessage = buildCallMessage(message.call);
+    }
+    else if ('paymentInvite' in message && !!message.paymentInvite) {
+        // addons/from-messages.ts → buildPaymentInviteMessage
+        m.paymentInviteMessage = buildPaymentInviteMessage(message.paymentInvite);
+    }
+    else if (hasNonNullishProperty(message, 'sharePhoneNumber')) {
         m.protocolMessage = {
             type: proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER
         };
     }
-    else if ('requestPhoneNumber' in message) {
+    else if (hasNonNullishProperty(message, 'requestPhoneNumber')) {
         m.requestPhoneNumberMessage = {};
     }
-    else if ('limitSharing' in message) {
+    else if (hasNonNullishProperty(message, 'limitSharing')) {
         m.protocolMessage = {
             type: proto.Message.ProtocolMessage.Type.LIMIT_SHARING,
             limitSharing: {
@@ -468,25 +534,381 @@ export const generateWAMessageContent = async (message, options) => {
             }
         };
     }
+    else if ('productList' in message && !!message.productList) {
+        // productList handled below after this block — just skip media
+    }
+    else if ('album' in message && !!message.album) {
+        // album handled in sendMessage — just set albumMessage header
+        const albumOpts = message.album;
+        m.albumMessage = {
+            expectedImageCount: albumOpts.expectedImageCount,
+            expectedVideoCount: albumOpts.expectedVideoCount
+        };
+    }
+    else if ('stickerPack' in message && !!message.stickerPack) {
+        // addons/from-messages.ts → buildStickerPackMessage
+        m.stickerPackMessage = await buildStickerPackMessage(message.stickerPack, options);
+    }
     else {
         m = await prepareWAMessageMedia(message, options);
     }
-    if ('viewOnce' in message && !!message.viewOnce) {
+    // ── productList → ListMessage with products ────────────────────────────────
+    if ('productList' in message && !!message.productList) {
+        const thumbnail = message.thumbnail
+            ? await generateThumbnail(message.thumbnail, 'image', {})
+            : null;
+        const listMessage = {
+            title: message.title,
+            buttonText: message.buttonText,
+            footerText: message.footer,
+            description: message.text,
+            productListInfo: {
+                productSections: message.productList,
+                headerImage: {
+                    productId: message.productList[0]?.products?.[0]?.productId,
+                    jpegThumbnail: thumbnail?.thumbnail ?? null
+                },
+                businessOwnerJid: message.businessOwnerJid
+            },
+            listType: proto.Message.ListMessage.ListType.PRODUCT_LIST
+        };
+        listMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions?.length ? { mentionedJid: message.mentions } : {}),
+            ...(message.mentionAll ? { nonJidMentions: 1 } : {})
+        };
+        m = { listMessage };
+    }
+    // ── sections → ListMessage (standalone if, runs independently like fork) ──
+    if ('sections' in message && !!message.sections) {
+        const listMessage = {
+            title: message.title,
+            buttonText: message.buttonText,
+            footerText: message.footer,
+            description: message.text,
+            sections: message.sections,
+            listType: proto.Message.ListMessage.ListType.SINGLE_SELECT
+        };
+        listMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions?.length ? { mentionedJid: message.mentions } : {}),
+            ...(message.mentionAll ? { nonJidMentions: 1 } : {})
+        };
+        m = { listMessage };
+    }
+    // ── buttons → buttonsMessage ──────────────────────────────────────────────
+    else if ('buttons' in message && !!message.buttons) {
+        const buttonsMessage = {
+            buttons: message.buttons.map((b) => ({
+                ...b,
+                type: proto.Message.ButtonsMessage.Button.Type.RESPONSE
+            }))
+        };
+        if ('text' in message) {
+            buttonsMessage.contentText = message.text;
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType.EMPTY;
+        }
+        else {
+            if ('caption' in message) {
+                buttonsMessage.contentText = message.caption;
+            }
+            const mediaType = Object.keys(m)[0]?.replace('Message', '').toUpperCase();
+            if (mediaType && mediaType in proto.Message.ButtonsMessage.HeaderType) {
+                buttonsMessage.headerType =
+                    proto.Message.ButtonsMessage.HeaderType[mediaType];
+            }
+            Object.assign(buttonsMessage, m);
+        }
+        if ('footer' in message && !!message.footer) {
+            buttonsMessage.footerText = message.footer;
+        }
+        if ('title' in message && !!message.title) {
+            buttonsMessage.text = message.title;
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType.TEXT;
+        }
+        buttonsMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions?.length ? { mentionedJid: message.mentions } : {}),
+            ...(message.mentionAll ? { nonJidMentions: 1 } : {})
+        };
+        m = { buttonsMessage };
+    }
+    // ── templateButtons → TemplateMessage ─────────────────────────────────────
+    else if ('templateButtons' in message && !!message.templateButtons) {
+        const hydratedTemplate = {
+            hydratedButtons: message.templateButtons
+        };
+        if ('text' in message) {
+            hydratedTemplate.hydratedContentText = message.text;
+        }
+        else if ('caption' in message) {
+            hydratedTemplate.hydratedContentText = message.caption;
+            Object.assign(hydratedTemplate, m);
+        }
+        if ('footer' in message && !!message.footer) {
+            hydratedTemplate.hydratedFooterText = message.footer;
+        }
+        ;
+        hydratedTemplate.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions?.length ? { mentionedJid: message.mentions } : {}),
+            ...(message.mentionAll ? { nonJidMentions: 1 } : {})
+        };
+        m = { templateMessage: { hydratedTemplate } };
+    }
+    // ── interactiveButtons → InteractiveMessage native flow (Android + iOS) ──
+    else if ('interactiveButtons' in message && !!message.interactiveButtons) {
+        const interactiveMessage = {
+            // FIX Bug 2: messageParamsJson: '' is required — without it iOS doesn't render buttons
+            nativeFlowMessage: { buttons: message.interactiveButtons, messageParamsJson: '' }
+        };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: false
+            };
+        }
+        else if ('caption' in message) {
+            interactiveMessage.body = { text: message.caption ?? '' };
+            // FIX Bug 1: Object.assign(interactiveMessage, m) was mutating interactiveMessage
+            // AND spreading the whole corrupted object into header — completely broken.
+            // Correct fix: extract only the media fields from m and place them in header.
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: !!(m.imageMessage || m.videoMessage || m.documentMessage),
+                imageMessage: m.imageMessage ?? undefined,
+                videoMessage: m.videoMessage ?? undefined,
+                documentMessage: m.documentMessage ?? undefined
+            };
+        }
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        interactiveMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions?.length ? { mentionedJid: message.mentions } : {}),
+            ...(message.mentionAll ? { nonJidMentions: 1 } : {})
+        };
+        m = { interactiveMessage };
+    }
+    // ── shop → InteractiveMessage (shopStorefrontMessage) ─────────────────────
+    else if ('shop' in message && !!message.shop) {
+        const interactiveMessage = {
+            shopStorefrontMessage: {
+                surface: message.shop.surface,
+                id: message.shop.id
+            }
+        };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: false
+            };
+        }
+        else if ('caption' in message) {
+            interactiveMessage.body = { text: message.caption ?? '' };
+            // FIX Bug 1: same Object.assign corruption as interactiveButtons — fixed
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: !!(m.imageMessage || m.videoMessage || m.documentMessage),
+                imageMessage: m.imageMessage ?? undefined,
+                videoMessage: m.videoMessage ?? undefined,
+                documentMessage: m.documentMessage ?? undefined
+            };
+        }
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        interactiveMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions?.length ? { mentionedJid: message.mentions } : {}),
+            ...(message.mentionAll ? { nonJidMentions: 1 } : {})
+        };
+        m = { interactiveMessage };
+    }
+    // ── collection → InteractiveMessage (collectionMessage) ───────────────────
+    else if ('collection' in message && !!message.collection) {
+        const interactiveMessage = {
+            collectionMessage: {
+                bizJid: message.collection.bizJid,
+                id: message.collection.id,
+                messageVersion: message.collection.version ?? message.collection.messageVersion
+            }
+        };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: false
+            };
+        }
+        else if ('caption' in message) {
+            interactiveMessage.body = { text: message.caption ?? '' };
+            // FIX Bug 1: same Object.assign corruption — fixed
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: !!(m.imageMessage || m.videoMessage || m.documentMessage),
+                imageMessage: m.imageMessage ?? undefined,
+                videoMessage: m.videoMessage ?? undefined,
+                documentMessage: m.documentMessage ?? undefined
+            };
+        }
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
+        }
+        interactiveMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions?.length ? { mentionedJid: message.mentions } : {}),
+            ...(message.mentionAll ? { nonJidMentions: 1 } : {})
+        };
+        m = { interactiveMessage };
+    }
+    // ── cards → InteractiveMessage (carouselMessage, wrapped in viewOnce) ──────
+    else if ('cards' in message && !!message.cards) {
+        const normalizeMedia = (media) => {
+            if (!media)
+                return undefined;
+            if (Buffer.isBuffer(media))
+                return media;
+            if (typeof media === 'string')
+                return { url: media };
+            return media;
+        };
+        const slides = await Promise.all(message.cards.map(async (slide) => {
+            const { image, video, document: doc, product, title, body, footer, buttons } = slide;
+            let header = {};
+            if (product) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: normalizeMedia(product.productImage) }, options);
+                header.productMessage = { product: { ...product, productImage: imageMessage } };
+            }
+            else if (image) {
+                const prepared = await prepareWAMessageMedia({ image: normalizeMedia(image) }, options);
+                if (prepared.imageMessage)
+                    prepared.imageMessage.viewOnce = true;
+                header = prepared;
+            }
+            else if (video) {
+                const prepared = await prepareWAMessageMedia({ video: normalizeMedia(video) }, options);
+                if (prepared.videoMessage) {
+                    prepared.videoMessage.viewOnce = true;
+                    prepared.videoMessage.gifPlayback = false;
+                }
+                header = prepared;
+            }
+            else if (doc) {
+                const prepared = await prepareWAMessageMedia({
+                    document: normalizeMedia(doc),
+                    mimetype: slide.mimetype || 'application/octet-stream',
+                    fileName: slide.fileName
+                }, options);
+                header = prepared;
+            }
+            const headerProps = {
+                title,
+                hasMediaAttachment: !!(header.imageMessage ||
+                    header.videoMessage ||
+                    header.documentMessage ||
+                    header.productMessage),
+                ...header
+            };
+            return WAProto.Message.InteractiveMessage.create({
+                header: WAProto.Message.InteractiveMessage.Header.create(headerProps),
+                body: WAProto.Message.InteractiveMessage.Body.create({ text: body }),
+                footer: WAProto.Message.InteractiveMessage.Footer.create({ text: footer }),
+                nativeFlowMessage: WAProto.Message.InteractiveMessage.NativeFlowMessage.create({
+                    buttons: buttons ?? []
+                })
+            });
+        }));
+        const interactiveMessage = {
+            carouselMessage: WAProto.Message.InteractiveMessage.CarouselMessage.create({ cards: slides })
+        };
+        if ('text' in message) {
+            interactiveMessage.body = WAProto.Message.InteractiveMessage.Body.create({
+                text: message.text ?? ''
+            });
+            interactiveMessage.header = WAProto.Message.InteractiveMessage.Header.create({
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: false
+            });
+        }
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = WAProto.Message.InteractiveMessage.Footer.create({
+                text: message.footer ?? ''
+            });
+        }
+        interactiveMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions?.length ? { mentionedJid: message.mentions } : {}),
+            ...(message.mentionAll ? { nonJidMentions: 1 } : {})
+        };
+        // Wrap in viewOnceMessage matching innovators pattern for correct WA rendering
+        m = { interactiveMessage };
+    }
+    if (hasOptionalProperty(message, 'viewOnce') && !!message.viewOnce) {
         m = { viewOnceMessage: { message: m } };
     }
-    if ('mentions' in message && message.mentions?.length) {
+    // ── viewOnceExt → viewOnceMessageV2Extension ──────────────────────────────
+    if (hasOptionalProperty(message, 'viewOnceExt') && !!message.viewOnceExt) {
+        m = { viewOnceMessageV2Extension: { message: m } };
+    }
+    // ── groupStatus → groupStatusMessageV2 ────────────────────────────────────
+    if (hasOptionalProperty(message, 'groupStatus') && !!message.groupStatus) {
         const messageType = Object.keys(m)[0];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const key = m[messageType];
-        if ('contextInfo' in key && !!key.contextInfo) {
-            key.contextInfo.mentionedJid = message.mentions;
+        if (key && 'contextInfo' in key && !!key.contextInfo) {
+            key.contextInfo.isGroupStatus = message.groupStatus;
+        }
+        else if (key) {
+            key.contextInfo = { isGroupStatus: message.groupStatus };
+        }
+        m = { groupStatusMessageV2: { message: m } };
+    }
+    // ── interactiveAsTemplate → templateMessage.interactiveMessageTemplate ────
+    // FIX Bug 4: was `else if` — so it was silently skipped whenever groupStatus was set.
+    // Must be an independent `if` so both can apply independently.
+    if (hasOptionalProperty(message, 'interactiveAsTemplate') && !!message.interactiveAsTemplate) {
+        if (!m.interactiveMessage) {
+            throw new Boom('Invalid message type for template', { statusCode: 400 });
+        }
+        m = {
+            templateMessage: {
+                interactiveMessageTemplate: m.interactiveMessage,
+                templateId: message.id || `template-${Date.now()}`
+            }
+        };
+    }
+    if ((hasOptionalProperty(message, 'mentions') && message.mentions?.length) ||
+        (hasOptionalProperty(message, 'mentionAll') && message.mentionAll)) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        if (key && 'contextInfo' in key) {
+            key.contextInfo = key.contextInfo || {};
+            if (message.mentions?.length) {
+                key.contextInfo.mentionedJid = message.mentions;
+            }
+            if (message.mentionAll) {
+                key.contextInfo.nonJidMentions = 1;
+            }
         }
         else if (key) {
             key.contextInfo = {
-                mentionedJid: message.mentions
+                mentionedJid: message.mentions,
+                nonJidMentions: message.mentionAll ? 1 : 0
             };
         }
     }
-    if ('edit' in message) {
+    if (hasOptionalProperty(message, 'edit')) {
         m = {
             protocolMessage: {
                 key: message.edit,
@@ -496,7 +918,7 @@ export const generateWAMessageContent = async (message, options) => {
             }
         };
     }
-    if ('contextInfo' in message && !!message.contextInfo) {
+    if (hasOptionalProperty(message, 'contextInfo') && !!message.contextInfo) {
         const messageType = Object.keys(m)[0];
         const key = m[messageType];
         if ('contextInfo' in key && !!key.contextInfo) {
@@ -506,6 +928,21 @@ export const generateWAMessageContent = async (message, options) => {
             key.contextInfo = message.contextInfo;
         }
     }
+    if (hasOptionalProperty(message, 'albumParentKey') && !!message.albumParentKey) {
+        m.messageContextInfo = {
+            ...m.messageContextInfo,
+            messageAssociation: {
+                associationType: WAProto.MessageAssociation.AssociationType.MEDIA_ALBUM,
+                parentMessageKey: message.albumParentKey
+            }
+        };
+    }
+    if (shouldIncludeReportingToken(m)) {
+        m.messageContextInfo = m.messageContextInfo || {};
+        if (!m.messageContextInfo.messageSecret) {
+            m.messageContextInfo.messageSecret = randomBytes(32);
+        }
+    }
     return WAProto.Message.create(m);
 };
 export const generateWAMessageFromContent = (jid, message, options) => {
@@ -614,7 +1051,10 @@ export const normalizeMessageContent = (content) => {
             message?.documentWithCaptionMessage ||
             message?.viewOnceMessageV2 ||
             message?.viewOnceMessageV2Extension ||
-            message?.editedMessage);
+            message?.editedMessage ||
+            message?.associatedChildMessage ||
+            message?.groupStatusMessage ||
+            message?.groupStatusMessageV2);
     }
 };
 /**