plogme 2.0.7 → 2.0.9

package/lib/Defaults/index.js

@@ -2,7 +2,7 @@ import { proto } from '../../WAProto/index.js';
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
-const version = [2, 3000, 1047412487];
+const version = [2, 3000, 1049983640];
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const BIZ_BOT_SUPPORT_PAYLOAD = '{"version":1,"is_ai_message":true,"should_upload_client_logs":false,"should_show_system_message":false,"ticket_id":"7004947587700716","citation_items":[],"ticket_locale":"us"}';
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';

package/lib/Socket/messages-send.js

@@ -1,11 +1,11 @@
 import NodeCache from '@cacheable/node-cache';
 import { Boom } from '@hapi/boom';
-import { randomBytes } from 'crypto';
+import { randomBytes, randomUUID } 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, assertMeId, bindWaitForEvent, buildLinkPreview, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, makeWhatsAppFlowButton, getUrlFromDirectPath, getWAUploadToServer, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
-import { prepareRichMenuMessage, prepareA2UIMessage, prepareA2UICommandMenu, prepareAIRichCommandMenu, prepareSocialEntityMessage, prepareInstagramProfileMessage, prepareRichResponseMessage, prepareRichGenerationMessage, prepareCopyToClipboardMessage, prepareRichTextMessage, prepareRichQuoteMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareSocialProfileMessage, prepareUnifiedResponseMessage, prepareRichMapMessage, prepareBotPromptSuggestionsMessage, prepareBotSourcesMessage, prepareRichDynamicMediaMessage, prepareBotPttTranscriptMessage, prepareGridImageMessage, prepareVerticalAlbumMessage, prepareVideoGridMessage, prepareHtmlMessage, prepareRichHtmlMessage, attachBotVerificationProofs, hasVerifiableProofs } from '../Utils/rich-message-utils.js';
+import { prepareRichMenuMessage, prepareA2UIMessage, prepareA2UICommandMenu, prepareAIRichCommandMenu, prepareSocialEntityMessage, prepareInstagramProfileMessage, prepareRichResponseMessage, prepareRichGenerationMessage, prepareCopyToClipboardMessage, prepareRichTextMessage, prepareRichQuoteMessage, prepareRichImageMessage, prepareRichLinkMessage, prepareSocialProfileMessage, prepareUnifiedResponseMessage, prepareRichMapMessage, prepareBotPromptSuggestionsMessage, prepareBotSourcesMessage, prepareRichDynamicMediaMessage, prepareBotPttTranscriptMessage, prepareGridImageMessage, prepareVerticalAlbumMessage, prepareVideoGridMessage, prepareHtmlMessage, prepareRichHtmlMessage, buildRichLabelMessage, attachBotVerificationProofs, hasVerifiableProofs } from '../Utils/rich-message-utils.js';
 import { generateSlotMachineHtml } from '../Utils/games/slot-machine.js';
 import { generateMiniAppHtml } from '../Utils/games/miniapp.js';
 import { generateWebsitePreviewHtml, generateLinkPreviewHtml } from '../Utils/games/website-preview.js';
@@ -37,6 +37,7 @@ export const normalizeStatusJidList = (value) => {
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeUsernameSocket(config);
+    let socket;
     const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler } = sock;
     const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
 
@@ -56,57 +57,45 @@ export const makeMessagesSocket = (config) => {
 
     // ── BULK REACTION HELPER (NEW) ──
     const sendBulkReactions = async (jid, messageId, emoji, count = 1, fake = false) => {
-        const maxReactions = Math.min(count, 1000);
-        const reactions = [];
-
-        if (fake) {
-            for (let i = 0; i < maxReactions; i++) {
-                const fakeSender = `${Math.floor(Math.random() * 999999999)}${i}@s.whatsapp.net`;
-                reactions.push({
-                    key: {
-                        remoteJid: jid,
-                        fromMe: false,
-                        id: messageId,
-                        participant: fakeSender
-                    },
-                    reaction: {
-                        key: {
-                            remoteJid: jid,
-                            fromMe: false,
-                            id: messageId
-                        },
-                        text: emoji,
-                        senderTimestampMs: Date.now() + i
-                    }
-                });
-            }
-        } else {
-            for (let i = 0; i < maxReactions; i++) {
-                reactions.push({
-                    react: {
-                        text: emoji,
-                        key: {
-                            remoteJid: jid,
-                            fromMe: false,
-                            id: messageId
-                        }
-                    }
-                });
+        const maxReactions = Math.min(Math.max(Number(count) || 1, 1), 1000);
+        if (isJidNewsletter(jid)) {
+            if (typeof socket.newsletterReactMessage !== 'function') {
+                throw new Boom('newsletter reaction API is unavailable', { statusCode: 501 });
             }
+            await socket.newsletterReactMessage(jid, messageId, String(emoji || ''));
+            return { sent: 1, requested: maxReactions, fake: false, channel: true, jid };
         }
-
-        const batchSize = 50;
-        for (let i = 0; i < reactions.length; i += batchSize) {
-            const batch = reactions.slice(i, i + batchSize);
-            try {
-                await sock.sendMessage(jid, batch, { ephemeralExpiration: 86400 });
-                await delay(100);
-            } catch (err) {
-                console.log(`[BULK_REACT] Batch failed: ${err.message}`);
+        const makeReaction = () => ({
+            react: {
+                text: String(emoji || ''),
+                key: {
+                    remoteJid: jid,
+                    fromMe: false,
+                    id: messageId
+                }
             }
+        });
+        let sent = 0;
+        const batchSize = 10;
+
+        // sendMessage accepts one content object, not an array of messages.
+        // Also, fake inbound reaction records cannot be serialized as outgoing
+        // WhatsApp messages or impersonate other users. Keep the flag for API
+        // compatibility, but always send a valid reaction from this account.
+        if (fake) {
+            logger.warn('[BULK_REACT] fake=true cannot impersonate other WhatsApp users; sending valid reactions from this account');
+        }
+        for (let i = 0; i < maxReactions; i += batchSize) {
+            const batch = Array.from({ length: Math.min(batchSize, maxReactions - i) }, () =>
+                socket.sendMessage(jid, makeReaction(), { ephemeralExpiration: 86400 })
+                    .then(() => { sent += 1; })
+                    .catch(error => logger.warn(`[BULK_REACT] Reaction failed: ${error.message}`))
+            );
+            await Promise.all(batch);
+            if (i + batchSize < maxReactions) await delay(100);
         }
 
-        return { sent: maxReactions, fake, jid };
+        return { sent, requested: maxReactions, fake: false, jid };
     };
 
     // ── MIMIC HELPER ──
@@ -244,6 +233,16 @@ export const makeMessagesSocket = (config) => {
             const decoded = jidDecode(jid);
             const user = decoded?.user;
             const device = decoded?.device;
+            // Meta AI/bot JIDs are single device-0 endpoints. USync does not
+            // enumerate them, so inject the endpoint instead of dropping it.
+            if (user && (isJidMetaAI(jid) || isJidBot(jid))) {
+                deviceResults.push({
+                    user,
+                    device: typeof device === 'number' ? device : 0,
+                    jid
+                });
+                return null;
+            }
             const isExplicitDevice = typeof device === 'number' && device >= 0;
             if (isExplicitDevice && user) {
                 deviceResults.push({
@@ -407,7 +406,10 @@ export const makeMessagesSocket = (config) => {
         if (jidsRequiringFetch.length) {
             const wireJids = [
                 ...jidsRequiringFetch.filter(jid => !!isLidUser(jid) || !!isHostedLidUser(jid)),
-                ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => !!isPnUser(jid) || !!isHostedPnUser(jid)))) || []).map(a => a.lid)
+                ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => !!isPnUser(jid) || !!isHostedPnUser(jid)))) || []).map(a => a.lid),
+                // @bot endpoints are not represented by LID/PN USync results,
+                // but still require a pre-key fetch to build the Signal session.
+                ...jidsRequiringFetch.filter(jid => isJidMetaAI(jid) || isJidBot(jid))
             ];
             logger.debug({ jidsRequiringFetch, wireJids }, 'fetching sessions');
             const result = await query({
@@ -688,6 +690,16 @@ export const makeMessagesSocket = (config) => {
                 if (isStatus && statusJidList) {
                     participantsList.push(...statusJidList);
                 }
+                // Bots invoked through botGroupMetadata are not group members,
+                // so include their @bot endpoints in sender-key distribution.
+                const botGroupParticipants = message?.messageContextInfo?.botMetadata?.botGroupMetadata?.participantsMetadata || [];
+                for (const participant of botGroupParticipants) {
+                    if (!participant?.botFbid)
+                        continue;
+                    const botJid = `${participant.botFbid}@bot`;
+                    if (!participantsList.includes(botJid))
+                        participantsList.push(botJid);
+                }
                 const additionalDevices = await getUSyncDevices(participantsList, !!useUserDevicesCache, false);
                 devices.push(...additionalDevices);
                 if (isGroup) {
@@ -713,7 +725,8 @@ export const makeMessagesSocket = (config) => {
                 for (const device of devices) {
                     const deviceJid = device.jid;
                     const hasKey = !!senderKeyMap[deviceJid];
-                    if ((!hasKey || !!participant) &&
+                    const isBotRecipient = isJidMetaAI(deviceJid) || isJidBot(deviceJid);
+                    if ((!hasKey || !!participant || isBotRecipient) &&
                         !isHostedLidUser(deviceJid) &&
                         !isHostedPnUser(deviceJid) &&
                         device.device !== 99) {
@@ -1232,7 +1245,7 @@ export const makeMessagesSocket = (config) => {
         }
     });
 
-    const socket = {
+    socket = {
         ...sock,
         userDevicesCache,
         devicesMutex,
@@ -1312,7 +1325,7 @@ export const makeMessagesSocket = (config) => {
         },
         sendCarousel: async (jid, cards, options = {}) => {
             if (!Array.isArray(cards) || cards.length === 0) {
-                throw new Boom('sendCarousel requires a non-empty cards array', { statusCode: 400 });
+                throw new Boom('sendCarousel requires a non-empty card array', { statusCode: 400 });
             }
             const normalizedCards = cards.map(card => ({
                 ...card,
@@ -1328,6 +1341,7 @@ export const makeMessagesSocket = (config) => {
             const fullMsg = await generateWAMessage(jid, {
                 ...messageOptions,
                 cards: normalizedCards,
+                ...(options.carouselCardType != null ? { carouselCardType: options.carouselCardType } : {}),
                 ...(text !== undefined ? { text } : {}),
                 ...(footer !== undefined ? { footer } : {})
             }, {
@@ -1390,76 +1404,71 @@ export const makeMessagesSocket = (config) => {
             return fullMsg;
         },
         sendMetaAI: async (a, b, c = {}) => {
-            // baron signature: (jid, text, opts) — README signature: (text, opts)
-            let text;
-            let opts = c;
-            if (typeof b === 'string') {
-                text = b;
-            }
-            else {
-                text = a;
-                opts = b || {};
-            }
-            const yourJid = typeof b === 'string' ? a : (opts.yourJid || '');
+            // Supports both (text, opts) and the historical (jid, text, opts)
+            // call shape. The payload below mirrors the verified WA-Web Hatch send.
+            const legacySignature = typeof b === 'string';
+            const text = legacySignature ? b : a;
+            const opts = legacySignature ? c : (b || {});
             const META_AI_BOT_JID = '867051314767696@bot';
+            const META_AI_FBID = '867051314767696';
             const jid = opts.jid || META_AI_BOT_JID;
-            const threadId = opts.threadId || generateMessageIDV2(yourJid);
-            const now = Date.now();
-            const senderTimestamp = opts.senderTimestamp || String(Math.floor(now / 1000));
+            const isGroup = jid.endsWith('@g.us');
+            const invokerJid = opts.invokerJid || authState.creds.me?.id;
             const messageSecret = opts.messageSecret || randomBytes(32);
-            const senderKeyHash = opts.senderKeyHash || randomBytes(8).toString('base64');
-            const message = {
-                extendedTextMessage: proto.Message.ExtendedTextMessage.fromObject({
-                    text,
-                    previewType: 'NONE',
-                    contextInfo: proto.ContextInfo.fromObject({
-                        botMessageSharingInfo: {
-                            botEntryPointOrigin: 'FAVICON',
-                            forwardScore: 0
-                        }
-                    }),
-                    inviteLinkGroupTypeV2: 'DEFAULT'
-                }),
-                messageContextInfo: proto.MessageContextInfo.fromObject({
-                    deviceListMetadata: {
-                        senderKeyHash,
-                        senderTimestamp
+            const rendering = {
+                bloksVersioningId: 'd7c89519fd412464e4a4ddd60b2e5fa57c5000766a697d60835246ef0952daba',
+                pixelDensity: 2.625
+            };
+            const botMetadata = isGroup
+                ? {
+                    botGroupMetadata: {
+                        participantsMetadata: [{ botFbid: opts.botFbid || META_AI_FBID }]
                     },
-                    deviceListMetadataVersion: 2,
-                    messageSecret,
-                    botMetadata: {
-                        botModeSelectionMetadata: {
-                            overrideMode: [0]
-                        },
-                        botThreadInfo: {
-                            serverInfo: { title: text.substring(0, 50) },
-                            clientInfo: { type: 'DEFAULT' }
-                        },
-                        botRenderingConfigMetadata: {
-                            bloksVersioningId: '1eb86e6f4117d052e6bab62fe758a2e2af43747b85c5c1a886c8262bac462ea4',
-                            pixelDensity: 2.625
-                        },
-                        ...(opts.conversationContext?.length ? { aiConversationContext: opts.conversationContext } : {})
+                    botRenderingConfigMetadata: rendering
+                }
+                : {
+                    personaId: jid,
+                    invokerJid,
+                    sessionMetadata: {
+                        sessionId: opts.sessionId || randomUUID(),
+                        sessionSource: 3
                     },
-                    threadId: [
-                        {
-                            threadType: 'AI_THREAD',
-                            threadKey: {
-                                remoteJid: '0002@s.whatsapp.net',
-                                fromMe: true,
-                                id: threadId
-                            }
-                        }
-                    ]
-                })
+                    capabilityMetadata: {
+                        capabilities: opts.capabilities || Array.from({ length: 72 }, (_, i) => i + 1)
+                    },
+                    botMetricsMetadata: {
+                        destinationId: jid,
+                        destinationEntryPoint: 2
+                    }
+                };
+            const content = isGroup
+                ? (opts.mention
+                    ? { extendedTextMessage: { text, contextInfo: { mentionedJid: [META_AI_BOT_JID] } } }
+                    : { conversation: text })
+                : { extendedTextMessage: { text } };
+            const message = {
+                ...content,
+                messageContextInfo: {
+                    messageSecret,
+                    botMetadata,
+                    ...(opts.conversationContext?.length ? { aiConversationContext: opts.conversationContext } : {})
+                }
             };
-            const msgId = generateMessageIDV2(yourJid);
-            const messageOptions = {
+            const msgId = generateMessageIDV2(invokerJid || '');
+            const relayOptions = {
                 messageId: msgId,
                 ...(opts.quoted ? { quoted: opts.quoted } : {}),
-                ...(opts.links ? { links: opts.links } : {})
+                ...(opts.links ? { links: opts.links } : {}),
+                additionalNodes: [{
+                    tag: 'bot',
+                    attrs: {
+                        persona_type: opts.personaType || 'default',
+                        agent_engagement_type: opts.agentEngagementType || (isGroup ? 'group_chat' : 'direct_chat'),
+                        mode_selected: opts.modeSelected || '0'
+                    }
+                }]
             };
-            await relayMessage(jid, message, messageOptions);
+            await relayMessage(jid, message, relayOptions);
             return msgId;
         },
         // Additive Nexus-compatible AI-rich helpers. Existing Gen4/table/grid/carousel APIs remain unchanged.
@@ -1599,6 +1608,19 @@ export const makeMessagesSocket = (config) => {
             }
             return fullMsg;
         },
+        /**
+         * Send a compact forwarded AIRich label bubble. This preserves the
+         * base64 unified-response wire shape used by direct relayMessage calls.
+         */
+        sendRichLabelMessage: async (jid, content = {}, options = {}) => {
+            if (!jid) throw new Boom('sendRichLabelMessage requires a target JID', { statusCode: 400 });
+            if (!content || typeof content !== 'object' || Array.isArray(content)) {
+                throw new Boom('sendRichLabelMessage content must be an object', { statusCode: 400 });
+            }
+            const message = buildRichLabelMessage(content);
+            await relayMessage(jid, message, options);
+            return message;
+        },
         captureAndResendUnifiedResponse: async (jid, metaAiMsg, quoted, options = {}) => {
             const captured = captureUnifiedResponse(metaAiMsg);
             if (!captured) {

package/lib/Types/Message.js

@@ -8,10 +8,11 @@ export const ButtonType = proto.Message.ButtonsMessage.Button.Type;
 export const CarouselCardType = proto.Message.InteractiveMessage.CarouselMessage.CarouselCardType;
 export const ListType = proto.Message.ListMessage.ListType;
 export const ProtocolType = proto.Message.ProtocolMessage.Type;
+export const EventInviteStatus = proto.Message.EventInviteMessage.EventStatus;
 export const WAMessageStubType = proto.WebMessageInfo.StubType;
 export const WAMessageStatus = proto.WebMessageInfo.Status;
 export var WAMessageAddressingMode;
 (function (WAMessageAddressingMode) {
     WAMessageAddressingMode["PN"] = "pn";
     WAMessageAddressingMode["LID"] = "lid";
-})(WAMessageAddressingMode || (WAMessageAddressingMode = {}));
+})(WAMessageAddressingMode || (WAMessageAddressingMode = {}));

package/lib/Utils/bot-planning-replay.js

@@ -11,8 +11,7 @@
  *     → edit: step[0] → DONE
  *     → edit: step[1] → DONE
  *     → ...
- *     → delete placeholder
- *     → send final message fresh
+ *     → MESSAGE_EDIT: final answer on the same message key
  *
  * If you use or copy this code, please credit @crysnovax/bailey.
  */
@@ -119,19 +118,17 @@ export const replayPlanning = async (sock, jid, steps, finalContent, {
             await delay(finalPauseMs);
         }
 
-        if (key && !aborted) {
-            await sock.sendMessage(jid, { delete: key });
-        }
     } catch (err) {
-        try { if (key) await sock.sendMessage(jid, { delete: key }); } catch (_) {}
+        // Keep the latest successfully rendered frame if an intermediate edit fails.
     }
 
     await sock.sendPresenceUpdate('paused', jid);
 
-    // Skip final send if _skipFinalSend is set (for replayPlanningOnly)
-    if (sendOptions._skipFinalSend) return placeholder;
+    // Skip the final edit if _skipFinalSend is set (for replayPlanningOnly).
+    if (sendOptions._skipFinalSend || !key || aborted) return placeholder;
 
-    return sock.sendMessage(jid, finalContent, sendOptions);
+    const { _skipFinalSend: _ignored, ...finalSendOptions } = sendOptions;
+    return sock.sendMessage(jid, { ...finalContent, edit: key }, finalSendOptions);
 };
 
 /**

package/lib/Utils/chat-utils.js

@@ -832,6 +832,14 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
     else if (action?.lockChatAction) {
         ev.emit('chats.lock', { id: id, locked: !!action.lockChatAction.locked });
     }
+    else if (action?.communityNestingStateAction) {
+        const nestingState = action.communityNestingStateAction.nestingState;
+        ev.emit('groups.update', [{
+                id,
+                nestingState,
+                nested: nestingState === proto.SyncActionValue.CommunityNestingStateAction.NestingState.NESTING_STATE_NESTED
+            }]);
+    }
     else if (action?.privacySettingDisableLinkPreviewsAction) {
         ev.emit('settings.update', {
             setting: 'disableLinkPreviews',

package/lib/Utils/history.js

@@ -39,6 +39,8 @@ export const processHistoryMessage = (item, logger) => {
     const contacts = [];
     const chats = [];
     const lidPnMappings = [];
+    const favoriteStickers = [];
+    const omittedConversations = [];
     logger?.trace({ progress: item.progress }, 'processing history of type ' + item.syncType?.toString());
     // Extract LID-PN mappings for all sync types
     for (const m of item.phoneNumberToLidMappings || []) {
@@ -46,6 +48,21 @@ export const processHistoryMessage = (item, logger) => {
             lidPnMappings.push({ lid: m.lidJid, pn: m.pnJid });
         }
     }
+    const favoriteStickerKeys = new Set();
+    for (const sticker of item.favoriteStickers || []) {
+        const key = sticker.fileSha256 ? Buffer.from(sticker.fileSha256).toString('base64') : undefined;
+        if (!key || !favoriteStickerKeys.has(key)) {
+            if (key)
+                favoriteStickerKeys.add(key);
+            favoriteStickers.push(sticker);
+        }
+    }
+    for (const omitted of item.omittedConversations || []) {
+        omittedConversations.push({
+            id: omitted.historyChatId,
+            accountLid: omitted.accountLid || undefined
+        });
+    }
     switch (item.syncType) {
         case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
         case proto.HistorySync.HistorySyncType.RECENT:
@@ -109,6 +126,9 @@ export const processHistoryMessage = (item, logger) => {
         contacts,
         messages,
         lidPnMappings,
+        favoriteStickers,
+        omittedConversations,
+        omittedConversationsProvided: item.omittedConversationsProvided ?? false,
         syncType: item.syncType,
         progress: item.progress
     };
@@ -127,4 +147,4 @@ export const getHistoryMsg = (message) => {
     const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
     const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
     return anyHistoryMsg;
-};
+};

package/lib/Utils/messages.js

@@ -835,6 +835,33 @@ export const generateWAMessageContent = async (message, options) => {
     else if (hasNonNullishProperty(message, 'product')) {
         m.productMessage = await prepareProductMessage(message, options);
     }
+    else if (hasNonNullishProperty(message, 'eventInvite') || hasNonNullishProperty(message, 'eventInviteMessage')) {
+        const invite = message.eventInvite || message.eventInviteMessage;
+        if (!invite.eventId && !invite.id) {
+            throw new Boom('eventInvite requires an eventId', { statusCode: 400 });
+        }
+        const startTime = invite.startDate instanceof Date
+            ? Math.floor(invite.startDate.getTime() / 1000)
+            : invite.startTime != null ? Number(invite.startTime) : undefined;
+        const endTime = invite.endDate instanceof Date
+            ? Math.floor(invite.endDate.getTime() / 1000)
+            : invite.endTime != null ? Number(invite.endTime) : undefined;
+        m.eventInviteMessage = proto.Message.EventInviteMessage.fromObject({
+            eventId: invite.eventId || invite.id,
+            eventTitle: invite.title || invite.eventTitle || '',
+            caption: invite.text || invite.caption || '',
+            startTime,
+            endTime,
+            isCanceled: invite.isCancelled ?? invite.isCanceled ?? false,
+            jpegThumbnail: invite.thumbnail || invite.jpegThumbnail,
+            callLink: invite.callLink,
+            coverImageHandle: invite.coverImageHandle,
+            locationName: invite.locationName,
+            lastUpdatedTsUsec: invite.lastUpdatedTsUsec,
+            status: invite.status,
+            contextInfo: invite.contextInfo
+        });
+    }
     else if (hasNonNullishProperty(message, 'event')) {
         m.eventMessage = {};
         const startTime = Math.floor(message.event.startDate.getTime() / 1000);
@@ -1072,6 +1099,18 @@ export const generateWAMessageContent = async (message, options) => {
     else if (hasNonNullishProperty(message, 'requestPhoneNumber')) {
         m.requestPhoneNumberMessage = {};
     }
+    else if (hasNonNullishProperty(message, 'requestLocation')) {
+        m.requestLocationMessage = proto.Message.RequestLocationMessage.fromObject({});
+    }
+    else if (hasNonNullishProperty(message, 'requestLocationUpdate')) {
+        const request = message.requestLocationUpdate || {};
+        const updateType = proto.Message.RequestLocationUpdateMessage.UpdateType;
+        m.requestLocationUpdateMessage = proto.Message.RequestLocationUpdateMessage.fromObject({
+            key: request.key,
+            updateType: request.cancel ? updateType.CANCEL : (request.updateType ?? updateType.UNKNOWN),
+            senderTimestampMs: request.senderTimestampMs ?? Date.now()
+        });
+    }
     else if (hasNonNullishProperty(message, 'chatTheme')) {
         const theme = message.chatTheme || {};
         const themeSetting = {};
@@ -1080,6 +1119,31 @@ export const generateWAMessageContent = async (message, options) => {
                 (String(theme.chatThemeId).includes('@') ? theme.chatThemeId : `${theme.chatThemeId}@Tonal`);
             themeSetting.colorSchemeId = String(colorSchemeId);
         }
+        if (theme.solidColor) {
+            const solidColor = typeof theme.solidColor === 'object' ? theme.solidColor : {};
+            const hexToArgb = (value, fallback) => {
+                if (typeof value === 'number')
+                    return value >>> 0;
+                if (typeof value !== 'string')
+                    return fallback;
+                const hex = value.replace('#', '');
+                if (hex.length === 6)
+                    return (0xff000000 | parseInt(hex, 16)) >>> 0;
+                if (hex.length === 8)
+                    return parseInt(hex, 16) >>> 0;
+                return fallback;
+            };
+            const solid = {
+                backgroundLightArgb: hexToArgb(solidColor.colorLight || solidColor.color, 0xffffffff),
+                backgroundDarkArgb: hexToArgb(solidColor.colorDark || solidColor.color, 0xff000000),
+                isDoodleEnabled: solidColor.isDoodleEnabled ?? false
+            };
+            if (solidColor.doodleColorLight != null)
+                solid.doodleLightArgb = hexToArgb(solidColor.doodleColorLight);
+            if (solidColor.doodleColorDark != null)
+                solid.doodleDarkArgb = hexToArgb(solidColor.doodleColorDark);
+            themeSetting.solidColor = proto.Message.ChatSolidColorWallpaper.fromObject(solid);
+        }
         if (theme.animatedWallpaper) {
             const wallpaper = theme.animatedWallpaper;
             themeSetting.animatedWallpaper = proto.Message.ChatAnimatedWallpaper.fromObject({
@@ -1115,6 +1179,13 @@ export const generateWAMessageContent = async (message, options) => {
             }
         };
     }
+    else if (hasNonNullishProperty(message, 'cards')) {
+        // Carousel composition is handled by the interactive-message chain
+        // below. Mark this shape as recognized so cards-only sends do not
+        // fall through to prepareWAMessageMedia(message), which has no
+        // top-level media key and incorrectly throws Invalid media type.
+        m = {};
+    }
     else {
         m = await prepareWAMessageMedia(message, options);
         if (m.audioMessage && options.backgroundColor !== undefined) {
@@ -1301,6 +1372,9 @@ export const generateWAMessageContent = async (message, options) => {
         m = { interactiveMessage };
     }
     else if (hasNonNullishProperty(message, 'cards')) {
+        const carouselCardType = typeof message.carouselCardType === 'string'
+            ? ({ horizontal: CarouselCardType.HSCROLL_CARDS, hscroll: CarouselCardType.HSCROLL_CARDS, album: CarouselCardType.ALBUM_IMAGE }[message.carouselCardType.toLowerCase()] ?? CarouselCardType.HSCROLL_CARDS)
+            : (message.carouselCardType ?? CarouselCardType.HSCROLL_CARDS);
         const interactiveMessage = {
             carouselMessage: {
                 cards: await Promise.all(message.cards.map(async (card) => {
@@ -1326,18 +1400,17 @@ export const generateWAMessageContent = async (message, options) => {
                             hasMediaAttachment: isValidHeader
                         }
                     };
-                    if (hasOptionalProperty(card, 'text')) {
-                        carouselCard.body = { text: card.text };
+                    const cardBodyText = card.text ?? card.body?.text ?? card.caption;
+                    if (cardBodyText != null) {
+                        carouselCard.body = { text: cardBodyText };
                     }
-                    else {
-                        if (hasOptionalProperty(card, 'caption')) {
-                            carouselCard.body = { text: card.caption };
-                        }
-                        if (hasOptionalProperty(card, 'thumbnail') && !!card.thumbnail) {
-                            carouselCard.jpegThumbnail = card.thumbnail;
-                        }
-                        Object.assign(carouselCard.header, carouselHeader);
+                    if (hasOptionalProperty(card, 'thumbnail') && !!card.thumbnail) {
+                        carouselCard.jpegThumbnail = card.thumbnail;
                     }
+                    // The media header must be attached even when the card has
+                    // a body text. The old else-branch dropped image/video
+                    // headers for text-bearing cards, producing blank cards.
+                    Object.assign(carouselCard.header, carouselHeader);
                     if (hasOptionalProperty(card, 'audioFooter')) {
                         const { audioMessage } = await prepareWAMessageMedia({
                             audio: card.audioFooter
@@ -1352,7 +1425,7 @@ export const generateWAMessageContent = async (message, options) => {
                     }
                     return carouselCard;
                 })),
-                carouselCardType: CarouselCardType.UNKNOWN,
+                carouselCardType,
                 messageVersion: 1
             }
         };