@blckrose/baileys 1.1.1 → 1.1.5

package/lib/Defaults/index.js

@@ -89,7 +89,8 @@ export const MEDIA_PATH_MAP = {
     'product-catalog-image': '/product/image',
     'md-app-state': '',
     'md-msg-hist': '/mms/md-app-state',
-    'biz-cover-photo': '/pps/biz-cover-photo'
+    'biz-cover-photo': '/pps/biz-cover-photo',
+    'sticker-pack': '/mms/sticker'
 };
 export const MEDIA_HKDF_KEY_MAPPING = {
     audio: 'Audio',
@@ -110,7 +111,8 @@ export const MEDIA_HKDF_KEY_MAPPING = {
     'product-catalog-image': '',
     'payment-bg-image': 'Payment Background',
     ptv: 'Video',
-    'biz-cover-photo': 'Image'
+    'biz-cover-photo': 'Image',
+    'sticker-pack': 'Sticker Pack'
 };
 export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
 export const MIN_PREKEY_COUNT = 5;

package/lib/Signal/libsignal.js

@@ -3,14 +3,37 @@ import * as libsignal from 'libsignal';
 // @ts-ignore
 import { PreKeyWhisperMessage } from 'libsignal/src/protobufs.js';
 import { LRUCache } from 'lru-cache';
-// ── Suppress libsignal "Closing session: SessionEntry {...}" console spam ─────
-const _$origLog = console.log;
-console.log = (...args) => {
-    const first = typeof args[0] === 'string' ? args[0] : (args[0] instanceof Object ? args[0]?.constructor?.name : '');
-    if (first === 'Closing session:' || (typeof args[0] === 'object' && args[0]?.constructor?.name === 'SessionEntry')) return;
-    if (typeof args[0] === 'string' && (args[0].startsWith('Closing session') || args[0].includes('SessionEntry'))) return;
-    _$origLog.apply(console, args);
-};
+// ── Suppress libsignal "Closing session: SessionEntry {...}" noise ────────────
+// ES module imports di-hoist, jadi suppressor harus dipasang setelah semua import.
+// Cara paling efektif: patch console + process.stdout setelah module loaded.
+;(function _suppressSessionNoise() {
+    const _isNoise = (...args) => {
+        if (typeof args[0] === 'string') {
+            const s = args[0];
+            if (s.startsWith('Closing session') || s.includes('SessionEntry') ||
+                s.includes('pendingPreKey') || s.includes('currentRatchet') ||
+                s.includes('registrationId:') || s.includes('indexInfo:')) return true;
+        }
+        if (args[1] && typeof args[1] === 'object' &&
+            args[1]?.constructor?.name === 'SessionEntry') return true;
+        if (typeof args[0] === 'object' &&
+            args[0]?.constructor?.name === 'SessionEntry') return true;
+        return false;
+    };
+    const _wrapFn = (orig) => (...args) => { if (_isNoise(...args)) return; orig(...args); };
+    console.log  = _wrapFn(console.log.bind(console));
+    console.warn = _wrapFn(console.warn.bind(console));
+    console.info = _wrapFn(console.info.bind(console));
+    // Intercept process.stdout.write untuk kasus libsignal bypass console
+    const _origWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = function(chunk, ...rest) {
+        if (typeof chunk === 'string' && (
+            chunk.includes('Closing session') || chunk.includes('SessionEntry') ||
+            chunk.includes('pendingPreKey')   || chunk.includes('currentRatchet')
+        )) return true;
+        return _origWrite(chunk, ...rest);
+    };
+})();
 // ─────────────────────────────────────────────────────────────────────────────
 import { generateSignalPubKey } from '../Utils/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, transferDevice, WAJIDDomains } from '../WABinary/index.js';

package/lib/Socket/chats.js

@@ -8,7 +8,7 @@ import { chatModificationToAppPatch, decodePatches, decodeSyncdSnapshot, encodeS
 import { makeMutex } from '../Utils/make-mutex.js';
 import processMessage from '../Utils/process-message.js';
 import { buildTcTokenFromJid } from '../Utils/tc-token-utils.js';
-import { getBinaryNodeChild, getBinaryNodeChildren, jidDecode, jidNormalizedUser, reduceBinaryNodeToDictionary, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { getBinaryNodeChild, getBinaryNodeChildren, jidDecode, jidEncode, jidNormalizedUser, isLidUser, reduceBinaryNodeToDictionary, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeSocket } from './socket.js';
 const MAX_SYNC_ATTEMPTS = 2;
@@ -152,6 +152,23 @@ export const makeChatsSocket = (config) => {
         }
         return botList;
     };
+    const getLidUser = async (jid) => {
+        if (!jid) throw new Boom('Please input a jid user');
+        if (!jid.endsWith('@s.whatsapp.net') && !jid.endsWith('@lid')) {
+            throw new Boom('Invalid JID: Not a user JID!');
+        }
+        const targetJid = jid.includes('@') ? jid : `${jid}@s.whatsapp.net`;
+        const usyncQuery = new USyncQuery();
+        usyncQuery.protocols.push({
+            name: 'lid',
+            getQueryElement: () => ({ tag: 'lid', attrs: {}, content: undefined }),
+            getUserElement: () => null,
+            parser: (node) => node.attrs.val
+        });
+        usyncQuery.users.push({ id: targetJid });
+        const result = await sock.executeUSyncQuery(usyncQuery);
+        if (result) return result.list;
+    };
     const fetchStatus = async (...jids) => {
         const usyncQuery = new USyncQuery().withStatusProtocol();
         for (const jid of jids) {
@@ -258,6 +275,24 @@ export const makeChatsSocket = (config) => {
         return getBinaryNodeChildren(listNode, 'item').map(n => n.attrs.jid);
     };
     const updateBlockStatus = async (jid, action) => {
+        jid = jidNormalizedUser(jid);
+        // Jika input adalah LID, resolve ke PN dulu
+        if (jid.endsWith('@lid')) {
+            try {
+                const pn = await signalRepository?.lidMapping?.getPNForLID?.(jid).catch(() => null);
+                if (pn) jid = jidNormalizedUser(pn);
+            } catch {}
+        }
+        const dhash = String(Date.now());
+        const itemAttrs = {
+            dhash,
+            action,
+            jid, // selalu PN
+        };
+        // Block: tambah pn_jid juga
+        if (action === 'block') {
+            itemAttrs.pn_jid = jid;
+        }
         await query({
             tag: 'iq',
             attrs: {
@@ -268,10 +303,7 @@ export const makeChatsSocket = (config) => {
             content: [
                 {
                     tag: 'item',
-                    attrs: {
-                        action,
-                        jid
-                    }
+                    attrs: itemAttrs
                 }
             ]
         });
@@ -803,6 +835,60 @@ export const makeChatsSocket = (config) => {
         await Promise.all([fetchProps(), fetchBlocklist(), fetchPrivacySettings()]);
     };
     const upsertMessage = ev.createBufferedFunction(async (msg, type) => {
+        // ── Auto-inject isAdmin, isBotAdmin, metadata ─────────────────────────
+        try {
+            const remoteJid = msg.key?.remoteJid || '';
+            const isGroup = remoteJid.endsWith('@g.us');
+            if (isGroup) {
+                const _normalizeJid = (jid) => {
+                    if (!jid) return null;
+                    try { return jidNormalizedUser(jid).split('@')[0]; }
+                    catch { return String(jid).split('@')[0]; }
+                };
+                // Fetch metadata (pakai cache jika tersedia)
+                let meta = null;
+                try { meta = await sock.groupMetadata(remoteJid); } catch {}
+                if (meta && Array.isArray(meta.participants)) {
+                    msg.metadata = meta;
+                    const botJid = authState.creds?.me?.id;
+                    const senderJid = msg.key.fromMe
+                        ? authState.creds?.me?.id
+                        : (msg.key.participant || remoteJid);
+                    const senderNorm = _normalizeJid(senderJid);
+                    const botNorm = _normalizeJid(botJid);
+                    // isAdmin
+                    msg.isAdmin = meta.participants.some(p => {
+                        const pid = _normalizeJid(p.jid || p.id || p.lid);
+                        return pid === senderNorm && (p.admin === 'admin' || p.admin === 'superadmin');
+                    });
+                    // isBotAdmin: via m.isBotAdmin jika sudah di-set
+                    let isBotAdmin = typeof msg.isBotAdmin === 'boolean' ? msg.isBotAdmin : false;
+                    // fallback via owner
+                    if (!isBotAdmin) {
+                        const owners = [meta.owner, meta.subjectOwner, meta.ownerPn]
+                            .filter(Boolean).map(_normalizeJid);
+                        if (owners.includes(botNorm)) isBotAdmin = true;
+                    }
+                    // fallback via participants
+                    if (!isBotAdmin) {
+                        isBotAdmin = meta.participants.some(p => {
+                            const pid = _normalizeJid(p.jid || p.id || p.lid);
+                            return pid === botNorm && (p.admin === 'admin' || p.admin === 'superadmin');
+                        });
+                    }
+                    msg.isBotAdmin = isBotAdmin;
+                } else {
+                    msg.metadata = {};
+                    msg.isAdmin = false;
+                    msg.isBotAdmin = false;
+                }
+            } else {
+                msg.metadata = {};
+                msg.isAdmin = false;
+                msg.isBotAdmin = false;
+            }
+        } catch {}
+        // ─────────────────────────────────────────────────────────────────────
         ev.emit('messages.upsert', { messages: [msg], type });
         if (!!msg.pushName) {
             let jid = msg.key.fromMe ? authState.creds.me.id : msg.key.participant || msg.key.remoteJid;
@@ -1031,7 +1117,17 @@ export const makeChatsSocket = (config) => {
         removeMessageLabel,
         star,
         addOrEditQuickReply,
-        removeQuickReply
+        removeQuickReply,
+        clearMessage: (jid, key, timeStamp) => {
+            return chatModify({
+                delete: true,
+                lastMessages: [{
+                    key: key,
+                    messageTimestamp: timeStamp
+                }]
+            }, jid);
+        },
+        getLidUser
     };
 };
 //# sourceMappingURL=chats.js.map

package/lib/Socket/groups.js

@@ -40,28 +40,49 @@ export const makeGroupsSocket = (config) => {
         }
     });
     // Update cache saat participant berubah
+    // Debounce map to prevent duplicate refresh calls for same group
+    const _refreshDebounce = new Map();
+    const _refreshGroupMetadata = async (jid) => {
+        // Debounce: skip jika refresh sudah dijadwalkan dalam 2 detik terakhir
+        if (_refreshDebounce.has(jid)) return;
+        _refreshDebounce.set(jid, true);
+        setTimeout(() => _refreshDebounce.delete(jid), 2000);
+        try {
+            const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
+            const meta = extractGroupMetadata(result);
+            setCachedGroupMetadata(jid, meta);
+            // Emit groups.update agar subscriber luar (makeInMemoryStore dll) ikut terupdate
+            ev.emit('groups.update', [meta]);
+        } catch (e) {
+            // Ignore jika gagal (bot mungkin sudah keluar dari grup)
+        }
+    };
     ev.on('group-participants.update', ({ id, participants, action }) => {
         const entry = groupMetadataCache.get(id);
-        if (!entry) return;
-        const meta = { ...entry.data };
-        if (!Array.isArray(meta.participants)) return;
-        if (action === 'add') {
-            const existing = new Set(meta.participants.map(p => p.id));
-            for (const jid of participants) {
-                if (!existing.has(jid)) meta.participants.push({ id: jid, admin: null });
+        if (entry && Array.isArray(entry.data?.participants)) {
+            // Fast-path: update cache lokal secara optimistis tanpa tunggu network
+            const meta = { ...entry.data, participants: [...entry.data.participants] };
+            if (action === 'add') {
+                const existing = new Set(meta.participants.map(p => p.id));
+                for (const jid of participants) {
+                    if (!existing.has(jid)) meta.participants.push({ id: jid, admin: null });
+                }
+            } else if (action === 'remove') {
+                meta.participants = meta.participants.filter(p => !participants.includes(p.id));
+            } else if (action === 'promote') {
+                meta.participants = meta.participants.map(p =>
+                    participants.includes(p.id) ? { ...p, admin: 'admin' } : p
+                );
+            } else if (action === 'demote') {
+                meta.participants = meta.participants.map(p =>
+                    participants.includes(p.id) ? { ...p, admin: null } : p
+                );
             }
-        } else if (action === 'remove') {
-            meta.participants = meta.participants.filter(p => !participants.includes(p.id));
-        } else if (action === 'promote') {
-            meta.participants = meta.participants.map(p =>
-                participants.includes(p.id) ? { ...p, admin: 'admin' } : p
-            );
-        } else if (action === 'demote') {
-            meta.participants = meta.participants.map(p =>
-                participants.includes(p.id) ? { ...p, admin: null } : p
-            );
+            groupMetadataCache.set(id, { data: meta, ts: entry.ts });
         }
-        groupMetadataCache.set(id, { data: meta, ts: entry.ts });
+        // Auto-refresh dari network untuk semua aksi participant
+        // Ini memastikan data selalu akurat dari server WA
+        _refreshGroupMetadata(id);
     });
     // ── End group metadata cache ───────────────────────────────────────────────
     const groupQuery = async (jid, type, content) => query({
@@ -330,7 +351,47 @@ export const makeGroupsSocket = (config) => {
                 { tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state: mode } }] }
             ]);
         },
-        groupFetchAllParticipating
+        groupFetchAllParticipating,
+        /**
+         * Auto detect isAdmin & isBotAdmin dari groupMetadata
+         * @param {string} groupJid - JID grup
+         * @param {string} senderJid - JID pengirim pesan
+         * @returns {Promise<{isAdmin: boolean, isBotAdmin: boolean}>}
+         */
+        getAdminStatus: async (groupJid, senderJid) => {
+            const normalizeJid = (jid) => {
+                if (!jid) return null;
+                try {
+                    return jidNormalizedUser(jid).split('@')[0];
+                } catch {
+                    return String(jid).split('@')[0];
+                }
+            };
+            const botJid = sock.authState?.creds?.me?.id;
+            const meta = await sock.groupMetadata(groupJid).catch(() => null);
+            if (!meta || !Array.isArray(meta.participants)) {
+                return { isAdmin: false, isBotAdmin: false };
+            }
+            const senderNorm = normalizeJid(senderJid);
+            const botNorm = normalizeJid(botJid);
+            const isAdmin = meta.participants.some(p => {
+                const pid = normalizeJid(p.jid || p.id || p.lid);
+                return pid === senderNorm && (p.admin === 'admin' || p.admin === 'superadmin');
+            });
+            // Cek isBotAdmin: via participants
+            let isBotAdmin = meta.participants.some(p => {
+                const pid = normalizeJid(p.jid || p.id || p.lid);
+                return pid === botNorm && (p.admin === 'admin' || p.admin === 'superadmin');
+            });
+            // Fallback: cek via owner/subjectOwner
+            if (!isBotAdmin) {
+                const owners = [meta.owner, meta.subjectOwner, meta.ownerPn]
+                    .filter(Boolean)
+                    .map(normalizeJid);
+                if (owners.includes(botNorm)) isBotAdmin = true;
+            }
+            return { isAdmin, isBotAdmin };
+        }
     };
 };
 export const extractGroupMetadata = (result) => {

package/lib/Socket/messages-recv.js

@@ -993,7 +993,47 @@ export const makeMessagesRecvSocket = (config) => {
             }
             return null;
         };
+        // Resolve semua contextInfo termasuk yang ada di dalam quotedMessage
+        const getAllContextInfos = (content, results = []) => {
+            if (!content || typeof content !== 'object') return results;
+            if (content.contextInfo) {
+                results.push(content.contextInfo);
+                // Juga cari di dalam quotedMessage secara rekursif
+                if (content.contextInfo.quotedMessage) {
+                    getAllContextInfos(content.contextInfo.quotedMessage, results);
+                }
+            }
+            for (const val of Object.values(content)) {
+                if (val && typeof val === 'object' && !results.includes(val)) {
+                    getAllContextInfos(val, results);
+                }
+            }
+            return results;
+        };
         const contextInfo = getContextInfo(msgContent);
+        // Resolve participant LID di semua contextInfo (termasuk quotedMessage)
+        const allContextInfos = getAllContextInfos(msgContent);
+        for (const ctx of allContextInfos) {
+            if (ctx?.participant?.endsWith('@lid')) {
+                try {
+                    const pn = await lidMapping.getPNForLID(ctx.participant);
+                    if (pn) {
+                        logger.debug({ lid: ctx.participant, pn }, 'resolved nested contextInfo.participant LID → PN');
+                        ctx.participant = pn;
+                    }
+                } catch { }
+            }
+            // Resolve mentionedJid di quotedMessage contextInfo juga
+            if (ctx !== contextInfo && ctx?.mentionedJid?.length) {
+                const lids = ctx.mentionedJid.filter(j => j?.endsWith('@lid'));
+                for (const lid of lids) {
+                    try {
+                        const pn = await lidMapping.getPNForLID(lid);
+                        if (pn) ctx.mentionedJid = ctx.mentionedJid.map(j => j === lid ? pn : j);
+                    } catch { }
+                }
+            }
+        }
         // resolve contextInfo.participant (sender of quoted message) jika masih LID
         if (contextInfo?.participant?.endsWith('@lid')) {
             try {
@@ -1007,6 +1047,33 @@ export const makeMessagesRecvSocket = (config) => {
         }
         if (!contextInfo?.mentionedJid?.length)
             return;
+        // Fix text yang masih mengandung LID number meskipun mentionedJid sudah resolved ke PN
+        // Kasus: mentionedJid sudah jadi @s.whatsapp.net tapi text masih "@165159209271535" (LID num)
+        const textFieldEarly = getTextField(msgContent);
+        if (textFieldEarly) {
+            let earlyText = textFieldEarly.obj[textFieldEarly.key] || '';
+            // Cek apakah text mengandung @angka panjang (>12 digit = kemungkinan LID number bukan nomor HP)
+            const lidNumPattern = /@(\d{13,20})/g;
+            const lidNumMatches = [...earlyText.matchAll(lidNumPattern)];
+            if (lidNumMatches.length > 0) {
+                // Untuk setiap mentionedJid yang sudah resolved, cek apakah ada LID number di text
+                for (const resolvedJid of contextInfo.mentionedJid) {
+                    if (resolvedJid?.endsWith('@lid')) continue; // belum resolved, skip dulu
+                    const pnNum = resolvedJid.split('@')[0].split(':')[0];
+                    if (!pnNum) continue;
+                    // Cari LID number di text yang paling mungkin match (berdasarkan urutan)
+                    for (const match of lidNumMatches) {
+                        const lidNum = match[1];
+                        if (earlyText.includes(`@${lidNum}`)) {
+                            earlyText = earlyText.split(`@${lidNum}`).join(`@${pnNum}`);
+                            logger.debug({ lidNum, pnNum }, 'replaced LID number in text with PN number');
+                            break;
+                        }
+                    }
+                }
+                textFieldEarly.obj[textFieldEarly.key] = earlyText;
+            }
+        }
         const hasLid = contextInfo.mentionedJid.some((j) => j?.endsWith('@lid'));
         if (!hasLid)
             return;
@@ -1039,7 +1106,14 @@ export const makeMessagesRecvSocket = (config) => {
                 if (result?.list) {
                     const mappings = [];
                     for (const item of result.list) {
-                        const lidJid = stillUnresolved.find(l => l === item.id || l.startsWith((item.id.split('@')[0] ?? '')));
+                        // item.id bisa berupa PN (@s.whatsapp.net) atau LID (@lid)
+                        // stillUnresolved berisi LID. Match berdasarkan numeric prefix
+                        const itemNum = (item.id ?? '').split('@')[0].split(':')[0];
+                        const lidJid = stillUnresolved.find(l => {
+                            if (l === item.id) return true;
+                            const lNum = l.split('@')[0].split(':')[0];
+                            return itemNum && lNum && itemNum === lNum;
+                        });
                         if (lidJid && item.id && !item.id.endsWith('@lid')) {
                             resolveMap.set(lidJid, item.id);
                             mappings.push({ lid: lidJid, pn: item.id });
@@ -1055,6 +1129,34 @@ export const makeMessagesRecvSocket = (config) => {
                 logger.debug({ err: e }, 'USync LID resolve failed, using cache only');
             }
         }
+        // ── Text-based PN extraction ─────────────────────────────────────────────
+        // WA kadang sudah resolve nomor HP di text (@6285133801810) tapi mentionedJid
+        // masih berisi LID. Kita ekstrak semua @nomor dari text lalu matching ke LID
+        // yang masih unresolved berdasarkan urutan kemunculan di mentionedJid.
+        const textField = getTextField(msgContent);
+        const stillUnresolvedAfterUSync = lidJids.filter(l => !resolveMap.has(l));
+        if (stillUnresolvedAfterUSync.length > 0 && textField) {
+            const rawText = textField.obj[textField.key] || '';
+            // Ekstrak semua mention @nomor dari text (hanya angka, min 7 digit)
+            const mentionMatches = [...rawText.matchAll(/@(\d{7,15})/g)].map(m => m[1]);
+            if (mentionMatches.length > 0) {
+                // Match LID ke nomor berdasarkan urutan index di mentionedJid
+                const lidOrder = contextInfo.mentionedJid
+                    .map((jid, idx) => ({ jid, idx }))
+                    .filter(({ jid }) => stillUnresolvedAfterUSync.includes(jid));
+                for (let i = 0; i < lidOrder.length && i < mentionMatches.length; i++) {
+                    const lidJid = lidOrder[i].jid;
+                    const phoneNum = mentionMatches[i];
+                    const pnJid = `${phoneNum}@s.whatsapp.net`;
+                    resolveMap.set(lidJid, pnJid);
+                    // Simpan mapping baru ini ke store untuk request berikutnya
+                    lidMapping.storeLIDPNMappings([{ lid: lidJid, pn: pnJid }]).catch(() => {});
+                    logger.debug({ lid: lidJid, pn: pnJid }, 'text-extracted PN for LID → PN');
+                }
+            }
+        }
+        // ── End text-based PN extraction ─────────────────────────────────────────
+
         contextInfo.mentionedJid = contextInfo.mentionedJid.map((jid) => {
             if (!jid?.endsWith('@lid'))
                 return jid;
@@ -1063,13 +1165,14 @@ export const makeMessagesRecvSocket = (config) => {
                 logger.debug({ lid: jid, pn: resolved }, 'resolved mentionedJid LID → PN');
                 return resolved;
             }
+            // Tetap kembalikan LID jika benar-benar tidak bisa di-resolve
             return jid;
         });
-        const textField = getTextField(msgContent);
         if (textField) {
             let text = textField.obj[textField.key];
+            // Replace LID number di text dengan PN number yang sudah di-resolve
             for (const [lidJid, pnJid] of resolveMap) {
-                const lidNum = lidJid.replace('@lid', '').split(':')[0] ?? '';
+                const lidNum = lidJid.split('@')[0].split(':')[0] ?? '';
                 const pnNum = pnJid.replace('@s.whatsapp.net', '').split(':')[0] ?? '';
                 if (lidNum && pnNum && text.includes(lidNum)) {
                     text = text.split(lidNum).join(pnNum);
@@ -1268,6 +1371,97 @@ export const makeMessagesRecvSocket = (config) => {
                 }
                 cleanMessage(msg, authState.creds.me.id, authState.creds.me.lid);
                 await resolveMentionedLIDs(msg, signalRepository.lidMapping);
+                // ── Post-resolve: fix semua LID yang tersisa di message object ────────
+                // Setelah resolveMentionedLIDs:
+                //   1. Fix text yang masih "@LIDnum" → "@PNnum"
+                //   2. Fix contextInfo.participant yang masih @lid (sender quoted)
+                //   3. Fix mentionedJid & text di dalam quotedMessage
+                try {
+                    const _safeSet = (obj, key, val) => {
+                        try { obj[key] = val; } catch (_) {
+                            // proto readonly fallback
+                            const proto = Object.getPrototypeOf(obj);
+                            const fresh = Object.assign(Object.create(proto), obj, { [key]: val });
+                            // replace reference di parent jika bisa — caller handles
+                            return fresh;
+                        }
+                        return obj;
+                    };
+                    const _fixTextLid = (innerMsg, mentionedJids, msgTypeLabel) => {
+                        const pnNumbers = (mentionedJids || [])
+                            .filter(j => j && !j.endsWith('@lid'))
+                            .map(j => j.split('@')[0].split(':')[0])
+                            .filter(Boolean);
+                        if (!pnNumbers.length) return;
+                        for (const textKey of ['text', 'caption', 'conversation']) {
+                            const originalText = innerMsg[textKey];
+                            if (typeof originalText !== 'string') continue;
+                            const lidPattern = /@(\d{13,20})/g;
+                            let newText = originalText;
+                            let match;
+                            let pnIdx = 0;
+                            while ((match = lidPattern.exec(originalText)) !== null) {
+                                if (pnIdx >= pnNumbers.length) break;
+                                const lidNum = match[1];
+                                const pnNum = pnNumbers[pnIdx++];
+                                newText = newText.split(`@${lidNum}`).join(`@${pnNum}`);
+                                logger.debug({ lidNum, pnNum, type: msgTypeLabel, textKey }, 'post-resolve: replaced LID num in text');
+                            }
+                            if (newText !== originalText) _safeSet(innerMsg, textKey, newText);
+                        }
+                    };
+                    const msgObj = msg.message;
+                    if (msgObj) {
+                        for (const msgType of Object.keys(msgObj)) {
+                            const innerMsg = msgObj[msgType];
+                            if (!innerMsg || typeof innerMsg !== 'object') continue;
+                            const ctxInfo = innerMsg.contextInfo;
+                            if (!ctxInfo) continue;
+                            // 1. Fix text LID → PN (pesan utama)
+                            if (ctxInfo.mentionedJid?.length) {
+                                _fixTextLid(innerMsg, ctxInfo.mentionedJid, msgType);
+                            }
+                            // 2. Fix contextInfo.participant (sender quoted) jika masih LID
+                            if (ctxInfo.participant?.endsWith('@lid')) {
+                                try {
+                                    const pn = await signalRepository.lidMapping.getPNForLID(ctxInfo.participant);
+                                    if (pn) {
+                                        _safeSet(ctxInfo, 'participant', pn);
+                                        logger.debug({ lid: ctxInfo.participant, pn }, 'post-resolve: fixed contextInfo.participant LID');
+                                    }
+                                } catch (_) {}
+                            }
+                            // 3. Fix mentionedJid & text di dalam quotedMessage
+                            if (ctxInfo.quotedMessage) {
+                                for (const qType of Object.keys(ctxInfo.quotedMessage)) {
+                                    const qInner = ctxInfo.quotedMessage[qType];
+                                    if (!qInner || typeof qInner !== 'object') continue;
+                                    const qCtx = qInner.contextInfo;
+                                    if (!qCtx?.mentionedJid?.length) continue;
+                                    // Resolve LID di mentionedJid quoted
+                                    const resolvedQ = await Promise.all(
+                                        qCtx.mentionedJid.map(async (jid) => {
+                                            if (!jid?.endsWith('@lid')) return jid;
+                                            try {
+                                                const pn = await signalRepository.lidMapping.getPNForLID(jid);
+                                                return pn || jid;
+                                            } catch (_) { return jid; }
+                                        })
+                                    );
+                                    if (resolvedQ.some((j, i) => j !== qCtx.mentionedJid[i])) {
+                                        _safeSet(qCtx, 'mentionedJid', resolvedQ);
+                                        logger.debug({ resolvedQ }, 'post-resolve: fixed quotedMessage mentionedJid');
+                                    }
+                                    // Fix text LID → PN di quoted
+                                    _fixTextLid(qInner, resolvedQ, `quoted.${qType}`);
+                                }
+                            }
+                        }
+                    }
+                } catch (lidFixErr) {
+                    logger.debug({ err: lidFixErr }, 'post-resolve LID fix failed (non-critical)');
+                }
+                // ── End post-resolve fix ──────────────────────────────────────────────
                 await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
             });
         }