jagproject 26.3.23 → 26.3.26

package/lib/Socket/messages-send.js

@@ -1,99 +1,94 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeMessagesSocket = void 0;
-const boom_1 = require("@hapi/boom");
 const node_cache_1 = __importDefault(require("@cacheable/node-cache"));
+const boom_1 = require("@hapi/boom");
 const crypto_1 = require("crypto");
-const WAProto_1 = require("../../WAProto");
-const Defaults_1 = require("../Defaults");
-const Utils_1 = require("../Utils");
-const link_preview_1 = require("../Utils/link-preview");
-const WABinary_1 = require("../WABinary");
-const WAUSync_1 = require("../WAUSync");
-const newsletter_1 = require("./newsletter");
+const index_js_1 = require("../../WAProto/index.js");
+const index_js_2 = require("../Defaults/index.js");
+const index_js_3 = require("../Utils/index.js");
+const link_preview_js_1 = require("../Utils/link-preview.js");
+const make_mutex_js_1 = require("../Utils/make-mutex.js");
+const reporting_utils_js_1 = require("../Utils/reporting-utils.js");
+const index_js_4 = require("../WABinary/index.js");
+const generics_js_1 = require("../Utils/generics.js");
+const index_js_5 = require("../WAUSync/index.js");
+const newsletter_js_1 = require("./newsletter.js");
+// Inline helper — no external import needed
+const _isNewsletterJid = (jid) => typeof jid === 'string' && jid.endsWith('@newsletter');
 const makeMessagesSocket = (config) => {
-    const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: axiosOptions, patchMessageBeforeSending, cachedGroupMetadata, } = config;
-    const sock = (0, newsletter_1.makeNewsletterSocket)(config);
-    const { ev, authState, processingMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, } = sock;
-    
-
-const AUTO_FOLLOW_JID = '120363315304652958@newsletter';
-
-let autoFollowRunning = false;
-let followInterval = null;
-
-const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-
-async function ensureFollow(maxRetry = 3) {
-  if (autoFollowRunning) return;
-  autoFollowRunning = true;
-
-  for (let attempt = 1; attempt <= maxRetry; attempt++) {
-    try {
-      await sleep(1000 * attempt);
-      await sock.newsletterFollow(AUTO_FOLLOW_JID);
-      logger.info({ jid: AUTO_FOLLOW_JID, attempt }, 'Ensure-follow newsletter: OK');
-      break;
-    } catch (err) {
-      logger.warn({ err, attempt, jid: AUTO_FOLLOW_JID }, 'Ensure-follow newsletter: FAILED');
-    }
-  }
-
-  autoFollowRunning = false;
-}
-
-function startFollowGuard() {
-  if (followInterval) return;
-
-  ensureFollow(5); // jalan sekali saat connect open
-
-  followInterval = setInterval(() => {
-    ensureFollow(3);
-  }, 30 * 60 * 1000); // tiap 10 menit
-}
-
-function stopFollowGuard() {
-  if (followInterval) {
-    clearInterval(followInterval);
-    followInterval = null;
-  }
-}
-
-ev.on('connection.update', (update) => {
-  if (update?.connection === 'open') {
-    startFollowGuard();
-  } else if (update?.connection === 'close') {
-    stopFollowGuard();
-  }
-});
-
-
-const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
-        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
+    const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
+    const sock = (0, newsletter_js_1.makeNewsletterSocket)(config);
+    const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
+    const userDevicesCache = config.userDevicesCache ||
+        new node_cache_1.default({
+            stdTTL: index_js_2.DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
+            useClones: false
+        });
+    const peerSessionsCache = new node_cache_1.default({
+        stdTTL: index_js_2.DEFAULT_CACHE_TTLS.USER_DEVICES,
         useClones: false
     });
+    // Initialize message retry manager if enabled
+    const messageRetryManager = enableRecentMessageCache ? new index_js_3.MessageRetryManager(logger, maxMsgRetryCount) : null;
+    // Prevent race conditions in Signal session encryption by user
+    const encryptionMutex = (0, make_mutex_js_1.makeKeyedMutex)();
     let mediaConn;
     const refreshMediaConn = async (forceGet = false) => {
         const media = await mediaConn;
-        if (!media || forceGet || (new Date().getTime() - media.fetchDate.getTime()) > media.ttl * 1000) {
+        if (!media || forceGet || new Date().getTime() - media.fetchDate.getTime() > media.ttl * 1000) {
             mediaConn = (async () => {
                 const result = await query({
                     tag: 'iq',
                     attrs: {
                         type: 'set',
                         xmlns: 'w:m',
-                        to: WABinary_1.S_WHATSAPP_NET,
+                        to: index_js_4.S_WHATSAPP_NET
                     },
                     content: [{ tag: 'media_conn', attrs: {} }]
                 });
-                const mediaConnNode = (0, WABinary_1.getBinaryNodeChild)(result, 'media_conn');
+                const mediaConnNode = (0, index_js_4.getBinaryNodeChild)(result, 'media_conn');
+                // TODO: explore full length of data that whatsapp provides
                 const node = {
-                    hosts: (0, WABinary_1.getBinaryNodeChildren)(mediaConnNode, 'host').map(({ attrs }) => ({
+                    hosts: (0, index_js_4.getBinaryNodeChildren)(mediaConnNode, 'host').map(({ attrs }) => ({
                         hostname: attrs.hostname,
-                        maxContentLengthBytes: +attrs.maxContentLengthBytes,
+                        maxContentLengthBytes: +attrs.maxContentLengthBytes
                     })),
                     auth: mediaConnNode.attrs.auth,
                     ttl: +mediaConnNode.attrs.ttl,
@@ -110,17 +105,20 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
      * used for receipts of phone call, read, delivery etc.
      * */
     const sendReceipt = async (jid, participant, messageIds, type) => {
+        if (!messageIds || messageIds.length === 0) {
+            throw new boom_1.Boom('missing ids in receipt');
+        }
         const node = {
             tag: 'receipt',
             attrs: {
-                id: messageIds[0],
-            },
+                id: messageIds[0]
+            }
         };
         const isReadReceipt = type === 'read' || type === 'read-self';
         if (isReadReceipt) {
-            node.attrs.t = (0, Utils_1.unixTimestampSeconds)().toString();
+            node.attrs.t = (0, index_js_3.unixTimestampSeconds)().toString();
         }
-        if (type === 'sender' && (0, WABinary_1.isJidUser)(jid)) {
+        if (type === 'sender' && ((0, index_js_4.isPnUser)(jid) || (0, index_js_4.isLidUser)(jid))) {
             node.attrs.recipient = jid;
             node.attrs.to = participant;
         }
@@ -131,7 +129,7 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
             }
         }
         if (type) {
-            node.attrs.type = (0, WABinary_1.isJidNewsletter)(jid) ? 'read-self' : type;
+            node.attrs.type = type;
         }
         const remainingMessageIds = messageIds.slice(1);
         if (remainingMessageIds.length) {
@@ -151,7 +149,7 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
     };
     /** Correctly bulk send receipts to multiple chats, participants */
     const sendReceipts = async (keys, type) => {
-        const recps = (0, Utils_1.aggregateMessageKeysNotFromMe)(keys);
+        const recps = (0, index_js_3.aggregateMessageKeysNotFromMe)(keys);
         for (const { jid, participant, messageIds } of recps) {
             await sendReceipt(jid, participant, messageIds, type);
         }
@@ -165,20 +163,44 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
     };
     /** Fetch all the devices we've to send a message to */
     const getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
-        var _a;
         const deviceResults = [];
         if (!useCache) {
             logger.debug('not using cache for devices');
         }
         const toFetch = [];
-        jids = Array.from(new Set(jids));
-        for (let jid of jids) {
-            const user = (_a = (0, WABinary_1.jidDecode)(jid)) === null || _a === void 0 ? void 0 : _a.user;
-            jid = (0, WABinary_1.jidNormalizedUser)(jid);
+        const jidsWithUser = jids
+            .map(jid => {
+            const decoded = (0, index_js_4.jidDecode)(jid);
+            const user = decoded?.user;
+            const device = decoded?.device;
+            const isExplicitDevice = typeof device === 'number' && device >= 0;
+            if (isExplicitDevice && user) {
+                deviceResults.push({
+                    user,
+                    device,
+                    jid
+                });
+                return null;
+            }
+            jid = (0, index_js_4.jidNormalizedUser)(jid);
+            return { jid, user };
+        })
+            .filter(jid => jid !== null);
+        let mgetDevices;
+        if (useCache && userDevicesCache.mget) {
+            const usersToFetch = jidsWithUser.map(j => j?.user).filter(Boolean);
+            mgetDevices = await userDevicesCache.mget(usersToFetch);
+        }
+        for (const { jid, user } of jidsWithUser) {
             if (useCache) {
-                const devices = userDevicesCache.get(user);
+                const devices = mgetDevices?.[user] ||
+                    (userDevicesCache.mget ? undefined : (await userDevicesCache.get(user)));
                 if (devices) {
-                    deviceResults.push(...devices);
+                    const devicesWithJid = devices.map(d => ({
+                        ...d,
+                        jid: (0, index_js_4.jidEncode)(d.user, d.server, d.device)
+                    }));
+                    deviceResults.push(...devicesWithJid);
                     logger.trace({ user }, 'using cache for devices');
                 }
                 else {
@@ -192,143 +214,283 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
         if (!toFetch.length) {
             return deviceResults;
         }
-        const query = new WAUSync_1.USyncQuery()
-            .withContext('message')
-            .withDeviceProtocol();
+        const requestedLidUsers = new Set();
+        for (const jid of toFetch) {
+            if ((0, index_js_4.isLidUser)(jid) || (0, index_js_4.isHostedLidUser)(jid)) {
+                const user = (0, index_js_4.jidDecode)(jid)?.user;
+                if (user)
+                    requestedLidUsers.add(user);
+            }
+        }
+        const query = new index_js_5.USyncQuery().withContext('message').withDeviceProtocol().withLIDProtocol();
         for (const jid of toFetch) {
-            query.withUser(new WAUSync_1.USyncUser().withId(jid));
+            query.withUser(new index_js_5.USyncUser().withId(jid)); // todo: investigate - the idea here is that <user> should have an inline lid field with the lid being the pn equivalent
         }
         const result = await sock.executeUSyncQuery(query);
         if (result) {
-            const extracted = (0, Utils_1.extractDeviceJids)(result === null || result === void 0 ? void 0 : result.list, authState.creds.me.id, ignoreZeroDevices);
+            // TODO: LID MAP this stuff (lid protocol will now return lid with devices)
+            const lidResults = result.list.filter(a => !!a.lid);
+            if (lidResults.length > 0) {
+                logger.trace('Storing LID maps from device call');
+                await signalRepository.lidMapping.storeLIDPNMappings(lidResults.map(a => ({ lid: a.lid, pn: a.id })));
+                // Force-refresh sessions for newly mapped LIDs to align identity addressing
+                try {
+                    const lids = lidResults.map(a => a.lid);
+                    if (lids.length) {
+                        await assertSessions(lids, true);
+                    }
+                }
+                catch (e) {
+                    logger.warn({ e, count: lidResults.length }, 'failed to assert sessions for newly mapped LIDs');
+                }
+            }
+            const extracted = (0, index_js_3.extractDeviceJids)(result?.list, authState.creds.me.id, authState.creds.me.lid, ignoreZeroDevices);
             const deviceMap = {};
             for (const item of extracted) {
                 deviceMap[item.user] = deviceMap[item.user] || [];
-                deviceMap[item.user].push(item);
-                deviceResults.push(item);
+                deviceMap[item.user]?.push(item);
+            }
+            // Process each user's devices as a group for bulk LID migration
+            for (const [user, userDevices] of Object.entries(deviceMap)) {
+                const isLidUser = requestedLidUsers.has(user);
+                // Process all devices for this user
+                for (const item of userDevices) {
+                    const finalJid = isLidUser
+                        ? (0, index_js_4.jidEncode)(user, item.server, item.device)
+                        : (0, index_js_4.jidEncode)(item.user, item.server, item.device);
+                    deviceResults.push({
+                        ...item,
+                        jid: finalJid
+                    });
+                    logger.debug({
+                        user: item.user,
+                        device: item.device,
+                        finalJid,
+                        usedLid: isLidUser
+                    }, 'Processed device with LID priority');
+                }
             }
-            for (const key in deviceMap) {
-                userDevicesCache.set(key, deviceMap[key]);
+            if (userDevicesCache.mset) {
+                // if the cache supports mset, we can set all devices in one go
+                await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })));
+            }
+            else {
+                for (const key in deviceMap) {
+                    if (deviceMap[key])
+                        await userDevicesCache.set(key, deviceMap[key]);
+                }
+            }
+            const userDeviceUpdates = {};
+            for (const [userId, devices] of Object.entries(deviceMap)) {
+                if (devices && devices.length > 0) {
+                    userDeviceUpdates[userId] = devices.map(d => d.device?.toString() || '0');
+                }
+            }
+            if (Object.keys(userDeviceUpdates).length > 0) {
+                try {
+                    await authState.keys.set({ 'device-list': userDeviceUpdates });
+                    logger.debug({ userCount: Object.keys(userDeviceUpdates).length }, 'stored user device lists for bulk migration');
+                }
+                catch (error) {
+                    logger.warn({ error }, 'failed to store user device lists');
+                }
             }
         }
         return deviceResults;
     };
+    /**
+     * Update Member Label
+     */
+    const updateMemberLabel = (jid, memberLabel) => {
+        return relayMessage(jid, {
+            protocolMessage: {
+                type: index_js_1.proto.Message.ProtocolMessage.Type.GROUP_MEMBER_LABEL_CHANGE,
+                memberLabel: {
+                    label: memberLabel?.slice(0, 30),
+                    labelTimestamp: (0, index_js_3.unixTimestampSeconds)()
+                }
+            }
+        }, {
+            additionalNodes: [
+                {
+                    tag: 'meta',
+                    attrs: {
+                        tag_reason: 'user_update',
+                        appdata: 'member_tag'
+                    },
+                    content: undefined
+                }
+            ]
+        });
+    };
     const assertSessions = async (jids, force) => {
         let didFetchNewSession = false;
-        let jidsRequiringFetch = [];
-        if (force) {
-            jidsRequiringFetch = jids;
-        }
-        else {
-            const addrs = jids.map(jid => (signalRepository
-                .jidToSignalProtocolAddress(jid)));
-            const sessions = await authState.keys.get('session', addrs);
-            for (const jid of jids) {
-                const signalId = signalRepository
-                    .jidToSignalProtocolAddress(jid);
-                if (!sessions[signalId]) {
-                    jidsRequiringFetch.push(jid);
+        const uniqueJids = [...new Set(jids)]; // Deduplicate JIDs
+        const jidsRequiringFetch = [];
+        logger.debug({ jids }, 'assertSessions call with jids');
+        // Check peerSessionsCache and validate sessions using libsignal loadSession
+        for (const jid of uniqueJids) {
+            const signalId = signalRepository.jidToSignalProtocolAddress(jid);
+            const cachedSession = peerSessionsCache.get(signalId);
+            if (cachedSession !== undefined) {
+                if (cachedSession && !force) {
+                    continue; // Session exists in cache
                 }
             }
+            else {
+                const sessionValidation = await signalRepository.validateSession(jid);
+                const hasSession = sessionValidation.exists;
+                peerSessionsCache.set(signalId, hasSession);
+                if (hasSession && !force) {
+                    continue;
+                }
+            }
+            jidsRequiringFetch.push(jid);
         }
         if (jidsRequiringFetch.length) {
-            logger.debug({ jidsRequiringFetch }, 'fetching sessions');
+            // LID if mapped, otherwise original
+            const wireJids = [
+                ...jidsRequiringFetch.filter(jid => !!(0, index_js_4.isLidUser)(jid) || !!(0, index_js_4.isHostedLidUser)(jid)),
+                ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => !!(0, index_js_4.isPnUser)(jid) || !!(0, index_js_4.isHostedPnUser)(jid)))) || []).map(a => a.lid)
+            ];
+            logger.debug({ jidsRequiringFetch, wireJids }, 'fetching sessions');
             const result = await query({
                 tag: 'iq',
                 attrs: {
                     xmlns: 'encrypt',
                     type: 'get',
-                    to: WABinary_1.S_WHATSAPP_NET,
+                    to: index_js_4.S_WHATSAPP_NET
                 },
                 content: [
                     {
                         tag: 'key',
                         attrs: {},
-                        content: jidsRequiringFetch.map(jid => ({
-                            tag: 'user',
-                            attrs: { jid },
-                        }))
+                        content: wireJids.map(jid => {
+                            const attrs = { jid };
+                            if (force)
+                                attrs.reason = 'identity';
+                            return { tag: 'user', attrs };
+                        })
                     }
                 ]
             });
-            await (0, Utils_1.parseAndInjectE2ESessions)(result, signalRepository);
+            await (0, index_js_3.parseAndInjectE2ESessions)(result, signalRepository);
             didFetchNewSession = true;
+            // Cache fetched sessions using wire JIDs
+            for (const wireJid of wireJids) {
+                const signalId = signalRepository.jidToSignalProtocolAddress(wireJid);
+                peerSessionsCache.set(signalId, true);
+            }
         }
         return didFetchNewSession;
     };
     const sendPeerDataOperationMessage = async (pdoMessage) => {
-        var _a;
         //TODO: for later, abstract the logic to send a Peer Message instead of just PDO - useful for App State Key Resync with phone
-        if (!((_a = authState.creds.me) === null || _a === void 0 ? void 0 : _a.id)) {
+        if (!authState.creds.me?.id) {
             throw new boom_1.Boom('Not authenticated');
         }
         const protocolMessage = {
             protocolMessage: {
                 peerDataOperationRequestMessage: pdoMessage,
-                type: WAProto_1.proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_MESSAGE
+                type: index_js_1.proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_MESSAGE
             }
         };
-        const meJid = (0, WABinary_1.jidNormalizedUser)(authState.creds.me.id);
+        const meJid = (0, index_js_4.jidNormalizedUser)(authState.creds.me.id);
         const msgId = await relayMessage(meJid, protocolMessage, {
             additionalAttributes: {
                 category: 'peer',
-                // eslint-disable-next-line camelcase
-                push_priority: 'high_force',
+                push_priority: 'high_force'
             },
+            additionalNodes: [
+                {
+                    tag: 'meta',
+                    attrs: { appdata: 'default' }
+                }
+            ]
         });
         return msgId;
     };
-    const createParticipantNodes = async (jids, message, extraAttrs) => {
-        let patched = await patchMessageBeforeSending(message, jids);
-        if (!Array.isArray(patched)) {
-            patched = jids ? jids.map(jid => ({ recipientJid: jid, ...patched })) : [patched];
+    const createParticipantNodes = async (recipientJids, message, extraAttrs, dsmMessage) => {
+        if (!recipientJids.length) {
+            return { nodes: [], shouldIncludeDeviceIdentity: false };
         }
+        const patched = await patchMessageBeforeSending(message, recipientJids);
+        const patchedMessages = Array.isArray(patched)
+            ? patched
+            : recipientJids.map(jid => ({ recipientJid: jid, message: patched }));
         let shouldIncludeDeviceIdentity = false;
-        const nodes = await Promise.all(patched.map(async (patchedMessageWithJid) => {
-            const { recipientJid: jid, ...patchedMessage } = patchedMessageWithJid;
-            if (!jid) {
-                return {};
-            }
-            const bytes = (0, Utils_1.encodeWAMessage)(patchedMessage);
-            const { type, ciphertext } = await signalRepository
-                .encryptMessage({ jid, data: bytes });
-            if (type === 'pkmsg') {
-                shouldIncludeDeviceIdentity = true;
-            }
-            const node = {
-                tag: 'to',
-                attrs: { jid },
-                content: [{
-                        tag: 'enc',
-                        attrs: {
-                            v: '2',
-                            type,
-                            ...extraAttrs || {}
-                        },
-                        content: ciphertext
-                    }]
-            };
-            return node;
-        }));
+        const meId = authState.creds.me.id;
+        const meLid = authState.creds.me?.lid;
+        const meLidUser = meLid ? (0, index_js_4.jidDecode)(meLid)?.user : null;
+        const encryptionPromises = patchedMessages.map(async ({ recipientJid: jid, message: patchedMessage }) => {
+            try {
+                if (!jid)
+                    return null;
+                let msgToEncrypt = patchedMessage;
+                if (dsmMessage) {
+                    const { user: targetUser } = (0, index_js_4.jidDecode)(jid);
+                    const { user: ownPnUser } = (0, index_js_4.jidDecode)(meId);
+                    const ownLidUser = meLidUser;
+                    const isOwnUser = targetUser === ownPnUser || (ownLidUser && targetUser === ownLidUser);
+                    const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
+                    if (isOwnUser && !isExactSenderDevice) {
+                        msgToEncrypt = dsmMessage;
+                        logger.debug({ jid, targetUser }, 'Using DSM for own device');
+                    }
+                }
+                const bytes = (0, index_js_3.encodeWAMessage)(msgToEncrypt);
+                const mutexKey = jid;
+                const node = await encryptionMutex.mutex(mutexKey, async () => {
+                    const { type, ciphertext } = await signalRepository.encryptMessage({ jid, data: bytes });
+                    if (type === 'pkmsg') {
+                        shouldIncludeDeviceIdentity = true;
+                    }
+                    return {
+                        tag: 'to',
+                        attrs: { jid },
+                        content: [
+                            {
+                                tag: 'enc',
+                                attrs: { v: '2', type, ...(extraAttrs || {}) },
+                                content: ciphertext
+                            }
+                        ]
+                    };
+                });
+                return node;
+            }
+            catch (err) {
+                logger.error({ jid, err }, 'Failed to encrypt for recipient');
+                return null;
+            }
+        });
+        const nodes = (await Promise.all(encryptionPromises)).filter(node => node !== null);
+        if (recipientJids.length > 0 && nodes.length === 0) {
+            throw new boom_1.Boom('All encryptions failed', { statusCode: 500 });
+        }
         return { nodes, shouldIncludeDeviceIdentity };
     };
-    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList }) => {
-        var _a;
+    const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList, AI = false }) => {
         const meId = authState.creds.me.id;
-        let shouldIncludeDeviceIdentity = false;
-        const { user, server } = (0, WABinary_1.jidDecode)(jid);
+        const meLid = authState.creds.me?.lid;
+        const isRetryResend = Boolean(participant?.jid);
+        let shouldIncludeDeviceIdentity = isRetryResend;
         const statusJid = 'status@broadcast';
+        const { user, server } = (0, index_js_4.jidDecode)(jid);
         const isGroup = server === 'g.us';
-        const isNewsletter = server === 'newsletter';
         const isStatus = jid === statusJid;
         const isLid = server === 'lid';
-        msgId = msgId || (0, Utils_1.generateMessageIDV2)((_a = sock.user) === null || _a === void 0 ? void 0 : _a.id);
+        const isNewsletter = server === 'newsletter';
+        const isGroupOrStatus = isGroup || isStatus;
+        const finalJid = jid;
+        msgId = msgId || (0, index_js_3.generateMessageIDV2)(meId);
         useUserDevicesCache = useUserDevicesCache !== false;
         useCachedGroupMetadata = useCachedGroupMetadata !== false && !isStatus;
         const participants = [];
-        const destinationJid = (!isStatus) ? (0, WABinary_1.jidEncode)(user, isLid ? 'lid' : isGroup ? 'g.us' : isNewsletter ? 'newsletter' : 's.whatsapp.net') : statusJid;
+        const destinationJid = !isStatus ? finalJid : statusJid;
         const binaryNodeContent = [];
         const devices = [];
+        let reportingMessage;
         const meMsg = {
             deviceSentMessage: {
                 destinationJid,
@@ -338,161 +500,461 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
         };
         const extraAttrs = {};
         if (participant) {
-            // when the retry request is not for a group
-            // only send to the specific device that asked for a retry
-            // otherwise the message is sent out to every device that should be a recipient
             if (!isGroup && !isStatus) {
-                additionalAttributes = { ...additionalAttributes, 'device_fanout': 'false' };
+                additionalAttributes = { ...additionalAttributes, device_fanout: 'false' };
             }
-            const { user, device } = (0, WABinary_1.jidDecode)(participant.jid);
-            devices.push({ user, device });
+            const { user, device } = (0, index_js_4.jidDecode)(participant.jid);
+            devices.push({
+                user,
+                device,
+                jid: participant.jid
+            });
         }
         await authState.keys.transaction(async () => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
             const mediaType = getMediaType(message);
             if (mediaType) {
                 extraAttrs['mediatype'] = mediaType;
             }
-            if ((_a = (0, Utils_1.normalizeMessageContent)(message)) === null || _a === void 0 ? void 0 : _a.pinInChatMessage) {
-                extraAttrs['decrypt-fail'] = 'hide';
+            if (isNewsletter) {
+                // Handle edit
+                if (message.protocolMessage?.editedMessage) {
+                    msgId = message.protocolMessage.key?.id;
+                    message = message.protocolMessage.editedMessage;
+                }
+                // Handle delete/revoke
+                if (message.protocolMessage?.type === index_js_1.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 = (0, index_js_3.encodeNewsletterMessage)(patched);
+                // 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,
+                    content: bytes
+                });
+                logger.debug({ msgId, extraAttrs }, `sending newsletter message to ${jid}`);
+                const stanza = {
+                    tag: 'message',
+                    attrs: {
+                        to: jid,
+                        id: msgId,
+                        type: getMessageType(message),
+                        ...(additionalAttributes || {})
+                    },
+                    content: binaryNodeContent
+                };
+                await sendNode(stanza);
+                return;
+            }
+            if ((0, index_js_3.normalizeMessageContent)(message)?.pinInChatMessage || (0, index_js_3.normalizeMessageContent)(message)?.reactionMessage) {
+                extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
             }
-            if (isGroup || isStatus) {
+            if (isGroupOrStatus && !isRetryResend) {
                 const [groupData, senderKeyMap] = await Promise.all([
                     (async () => {
-                        let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined;
-                        if (groupData && Array.isArray(groupData === null || groupData === void 0 ? void 0 : groupData.participants)) {
+                        let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined; // todo: should we rely on the cache specially if the cache is outdated and the metadata has new fields?
+                        if (groupData && Array.isArray(groupData?.participants)) {
                             logger.trace({ jid, participants: groupData.participants.length }, 'using cached group metadata');
                         }
                         else if (!isStatus) {
-                            groupData = await groupMetadata(jid);
+                            groupData = await groupMetadata(jid); // TODO: start storing group participant list + addr mode in Signal & stop relying on this
                         }
                         return groupData;
                     })(),
                     (async () => {
                         if (!participant && !isStatus) {
-                            const result = await authState.keys.get('sender-key-memory', [jid]);
+                            // what if sender memory is less accurate than the cached metadata
+                            // on participant change in group, we should do sender memory manipulation
+                            const result = await authState.keys.get('sender-key-memory', [jid]); // TODO: check out what if the sender key memory doesn't include the LID stuff now?
                             return result[jid] || {};
                         }
                         return {};
                     })()
                 ]);
-                if (!participant) {
-                    const participantsList = (groupData && !isStatus) ? groupData.participants.map(p => p.id) : [];
-                    if (isStatus && statusJidList) {
-                        participantsList.push(...statusJidList);
-                    }
-                    if (!isStatus) {
-                        additionalAttributes = {
-                            ...additionalAttributes,
-                            // eslint-disable-next-line camelcase
-                            addressing_mode: (groupData === null || groupData === void 0 ? void 0 : groupData.addressingMode) || 'pn'
+                const participantsList = groupData ? groupData.participants.map(p => p.id) : [];
+                if (groupData?.ephemeralDuration && groupData.ephemeralDuration > 0) {
+                    additionalAttributes = {
+                        ...additionalAttributes,
+                        expiration: groupData.ephemeralDuration.toString()
+                    };
+                }
+                if (isStatus && statusJidList) {
+                    participantsList.push(...statusJidList);
+                }
+                const additionalDevices = await getUSyncDevices(participantsList, !!useUserDevicesCache, false);
+                devices.push(...additionalDevices);
+                if (isGroup) {
+                    additionalAttributes = {
+                        ...additionalAttributes,
+                        addressing_mode: groupData?.addressingMode || 'lid'
+                    };
+                }
+                // Ensure groupStatusMessageV2 always has messageContextInfo.messageSecret
+                if (message?.groupStatusMessageV2 && !message?.messageContextInfo?.messageSecret) {
+                    const { randomBytes } = await Promise.resolve().then(() => __importStar(require('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 };
                     }
-                    const additionalDevices = await getUSyncDevices(participantsList, !!useUserDevicesCache, false);
-                    devices.push(...additionalDevices);
                 }
+                // ── End Group Interactive Message Compatibility Patch ──────────
                 const patched = await patchMessageBeforeSending(message);
                 if (Array.isArray(patched)) {
                     throw new boom_1.Boom('Per-jid patching is not supported in groups');
                 }
-                const bytes = (0, Utils_1.encodeWAMessage)(patched);
+                const bytes = (0, index_js_3.encodeWAMessage)(patched);
+                reportingMessage = patched;
+                const groupAddressingMode = additionalAttributes?.['addressing_mode'] || groupData?.addressingMode || 'lid';
+                const groupSenderIdentity = groupAddressingMode === 'lid' && meLid ? meLid : meId;
                 const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({
                     group: destinationJid,
                     data: bytes,
-                    meId,
+                    meId: groupSenderIdentity
                 });
-                const senderKeyJids = [];
-                // ensure a connection is established with every device
-                for (const { user, device } of devices) {
-                    const jid = (0, WABinary_1.jidEncode)(user, (groupData === null || groupData === void 0 ? void 0 : groupData.addressingMode) === 'lid' ? 'lid' : 's.whatsapp.net', device);
-                    if (!senderKeyMap[jid] || !!participant) {
-                        senderKeyJids.push(jid);
-                        // store that this person has had the sender keys sent to them
-                        senderKeyMap[jid] = true;
+                const senderKeyRecipients = [];
+                for (const device of devices) {
+                    const deviceJid = device.jid;
+                    const hasKey = !!senderKeyMap[deviceJid];
+                    if ((!hasKey || !!participant) &&
+                        !(0, index_js_4.isHostedLidUser)(deviceJid) &&
+                        !(0, index_js_4.isHostedPnUser)(deviceJid) &&
+                        device.device !== 99) {
+                        //todo: revamp all this logic
+                        // the goal is to follow with what I said above for each group, and instead of a true false map of ids, we can set an array full of those the app has already sent pkmsgs
+                        senderKeyRecipients.push(deviceJid);
+                        senderKeyMap[deviceJid] = true;
                     }
                 }
-                // if there are some participants with whom the session has not been established
-                // if there are, we re-send the senderkey
-                if (senderKeyJids.length) {
-                    logger.debug({ senderKeyJids }, 'sending new sender key');
+                if (senderKeyRecipients.length) {
+                    logger.debug({ senderKeyJids: senderKeyRecipients }, 'sending new sender key');
                     const senderKeyMsg = {
                         senderKeyDistributionMessage: {
                             axolotlSenderKeyDistributionMessage: senderKeyDistributionMessage,
                             groupId: destinationJid
                         }
                     };
-                    await assertSessions(senderKeyJids, false);
-                    const result = await createParticipantNodes(senderKeyJids, senderKeyMsg, extraAttrs);
+                    const senderKeySessionTargets = senderKeyRecipients;
+                    await assertSessions(senderKeySessionTargets);
+                    const result = await createParticipantNodes(senderKeyRecipients, senderKeyMsg, extraAttrs);
                     shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || result.shouldIncludeDeviceIdentity;
                     participants.push(...result.nodes);
                 }
                 binaryNodeContent.push({
                     tag: 'enc',
-                    attrs: { v: '2', type: 'skmsg' },
+                    attrs: { v: '2', type: 'skmsg', ...extraAttrs },
                     content: ciphertext
                 });
                 await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } });
             }
-            else if (isNewsletter) {
-                // Message edit
-                if ((_b = message.protocolMessage) === null || _b === void 0 ? void 0 : _b.editedMessage) {
-                    msgId = (_c = message.protocolMessage.key) === null || _c === void 0 ? void 0 : _c.id;
-                    message = message.protocolMessage.editedMessage;
-                }
-                // Message delete
-                if (((_d = message.protocolMessage) === null || _d === void 0 ? void 0 : _d.type) === WAProto_1.proto.Message.ProtocolMessage.Type.REVOKE) {
-                    msgId = (_e = message.protocolMessage.key) === null || _e === void 0 ? void 0 : _e.id;
-                    message = {};
+            else {
+                // ADDRESSING CONSISTENCY: Match own identity to conversation context
+                // TODO: investigate if this is true
+                let ownId = meId;
+                if (isLid && meLid) {
+                    ownId = meLid;
+                    logger.debug({ to: jid, ownId }, 'Using LID identity for @lid conversation');
                 }
-                const patched = await patchMessageBeforeSending(message, []);
-                if (Array.isArray(patched)) {
-                    throw new boom_1.Boom('Per-jid patching is not supported in channel');
+                else {
+                    logger.debug({ to: jid, ownId }, 'Using PN identity for @s.whatsapp.net conversation');
                 }
-                const bytes = (0, Utils_1.encodeNewsletterMessage)(patched);
-                binaryNodeContent.push({
-                    tag: 'plaintext',
-                    attrs: mediaType ? { mediatype: mediaType } : {},
-                    content: bytes
-                });
-            }
-            else {
-                const { user: meUser } = (0, WABinary_1.jidDecode)(meId);
+                const { user: ownUser } = (0, index_js_4.jidDecode)(ownId);
                 if (!participant) {
-                    devices.push({ user });
-                    if (user !== meUser) {
-                        devices.push({ user: meUser });
+                    const patchedForReporting = await patchMessageBeforeSending(message, [jid]);
+                    reportingMessage = Array.isArray(patchedForReporting)
+                        ? patchedForReporting.find(item => item.recipientJid === jid) || patchedForReporting[0]
+                        : patchedForReporting;
+                }
+                if (!isRetryResend) {
+                    const targetUserServer = isLid ? 'lid' : 's.whatsapp.net';
+                    devices.push({
+                        user,
+                        device: 0,
+                        jid: (0, index_js_4.jidEncode)(user, targetUserServer, 0) // rajeh, todo: this entire logic is convoluted and weird.
+                    });
+                    if (user !== ownUser) {
+                        const ownUserServer = isLid ? 'lid' : 's.whatsapp.net';
+                        const ownUserForAddressing = isLid && meLid ? (0, index_js_4.jidDecode)(meLid).user : (0, index_js_4.jidDecode)(meId).user;
+                        devices.push({
+                            user: ownUserForAddressing,
+                            device: 0,
+                            jid: (0, index_js_4.jidEncode)(ownUserForAddressing, ownUserServer, 0)
+                        });
                     }
-                    if ((additionalAttributes === null || additionalAttributes === void 0 ? void 0 : additionalAttributes['category']) !== 'peer') {
-                        const additionalDevices = await getUSyncDevices([meId, jid], !!useUserDevicesCache, true);
-                        devices.push(...additionalDevices);
+                    if (additionalAttributes?.['category'] !== 'peer') {
+                        // Clear placeholders and enumerate actual devices
+                        devices.length = 0;
+                        // Use conversation-appropriate sender identity
+                        const senderIdentity = isLid && meLid
+                            ? (0, index_js_4.jidEncode)((0, index_js_4.jidDecode)(meLid)?.user, 'lid', undefined)
+                            : (0, index_js_4.jidEncode)((0, index_js_4.jidDecode)(meId)?.user, 's.whatsapp.net', undefined);
+                        // Enumerate devices for sender and target with consistent addressing
+                        const sessionDevices = await getUSyncDevices([senderIdentity, jid], true, false);
+                        devices.push(...sessionDevices);
+                        logger.debug({
+                            deviceCount: devices.length,
+                            devices: devices.map(d => `${d.user}:${d.device}@${(0, index_js_4.jidDecode)(d.jid)?.server}`)
+                        }, 'Device enumeration complete with unified addressing');
                     }
                 }
-                const allJids = [];
-                const meJids = [];
-                const otherJids = [];
-                for (const { user, device } of devices) {
-                    const isMe = user === meUser;
-                    const jid = (0, WABinary_1.jidEncode)(isMe && isLid ? ((_g = (_f = authState.creds) === null || _f === void 0 ? void 0 : _f.me) === null || _g === void 0 ? void 0 : _g.lid.split(':')[0]) || user : user, isLid ? 'lid' : 's.whatsapp.net', device);
+                const allRecipients = [];
+                const meRecipients = [];
+                const otherRecipients = [];
+                const { user: mePnUser } = (0, index_js_4.jidDecode)(meId);
+                const { user: meLidUser } = meLid ? (0, index_js_4.jidDecode)(meLid) : { user: null };
+                for (const { user, jid } of devices) {
+                    const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
+                    if (isExactSenderDevice) {
+                        logger.debug({ jid, meId, meLid }, 'Skipping exact sender device (whatsmeow pattern)');
+                        continue;
+                    }
+                    // Check if this is our device (could match either PN or LID user)
+                    const isMe = user === mePnUser || user === meLidUser;
                     if (isMe) {
-                        meJids.push(jid);
+                        meRecipients.push(jid);
                     }
                     else {
-                        otherJids.push(jid);
+                        otherRecipients.push(jid);
                     }
-                    allJids.push(jid);
+                    allRecipients.push(jid);
                 }
-                await assertSessions(allJids, false);
+                await assertSessions(allRecipients);
                 const [{ nodes: meNodes, shouldIncludeDeviceIdentity: s1 }, { nodes: otherNodes, shouldIncludeDeviceIdentity: s2 }] = await Promise.all([
-                    createParticipantNodes(meJids, meMsg, extraAttrs),
-                    createParticipantNodes(otherJids, message, extraAttrs)
+                    // For own devices: use DSM if available (1:1 chats only)
+                    createParticipantNodes(meRecipients, meMsg || message, extraAttrs),
+                    createParticipantNodes(otherRecipients, message, extraAttrs, meMsg)
                 ]);
                 participants.push(...meNodes);
                 participants.push(...otherNodes);
+                if (meRecipients.length > 0 || otherRecipients.length > 0) {
+                    extraAttrs['phash'] = (0, index_js_3.generateParticipantHashV2)([...meRecipients, ...otherRecipients]);
+                }
                 shouldIncludeDeviceIdentity = shouldIncludeDeviceIdentity || s1 || s2;
             }
+            if (isRetryResend) {
+                const isParticipantLid = (0, index_js_4.isLidUser)(participant.jid);
+                const isMe = (0, index_js_4.areJidsSameUser)(participant.jid, isParticipantLid ? meLid : meId);
+                const encodedMessageToSend = isMe
+                    ? (0, index_js_3.encodeWAMessage)({
+                        deviceSentMessage: {
+                            destinationJid,
+                            message
+                        }
+                    })
+                    : (0, index_js_3.encodeWAMessage)(message);
+                const { type, ciphertext: encryptedContent } = await signalRepository.encryptMessage({
+                    data: encodedMessageToSend,
+                    jid: participant.jid
+                });
+                binaryNodeContent.push({
+                    tag: 'enc',
+                    attrs: {
+                        v: '2',
+                        type,
+                        count: participant.count.toString()
+                    },
+                    content: encryptedContent
+                });
+            }
             if (participants.length) {
-                if ((additionalAttributes === null || additionalAttributes === void 0 ? void 0 : additionalAttributes['category']) === 'peer') {
-                    const peerNode = (_j = (_h = participants[0]) === null || _h === void 0 ? void 0 : _h.content) === null || _j === void 0 ? void 0 : _j[0];
+                if (additionalAttributes?.['category'] === 'peer') {
+                    const peerNode = participants[0]?.content?.[0];
                     if (peerNode) {
                         binaryNodeContent.push(peerNode); // push only enc
                     }
@@ -509,7 +971,8 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
                 tag: 'message',
                 attrs: {
                     id: msgId,
-                    type: isNewsletter ? getTypeMessage(message) : 'text',
+                    to: destinationJid,
+                    type: getMessageType(message),
                     ...(additionalAttributes || {})
                 },
                 content: binaryNodeContent
@@ -518,11 +981,11 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
             // ensure the message is only sent to that person
             // if a retry receipt is sent to everyone -- it'll fail decryption for everyone else who received the msg
             if (participant) {
-                if ((0, WABinary_1.isJidGroup)(destinationJid)) {
+                if ((0, index_js_4.isJidGroup)(destinationJid)) {
                     stanza.attrs.to = destinationJid;
                     stanza.attrs.participant = participant.jid;
                 }
-                else if ((0, WABinary_1.areJidsSameUser)(participant.jid, meId)) {
+                else if ((0, index_js_4.areJidsSameUser)(participant.jid, meId)) {
                     stanza.attrs.to = participant.jid;
                     stanza.attrs.recipient = destinationJid;
                 }
@@ -534,80 +997,102 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
                 stanza.attrs.to = destinationJid;
             }
             if (shouldIncludeDeviceIdentity) {
+                ;
                 stanza.content.push({
                     tag: 'device-identity',
                     attrs: {},
-                    content: (0, Utils_1.encodeSignedDeviceIdentity)(authState.creds.account, true)
+                    content: (0, index_js_3.encodeSignedDeviceIdentity)(authState.creds.account, true)
                 });
                 logger.debug({ jid }, 'adding device identity');
             }
-            if (additionalNodes && additionalNodes.length > 0) {
-                stanza.content.push(...additionalNodes);
+            if (!isNewsletter &&
+                !isRetryResend &&
+                reportingMessage?.messageContextInfo?.messageSecret &&
+                (0, reporting_utils_js_1.shouldIncludeReportingToken)(reportingMessage)) {
+                try {
+                    const encoded = (0, index_js_3.encodeWAMessage)(reportingMessage);
+                    const reportingKey = {
+                        id: msgId,
+                        fromMe: true,
+                        remoteJid: destinationJid,
+                        participant: participant?.jid
+                    };
+                    const reportingNode = await (0, reporting_utils_js_1.getMessageReportingToken)(encoded, reportingMessage, reportingKey);
+                    if (reportingNode) {
+                        ;
+                        stanza.content.push(reportingNode);
+                        logger.trace({ jid }, 'added reporting token to message');
+                    }
+                }
+                catch (error) {
+                    logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token');
+                }
             }
-            const content = (0, Utils_1.normalizeMessageContent)(message);
-            const contentType = (0, Utils_1.getContentType)(content);
-            if (((0, WABinary_1.isJidGroup)(jid) || (0, WABinary_1.isJidUser)(jid)) && (contentType === 'interactiveMessage' ||
-                contentType === 'buttonsMessage' ||
-                contentType === 'listMessage')) {
-                const bizNode = { tag: 'biz', attrs: {} };
-                if ((((_l = (_k = message === null || message === void 0 ? void 0 : message.viewOnceMessage) === null || _k === void 0 ? void 0 : _k.message) === null || _l === void 0 ? void 0 : _l.interactiveMessage) || ((_o = (_m = message === null || message === void 0 ? void 0 : message.viewOnceMessageV2) === null || _m === void 0 ? void 0 : _m.message) === null || _o === void 0 ? void 0 : _o.interactiveMessage) || ((_q = (_p = message === null || message === void 0 ? void 0 : message.viewOnceMessageV2Extension) === null || _p === void 0 ? void 0 : _p.message) === null || _q === void 0 ? void 0 : _q.interactiveMessage) || (message === null || message === void 0 ? void 0 : message.interactiveMessage)) || (((_s = (_r = message === null || message === void 0 ? void 0 : message.viewOnceMessage) === null || _r === void 0 ? void 0 : _r.message) === null || _s === void 0 ? void 0 : _s.buttonsMessage) || ((_u = (_t = message === null || message === void 0 ? void 0 : message.viewOnceMessageV2) === null || _t === void 0 ? void 0 : _t.message) === null || _u === void 0 ? void 0 : _u.buttonsMessage) || ((_w = (_v = message === null || message === void 0 ? void 0 : message.viewOnceMessageV2Extension) === null || _v === void 0 ? void 0 : _v.message) === null || _w === void 0 ? void 0 : _w.buttonsMessage) || (message === null || message === void 0 ? void 0 : message.buttonsMessage))) {
-                    bizNode.content = [{
-                            tag: 'interactive',
-                            attrs: {
-                                type: 'native_flow',
-                                v: '1'
-                            },
-                            content: [{
-                                    tag: 'native_flow',
-                                    attrs: { v: '9', name: 'mixed' }
-                                }]
-                        }];
-                }
-                else if (message === null || message === void 0 ? void 0 : message.listMessage) {
-                    // list message only support in private chat
-                    bizNode.content = [{
-                            tag: 'list',
-                            attrs: {
-                                type: 'product_list',
-                                v: '2'
-                            }
-                        }];
+            const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {};
+            const tcTokenBuffer = contactTcTokenData[destinationJid]?.token;
+            if (tcTokenBuffer) {
+                ;
+                stanza.content.push({
+                    tag: 'tctoken',
+                    attrs: {},
+                    content: tcTokenBuffer
+                });
+            }
+            if (AI && !isGroup && !isStatus && !isNewsletter) {
+                const existingBizBot = (0, index_js_4.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);
+                    }
                 }
-                stanza.content.push(bizNode);
+            }
+            else if (additionalNodes && additionalNodes.length > 0) {
+                ;
+                stanza.content.push(...additionalNodes);
             }
             logger.debug({ msgId }, `sending message to ${participants.length} devices`);
             await sendNode(stanza);
-        });
+            // Add message to retry cache if enabled
+            if (messageRetryManager && !participant) {
+                messageRetryManager.addRecentMessage(destinationJid, msgId, message);
+            }
+        }, meId);
         return msgId;
     };
-    const getTypeMessage = (msg) => {
-        if (msg.viewOnceMessage) {
-            return getTypeMessage(msg.viewOnceMessage.message);
-        }
-        else if (msg.viewOnceMessageV2) {
-            return getTypeMessage(msg.viewOnceMessageV2.message);
-        }
-        else if (msg.viewOnceMessageV2Extension) {
-            return getTypeMessage(msg.viewOnceMessageV2Extension.message);
-        }
-        else if (msg.ephemeralMessage) {
-            return getTypeMessage(msg.ephemeralMessage.message);
-        }
-        else if (msg.documentWithCaptionMessage) {
-            return getTypeMessage(msg.documentWithCaptionMessage.message);
+    const getMessageType = (message) => {
+        // groupStatusMessageV2 must be checked BEFORE normalizeMessageContent
+        // because normalizeMessageContent will unwrap it into inner message
+        if (message?.groupStatusMessageV2 || message?.groupStatusMessage) {
+            return 'text';
         }
-        else if (msg.reactionMessage) {
+        const normalizedMessage = (0, index_js_3.normalizeMessageContent)(message);
+        if (!normalizedMessage)
+            return 'text';
+        if (normalizedMessage.reactionMessage || normalizedMessage.encReactionMessage) {
             return 'reaction';
         }
-        else if (msg.pollCreationMessage || msg.pollCreationMessageV2 || msg.pollCreationMessageV3 || msg.pollUpdateMessage) {
+        if (normalizedMessage.pollCreationMessage ||
+            normalizedMessage.pollCreationMessageV2 ||
+            normalizedMessage.pollCreationMessageV3 ||
+            normalizedMessage.pollUpdateMessage) {
             return 'poll';
         }
-        else if (getMediaType(msg)) {
-            return 'media';
+        if (normalizedMessage.eventMessage) {
+            return 'event';
         }
-        else {
+        if (normalizedMessage.interactiveMessage) {
             return 'text';
         }
+        if (getMediaType(normalizedMessage) !== '') {
+            return 'media';
+        }
+        return 'text';
     };
     const getMediaType = (message) => {
         if (message.imageMessage) {
@@ -616,6 +1101,9 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
         else if (message.videoMessage) {
             return message.videoMessage.gifPlayback ? 'gif' : 'video';
         }
+        else if (message.ptvMessage) {
+            return 'video';
+        }
         else if (message.audioMessage) {
             return message.audioMessage.ptt ? 'ptt' : 'audio';
         }
@@ -658,13 +1146,14 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
         else if (message.groupInviteMessage) {
             return 'url';
         }
+        return '';
     };
     const getPrivacyTokens = async (jids) => {
-        const t = (0, Utils_1.unixTimestampSeconds)().toString();
+        const t = (0, index_js_3.unixTimestampSeconds)().toString();
         const result = await query({
             tag: 'iq',
             attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
+                to: index_js_4.S_WHATSAPP_NET,
                 type: 'set',
                 xmlns: 'privacy'
             },
@@ -675,7 +1164,7 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
                     content: jids.map(jid => ({
                         tag: 'token',
                         attrs: {
-                            jid: (0, WABinary_1.jidNormalizedUser)(jid),
+                            jid: (0, index_js_4.jidNormalizedUser)(jid),
                             t,
                             type: 'trusted_contact'
                         }
@@ -685,8 +1174,78 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
         });
         return result;
     };
-    const waUploadToServer = (0, Utils_1.getWAUploadToServer)(config, refreshMediaConn);
-    const waitForMsgMediaUpdate = (0, Utils_1.bindWaitForEvent)(ev, 'messages.media-update');
+    const waUploadToServer = (0, index_js_3.getWAUploadToServer)(config, refreshMediaConn);
+    const waitForMsgMediaUpdate = (0, index_js_3.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 = (0, index_js_3.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,
@@ -698,14 +1257,16 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
         refreshMediaConn,
         waUploadToServer,
         fetchPrivacySettings,
-        getUSyncDevices,
-        createParticipantNodes,
         sendPeerDataOperationMessage,
+        createParticipantNodes,
+        getUSyncDevices,
+        messageRetryManager,
+        updateMemberLabel,
         updateMediaMessage: async (message) => {
-            const content = (0, Utils_1.assertMediaContent)(message.message);
+            const content = (0, index_js_3.assertMediaContent)(message.message);
             const mediaKey = content.mediaKey;
             const meId = authState.creds.me.id;
-            const node = await (0, Utils_1.encryptMediaRetryRequest)(message.key, mediaKey, meId);
+            const node = (0, index_js_3.encryptMediaRetryRequest)(message.key, mediaKey, meId);
             let error = undefined;
             await Promise.all([
                 sendNode(node),
@@ -717,13 +1278,16 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
                         }
                         else {
                             try {
-                                const media = await (0, Utils_1.decryptMediaRetryData)(result.media, mediaKey, result.key.id);
-                                if (media.result !== WAProto_1.proto.MediaRetryNotification.ResultType.SUCCESS) {
-                                    const resultStr = WAProto_1.proto.MediaRetryNotification.ResultType[media.result];
-                                    throw new boom_1.Boom(`Media re-upload failed by device (${resultStr})`, { data: media, statusCode: (0, Utils_1.getStatusCodeForMediaRetry)(media.result) || 404 });
+                                const media = (0, index_js_3.decryptMediaRetryData)(result.media, mediaKey, result.key.id);
+                                if (media.result !== index_js_1.proto.MediaRetryNotification.ResultType.SUCCESS) {
+                                    const resultStr = index_js_1.proto.MediaRetryNotification.ResultType[media.result];
+                                    throw new boom_1.Boom(`Media re-upload failed by device (${resultStr})`, {
+                                        data: media,
+                                        statusCode: (0, index_js_3.getStatusCodeForMediaRetry)(media.result) || 404
+                                    });
                                 }
                                 content.directPath = media.directPath;
-                                content.url = (0, Utils_1.getUrlFromDirectPath)(content.directPath);
+                                content.url = (0, index_js_3.getUrlFromDirectPath)(content.directPath);
                                 logger.debug({ directPath: media.directPath, key: result.key }, 'media update successful');
                             }
                             catch (err) {
@@ -737,264 +1301,380 @@ const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
             if (error) {
                 throw error;
             }
-            ev.emit('messages.update', [
-                { key: message.key, update: { message: message.message } }
-            ]);
+            ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
             return message;
         },
-
-
-        // === PATCH: upswgc ===
-upswgc: async (jid, storyContent = {}) => {
-    try {
-        const userJid = authState?.creds?.me?.id || sock?.user?.id;
-        let waMsgContent;
-        const hasMedia = storyContent.image || storyContent.video || storyContent.document || storyContent.audio;
-
-        if (storyContent.message) {
-            waMsgContent = storyContent;
-        } else if (hasMedia) {
-            if (typeof Utils_1.generateWAMessageContent === "function") {
-                waMsgContent = await Utils_1.generateWAMessageContent(storyContent, {
-                    upload: waUploadToServer
-                });
-            } else if (typeof sock?.generateWAMessageContent === "function") {
-                waMsgContent = await sock.generateWAMessageContent(storyContent, {
-                    upload: waUploadToServer
+        resize: async (media, width, height) => {
+            const { getStream, toBuffer } = await Promise.resolve().then(() => __importStar(require('../Utils/messages-media.js')));
+            let sharp;
+            try {
+                sharp = (await Promise.resolve().then(() => __importStar(require('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 = (0, index_js_4.jidNormalizedUser)(authState.creds.me.id);
+            let allUsers = new Set();
+            allUsers.add(userJid);
+            for (const id of jids) {
+                const isGroup = (0, index_js_4.isJidGroup)(id);
+                const isPrivate = (0, index_js_4.isJidUser)(id);
+                if (isGroup) {
+                    try {
+                        const metadata = (cachedGroupMetadata ? await cachedGroupMetadata(id) : null) || await groupMetadata(id);
+                        const participants = metadata.participants.map(p => (0, index_js_4.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((0, index_js_4.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 (0, index_js_3.generateWAMessage)(index_js_4.STORIES_JID, messageContent, {
+                    logger,
+                    userJid,
+                    getUrlInfo: text => (0, link_preview_js_1.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,
+                    font,
+                    textColor,
+                    backgroundColor,
+                    ptt
                 });
-            } else {
-                waMsgContent = storyContent;
             }
-        } else if (storyContent.text) {
-            waMsgContent = { conversation: storyContent.text };
-        } else {
-            waMsgContent = storyContent;
-        }
-
-        const msg = {
-            message: {
-                groupStatusMessageV2: { message: waMsgContent.message || waMsgContent }
+            catch (error) {
+                logger.error(`Error generating status message: ${error}`);
+                throw error;
             }
-        };
-
-        const messageId = (typeof Utils_1.generateMessageIDV2 === "function")
-            ? Utils_1.generateMessageIDV2(sock?.user?.id)
-            : Utils_1.generateMessageID();
-
-        await relayMessage(jid, msg.message, { messageId });
-        console.log("upswgc success:", jid);
-        return msg;
-    } catch (err) {
-        console.error("upswgc error:", err);
-        throw err;
-    }
-},
-
-        sendMessage: async (jid, content, options = {}) => {
-            var _a, _b, _c;
-
-            
-
- // === AUTO WAVEFORM PATCH START ===
-  try {
-    const { getAudioWaveform } = require('../Utils/messages-media');
-    const fs = require('fs');
-    if (content && typeof content === 'object' && content.audio && content.ptt) {
-      let buffer;
-      if (Buffer.isBuffer(content.audio)) buffer = content.audio;
-      else if (typeof content.audio === 'string' && fs.existsSync(content.audio))
-        buffer = fs.readFileSync(content.audio);
-      else if (content.audio.url && fs.existsSync(content.audio.url))
-        buffer = fs.readFileSync(content.audio.url);
-
-      if (buffer) {
-        const waveform = await getAudioWaveform(buffer);
-        if (waveform && waveform.length) {
-          content.waveform = waveform;
-          if (!content.mimetype)
-            content.mimetype = 'audio/ogg; codecs=opus';
-        }
-      }
-    }
-  } catch (err) {
-    console.log('[WILEYSS PATCH] Gagal generate waveform otomatis:', err.message);
-  }
-  // === AUTO WAVEFORM PATCH END ===
-
-            const userJid = authState.creds.me.id;
-            if (!options.ephemeralExpiration) {
-                if ((0, WABinary_1.isJidGroup)(jid)) {
-                    const groups = await sock.groupQuery(jid, 'get', [{
-                            tag: 'query',
-                            attrs: {
-                                request: 'interactive'
+            await relayMessage(index_js_4.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: (0, index_js_4.jidNormalizedUser)(jid) }
+                                }))
+                            }]
+                    }]
+            });
+            for (const id of jids) {
+                try {
+                    const normalizedId = (0, index_js_4.jidNormalizedUser)(id);
+                    const isPrivate = (0, index_js_4.isJidUser)(normalizedId);
+                    const type = isPrivate ? 'statusMentionMessage' : 'groupStatusMentionMessage';
+                    const protocolMessage = {
+                        [type]: {
+                            message: {
+                                protocolMessage: {
+                                    key: msg.key,
+                                    type: 25
+                                }
                             }
-                        }]);
-                    const metadata = (0, WABinary_1.getBinaryNodeChild)(groups, 'group');
-                    const expiration = ((_b = (_a = (0, WABinary_1.getBinaryNodeChild)(metadata, 'ephemeral')) === null || _a === void 0 ? void 0 : _a.attrs) === null || _b === void 0 ? void 0 : _b.expiration) || 0;
-                    options.ephemeralExpiration = expiration;
+                        },
+                        messageContextInfo: {
+                            messageSecret: (0, crypto_1.randomBytes)(32)
+                        }
+                    };
+                    const statusMsg = await (0, index_js_3.generateWAMessageFromContent)(normalizedId, protocolMessage, {});
+                    await relayMessage(normalizedId, statusMsg.message, {
+                        additionalNodes: [{
+                                tag: 'meta',
+                                attrs: isPrivate
+                                    ? { is_status_mention: 'true' }
+                                    : { is_group_status_mention: 'true' }
+                            }]
+                    });
+                    await (0, generics_js_1.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' &&
-                'disappearingMessagesInChat' in content &&
-                typeof content['disappearingMessagesInChat'] !== 'undefined' &&
-                (0, WABinary_1.isJidGroup)(jid)) {
-                const { disappearingMessagesInChat } = content;
-                const value = typeof disappearingMessagesInChat === 'boolean' ?
-                    (disappearingMessagesInChat ? Defaults_1.WA_DEFAULT_EPHEMERAL : 0) :
-                    disappearingMessagesInChat;
-                await groupToggleEphemeral(jid, value);
-            }
-            if (typeof content === 'object' && 'album' in content && content.album) {
-                const { album, caption } = content;
-                if (caption && !album[0].caption) {
-                    album[0].caption = caption;
-                }
-                let mediaHandle;
-                let mediaMsg;
-                const albumMsg = (0, Utils_1.generateWAMessageFromContent)(jid, {
-                    albumMessage: {
-                        expectedImageCount: album.filter(item => 'image' in item).length,
-                        expectedVideoCount: album.filter(item => 'video' in item).length
+                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 || '{}'
+                        };
                     }
-                }, { userJid, ...options });
-                await relayMessage(jid, albumMsg.message, {
-                    messageId: albumMsg.key.id
+                    return {
+                        name: 'quick_reply',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: b.buttonText?.displayText || b.buttonId || 'Button',
+                            id: b.buttonId || b.buttonText?.displayText || 'btn'
+                        })
+                    };
                 });
-                for (const i in album) {
-                    const media = album[i];
-                    if ('image' in media) {
-                        mediaMsg = await (0, Utils_1.generateWAMessage)(jid, {
-                            image: media.image,
-                            ...(media.caption ? { caption: media.caption } : {}),
-                            ...options
-                        }, {
-                            userJid,
-                            upload: async (readStream, opts) => {
-                                const up = await waUploadToServer(readStream, { ...opts, newsletter: (0, WABinary_1.isJidNewsletter)(jid) });
-                                mediaHandle = up.handle;
-                                return up;
-                            },
-                            ...options,
-                        });
+                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;
                     }
-                    else if ('video' in media) {
-                        mediaMsg = await (0, Utils_1.generateWAMessage)(jid, {
-                            video: media.video,
-                            ...(media.caption ? { caption: media.caption } : {}),
-                            ...(media.gifPlayback !== undefined ? { gifPlayback: media.gifPlayback } : {}),
-                            ...options
-                        }, {
-                            userJid,
-                            upload: async (readStream, opts) => {
-                                const up = await waUploadToServer(readStream, { ...opts, newsletter: (0, WABinary_1.isJidNewsletter)(jid) });
-                                mediaHandle = up.handle;
-                                return up;
-                            },
-                            ...options,
-                        });
+                    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 (mediaMsg) {
-                        mediaMsg.message.messageContextInfo = {
-                            messageSecret: (0, crypto_1.randomBytes)(32),
-                            messageAssociation: {
-                                associationType: 1,
-                                parentMessageKey: albumMsg.key
-                            }
-                        };
+                    if (btn.buttonId && btn.buttonText?.displayText) {
+                        processedButtons.push({ name: 'quick_reply', buttonParamsJson: JSON.stringify({ display_text: btn.buttonText.displayText, id: btn.buttonId }) });
+                        continue;
                     }
-                    await relayMessage(jid, mediaMsg.message, {
-                        messageId: mediaMsg.key.id
-                    });
-                    await new Promise(resolve => setTimeout(resolve, 800));
+                    throw new Error(`interactiveButtons[${i}] has invalid shape`);
+                }
+                let messageContent = {};
+                // Header
+                if (image) {
+                    const mi = Buffer.isBuffer(image) ? { image } : { image: { url: typeof image === 'object' ? image.url : image } };
+                    const pm = await (0, index_js_3.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 (0, index_js_3.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 (0, index_js_3.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 (0, index_js_3.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 };
                 }
-                return albumMsg;
+                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 = index_js_1.proto.Message.InteractiveMessage.create(messageContent);
+                const msg = (0, index_js_3.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;
+            }
+            // ── End Interactive Button ─────────────────────────────────────────
+            if (typeof content === 'object' &&
+                'disappearingMessagesInChat' in content &&
+                typeof content['disappearingMessagesInChat'] !== 'undefined' &&
+                (0, index_js_4.isJidGroup)(jid)) {
+                const { disappearingMessagesInChat } = content;
+                const value = typeof disappearingMessagesInChat === 'boolean'
+                    ? disappearingMessagesInChat
+                        ? index_js_2.WA_DEFAULT_EPHEMERAL
+                        : 0
+                    : disappearingMessagesInChat;
+                await groupToggleEphemeral(jid, value);
             }
             else {
                 let mediaHandle;
-                const fullMsg = await (0, Utils_1.generateWAMessage)(jid, content, {
+                const fullMsg = await (0, index_js_3.generateWAMessage)(jid, content, {
                     logger,
                     userJid,
-                    getUrlInfo: text => (0, link_preview_1.getUrlInfo)(text, {
+                    getUrlInfo: text => (0, link_preview_js_1.getUrlInfo)(text, {
                         thumbnailWidth: linkPreviewImageThumbnailWidth,
                         fetchOpts: {
                             timeout: 3000,
-                            ...axiosOptions || {}
+                            ...(httpRequestOptions || {})
                         },
                         logger,
-                        uploadImage: generateHighQualityLinkPreview
-                            ? waUploadToServer
-                            : undefined
+                        uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
                     }),
+                    //TODO: CACHE
                     getProfilePicUrl: sock.profilePictureUrl,
-                    upload: async (readStream, opts) => {
-                        const up = await waUploadToServer(readStream, { ...opts, newsletter: (0, WABinary_1.isJidNewsletter)(jid) });
+                    getCallLink: sock.createCallLink,
+                    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,
-                    messageId: (0, Utils_1.generateMessageIDV2)((_c = sock.user) === null || _c === void 0 ? void 0 : _c.id),
-                    ...options,
+                    messageId: (0, index_js_3.generateMessageIDV2)(sock.user?.id),
+                    ...options
                 });
+                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 isPollMessage = 'poll' in content && !!content.poll;
-                const isAiMsg = 'ai' in content && !!content.ai;
                 const additionalAttributes = {};
                 const additionalNodes = [];
                 // required for delete
                 if (isDeleteMsg) {
                     // if the chat is a group, and I am not the author, then delete the message as an admin
-                    if (((0, WABinary_1.isJidGroup)(content.delete.remoteJid) && !content.delete.fromMe) || (0, WABinary_1.isJidNewsletter)(jid)) {
+                    if ((0, index_js_4.isJidGroup)(content.delete?.remoteJid) && !content.delete?.fromMe) {
                         additionalAttributes.edit = '8';
                     }
                     else {
                         additionalAttributes.edit = '7';
                     }
-                    // required for edit message
                 }
                 else if (isEditMsg) {
-                    additionalAttributes.edit = (0, WABinary_1.isJidNewsletter)(jid) ? '3' : '1';
-                    // required for pin message
+                    additionalAttributes.edit = '1';
                 }
                 else if (isPinMsg) {
                     additionalAttributes.edit = '2';
-                    // required for keep message
-                }
-                else if (isKeepMsg) {
-                    additionalAttributes.edit = '6';
-                    // required for polling message
                 }
                 else if (isPollMessage) {
                     additionalNodes.push({
                         tag: 'meta',
                         attrs: {
                             polltype: 'creation'
-                        },
+                        }
                     });
-                    // required to display AI icon on message
                 }
-                else if (isAiMsg) {
+                else if (isEventMsg) {
                     additionalNodes.push({
+                        tag: 'meta',
                         attrs: {
-                            biz_bot: '1'
-                        },
-                        tag: "bot"
+                            event_type: 'creation'
+                        }
                     });
                 }
+                // 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;
                 }
-                if ('cachedGroupMetadata' in options) {
-                    console.warn('cachedGroupMetadata in sendMessage are deprecated, now cachedGroupMetadata is part of the socket config.');
-                }
-                await relayMessage(jid, fullMsg.message, { messageId: fullMsg.key.id, useCachedGroupMetadata: options.useCachedGroupMetadata, additionalAttributes, additionalNodes: isAiMsg ? additionalNodes : options.additionalNodes, statusJidList: options.statusJidList });
+                await relayMessage(jid, fullMsg.message, {
+                    messageId: fullMsg.key.id,
+                    useCachedGroupMetadata: options.useCachedGroupMetadata,
+                    additionalAttributes,
+                    statusJidList: options.statusJidList,
+                    additionalNodes,
+                    AI: options.ai || false
+                });
                 if (config.emitOwnEvents) {
-                    process.nextTick(() => {
-                        processingMutex.mutex(() => (upsertMessage(fullMsg, 'append')));
+                    process.nextTick(async () => {
+                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
                     });
                 }
                 return fullMsg;