@blckrose/baileys 2.0.4 → 2.0.5

package/lib/Defaults/index.js

@@ -90,7 +90,8 @@ export const MEDIA_PATH_MAP = {
     'md-app-state': '',
     'md-msg-hist': '/mms/md-app-state',
     'biz-cover-photo': '/pps/biz-cover-photo',
-    'sticker-pack': '/mms/sticker'
+    'sticker-pack': '/mms/sticker',
+    'thumbnail-sticker-pack': '/mms/sticker'
 };
 export const MEDIA_HKDF_KEY_MAPPING = {
     audio: 'Audio',
@@ -112,7 +113,8 @@ export const MEDIA_HKDF_KEY_MAPPING = {
     'payment-bg-image': 'Payment Background',
     ptv: 'Video',
     'biz-cover-photo': 'Image',
-    'sticker-pack': 'Sticker Pack'
+    'sticker-pack': 'Sticker Pack',
+    'thumbnail-sticker-pack': 'Sticker Pack'
 };
 export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP);
 export const MIN_PREKEY_COUNT = 5;
@@ -132,4 +134,12 @@ export const TimeMs = {
     Week: 7 * 24 * 60 * 60 * 1000
 };
 export const PHONENUMBER_MCC = phoneNumberMcc;
+
+export const DONATE_URL = 'https://saweria.co/itsliaaa';
+export const LEXER_REGEX = /(\/\/.*|\/\*[\s\S]*?\*\/|#.*)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`[\s\S]*?`)|(\b[a-zA-Z_]\w*\b)(?=\s*\()|(\b[a-zA-Z_]\w*\b)|(\b\d+(?:\.\d+)?\b)|(\s+|[^\w\s]+)/g;
+export const BOT_RENDERING_CONFIG_METADATA = {
+    bloksVersioningId: '0903aa5f7f47de66789d5f4c86d3bd6e05e4bc3ff85e454a9f907d5ed7fef97c',
+    pixelDensity: 2.75
+};
+
 //# sourceMappingURL=index.js.map

package/lib/Socket/messages-send.js

@@ -1501,7 +1501,7 @@ export const makeMessagesSocket = (config) => {
                     messageContent.contextInfo = { mentionedJid: options.mentionedJid };
                 }
                 const payload = proto.Message.InteractiveMessage.create(messageContent);
-                const msg = generateWAMessageFromContent(jid, { viewOnceMessage: { message: { interactiveMessage: payload } } }, { userJid, quoted: options?.quoted || null });
+                const msg = generateWAMessageFromContent(jid, { 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;

package/lib/Types/RichType.js

@@ -0,0 +1,22 @@
+export var CodeHighlightType;
+(function (CodeHighlightType) {
+    CodeHighlightType[CodeHighlightType["DEFAULT"] = 0] = "DEFAULT";
+    CodeHighlightType[CodeHighlightType["KEYWORD"] = 1] = "KEYWORD";
+    CodeHighlightType[CodeHighlightType["METHOD"] = 2] = "METHOD";
+    CodeHighlightType[CodeHighlightType["STRING"] = 3] = "STRING";
+    CodeHighlightType[CodeHighlightType["NUMBER"] = 4] = "NUMBER";
+    CodeHighlightType[CodeHighlightType["COMMENT"] = 5] = "COMMENT";
+})(CodeHighlightType || (CodeHighlightType = {}));
+export var RichSubMessageType;
+(function (RichSubMessageType) {
+    RichSubMessageType[RichSubMessageType["UNKNOWN"] = 0] = "UNKNOWN";
+    RichSubMessageType[RichSubMessageType["GRID_IMAGE"] = 1] = "GRID_IMAGE";
+    RichSubMessageType[RichSubMessageType["TEXT"] = 2] = "TEXT";
+    RichSubMessageType[RichSubMessageType["INLINE_IMAGE"] = 3] = "INLINE_IMAGE";
+    RichSubMessageType[RichSubMessageType["TABLE"] = 4] = "TABLE";
+    RichSubMessageType[RichSubMessageType["CODE"] = 5] = "CODE";
+    RichSubMessageType[RichSubMessageType["DYNAMIC"] = 6] = "DYNAMIC";
+    RichSubMessageType[RichSubMessageType["MAP"] = 7] = "MAP";
+    RichSubMessageType[RichSubMessageType["LATEX"] = 8] = "LATEX";
+    RichSubMessageType[RichSubMessageType["CONTENT_ITEMS"] = 9] = "CONTENT_ITEMS";
+})(RichSubMessageType || (RichSubMessageType = {}));

package/lib/Types/index.js

@@ -1,4 +1,5 @@
 export * from './Auth.js';
+export * from './RichType.js';
 export * from './MexUpdates.js';
 export * from './GroupMetadata.js';
 export * from './Chat.js';

package/lib/Utils/companion-reg-client-utils.js

@@ -0,0 +1,32 @@
+export const CompanionWebClientType = {
+    UNKNOWN: 0,
+    CHROME: 1,
+    EDGE: 2,
+    FIREFOX: 3,
+    IE: 4,
+    OPERA: 5,
+    SAFARI: 6,
+    ELECTRON: 7,
+    UWP: 8,
+    OTHER_WEB_CLIENT: 9
+};
+const BROWSER_TO_COMPANION_WEB_CLIENT = {
+    Chrome: CompanionWebClientType.CHROME,
+    Edge: CompanionWebClientType.EDGE,
+    Firefox: CompanionWebClientType.FIREFOX,
+    IE: CompanionWebClientType.IE,
+    Opera: CompanionWebClientType.OPERA,
+    Safari: CompanionWebClientType.SAFARI
+};
+export const getCompanionWebClientType = ([os, browserName]) => {
+    if (browserName === 'Desktop') {
+        return os === 'Windows' ? CompanionWebClientType.UWP : CompanionWebClientType.ELECTRON;
+    }
+    return BROWSER_TO_COMPANION_WEB_CLIENT[browserName] || CompanionWebClientType.OTHER_WEB_CLIENT;
+};
+export const getCompanionPlatformId = (browser) => {
+    return getCompanionWebClientType(browser).toString();
+};
+export const buildPairingQRData = (ref, noiseKeyB64, identityKeyB64, advB64, browser) => {
+    return [ref, noiseKeyB64, identityKeyB64, advB64, getCompanionPlatformId(browser)].join(',');
+};

package/lib/Utils/index.js

@@ -24,4 +24,8 @@ export * from './browser-utils.js';
 export * from './identity-change-handler.js';
 export * from './messages-newsletter.js';
 export * from './resolve-jid.js';
+export * from './rich-message-utils.js';
+export * from './companion-reg-client-utils.js';
+export * from './offline-node-processor.js';
+export * from './stanza-ack.js';
 //# sourceMappingURL=index.js.map

package/lib/Utils/messages-media.js

@@ -635,7 +635,8 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
         const headers = {
             ...customHeaders,
             'Content-Type': 'application/octet-stream',
-            Origin: DEFAULT_ORIGIN
+            'Origin': DEFAULT_ORIGIN,
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
         };
         // Collect buffer from Readable stream or read from file path
         let reqBuffer;
@@ -654,50 +655,64 @@ export const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, opt
         if (newsletter) {
             mediaPath = mediaPath?.replace('/mms/', '/newsletter/newsletter-');
         }
-        for (const { hostname, maxContentLengthBytes } of hosts) {
-            const auth = encodeURIComponent(uploadInfo.auth);
-            const url = `https://${hostname}${mediaPath}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
+        
+        // Retry logic: try all hosts, then refresh connection and retry
+        const maxRetries = 2;
+        for (let attempt = 0; attempt < maxRetries && !urls; attempt++) {
+            if (attempt > 0) {
+                logger?.info?.(`Retrying upload (attempt ${attempt + 1}/${maxRetries})...`);
+                uploadInfo = await refreshMediaConn(true);
+            }
 
-            let result;
-            try {
-                // Upload buffer directly like wiley (avoids file I/O issues)
-                const axios = (await import('axios')).default;
-                const body = await axios.post(url, reqBuffer, {
-                    ...options,
-                    headers: {
-                        ...headers,
-                    },
-                    httpsAgent: fetchAgent,
-                    timeout: timeoutMs,
-                    responseType: 'json',
-                    maxBodyLength: Infinity,
-                    maxContentLength: Infinity,
-                });
-                result = body.data;
+            for (const { hostname, maxContentLengthBytes } of hosts) {
+                const auth = encodeURIComponent(uploadInfo.auth);
+                const url = `https://${hostname}${mediaPath}/${fileEncSha256B64}?auth=${auth}&token=${fileEncSha256B64}`;
+
+                let result;
+                try {
+                    // Upload buffer directly like wiley (avoids file I/O issues)
+                    const axios = (await import('axios')).default;
+                    const body = await axios.post(url, reqBuffer, {
+                        ...options,
+                        headers: {
+                            ...headers,
+                            'Accept': '*/*',
+                        },
+                        httpsAgent: fetchAgent,
+                        timeout: timeoutMs || 60000, // Default 60s timeout
+                        responseType: 'json',
+                        maxBodyLength: Infinity,
+                        maxContentLength: Infinity,
+                        validateStatus: () => true, // Don't throw on any status code
+                    });
+                    result = body.data;
 
-                if (result?.url || result?.direct_path) {
-                    urls = {
-                        mediaUrl: result.url,
-                        directPath: result.direct_path,
-                        handle: result.handle,
-                        meta_hmac: result.meta_hmac,
-                        fbid: result.fbid,
-                        ts: result.ts
-                    };
-                    break;
+                    if (result?.url || result?.direct_path) {
+                        urls = {
+                            mediaUrl: result.url,
+                            directPath: result.direct_path,
+                            handle: result.handle,
+                            meta_hmac: result.meta_hmac,
+                            fbid: result.fbid,
+                            ts: result.ts
+                        };
+                        logger?.info?.(`Upload successful to host: ${hostname}`);
+                        break;
+                    }
+                    else {
+                        logger?.warn?.(`Upload to ${hostname} failed, reason: ${JSON.stringify(result)}`);
+                        // Refresh media conn on failure
+                        uploadInfo = await refreshMediaConn(true);
+                    }
                 }
-                else {
-                    uploadInfo = await refreshMediaConn(true);
-                    throw new Error(`upload failed, reason: ${JSON.stringify(result)}`);
+                catch (error) {
+                    const isLast = hostname === hosts[hosts.length - 1]?.hostname;
+                    logger?.warn?.(`Error uploading to ${hostname} ${isLast ? '' : ', retrying...'}: ${error?.message}`);
                 }
             }
-            catch (error) {
-                const isLast = hostname === hosts[uploadInfo.hosts.length - 1]?.hostname;
-
-                logger.warn({ trace: error?.stack, uploadResult: result }, `Error in uploading to ${hostname} ${isLast ? '' : ', retrying...'}`);
-            }
         }
         if (!urls) {
+            logger?.error?.('Media upload failed on all hosts after all retries');
             throw new Boom('Media upload failed on all hosts', { statusCode: 500 });
         }
         return urls;

package/lib/Utils/messages.js

@@ -20,104 +20,6 @@ const MIMETYPE_MAP = {
     sticker: 'image/webp',
     'product-catalog-image': 'image/jpeg'
 };
-/** Map ekstensi audio ke mimetype */
-const AUDIO_MIMETYPE_MAP = {
-    ogg: 'audio/ogg; codecs=opus',
-    oga: 'audio/ogg; codecs=opus',
-    opus: 'audio/ogg; codecs=opus',
-    mp3: 'audio/mpeg',
-    mpeg: 'audio/mpeg',
-    mp4: 'audio/mp4',
-    m4a: 'audio/mp4',
-    aac: 'audio/aac',
-    wav: 'audio/wav',
-    wave: 'audio/wav',
-    flac: 'audio/flac',
-    webm: 'audio/webm',
-    amr: 'audio/amr',
-    '3gp': 'audio/3gpp',
-    '3gpp': 'audio/3gpp',
-    wma: 'audio/x-ms-wma',
-    caf: 'audio/x-caf',
-    aiff: 'audio/aiff',
-    aif: 'audio/aiff',
-};
-/**
- * Deteksi mimetype audio dari magic bytes buffer.
- * Return null jika tidak dikenali.
- */
-const detectAudioMimetypeFromBuffer = (buf) => {
-    if (!buf || buf.length < 12) return null;
-    // OGG
-    if (buf[0] === 0x4F && buf[1] === 0x67 && buf[2] === 0x67 && buf[3] === 0x53)
-        return 'audio/ogg; codecs=opus';
-    // MP3 (ID3 tag atau sync bits)
-    if ((buf[0] === 0x49 && buf[1] === 0x44 && buf[2] === 0x33) ||
-        (buf[0] === 0xFF && (buf[1] & 0xE0) === 0xE0))
-        return 'audio/mpeg';
-    // MP4/M4A (ftyp box)
-    if (buf[4] === 0x66 && buf[5] === 0x74 && buf[6] === 0x79 && buf[7] === 0x70)
-        return 'audio/mp4';
-    // RIFF/WAV
-    if (buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46 &&
-        buf[8] === 0x57 && buf[9] === 0x41 && buf[10] === 0x56 && buf[11] === 0x45)
-        return 'audio/wav';
-    // FLAC
-    if (buf[0] === 0x66 && buf[1] === 0x4C && buf[2] === 0x61 && buf[3] === 0x43)
-        return 'audio/flac';
-    // WEBM/MKV
-    if (buf[0] === 0x1A && buf[1] === 0x45 && buf[2] === 0xDF && buf[3] === 0xA3)
-        return 'audio/webm';
-    // AMR
-    if (buf[0] === 0x23 && buf[1] === 0x21 && buf[2] === 0x41 && buf[3] === 0x4D &&
-        buf[4] === 0x52)
-        return 'audio/amr';
-    return null;
-};
-/**
- * Deteksi mimetype audio secara otomatis dari media input.
- * Cek: 1) ekstensi URL/path, 2) magic bytes buffer, 3) fallback ke ogg/opus.
- */
-const detectAudioMimetype = async (media) => {
-    // Cek ekstensi dari URL atau path string
-    if (typeof media === 'string' || (media && typeof media === 'object' && 'url' in media)) {
-        const urlStr = typeof media === 'string' ? media : media.url?.toString?.() ?? '';
-        // Ambil path tanpa query string, lalu cari semua ekstensi
-        const pathOnly = urlStr.split('?')[0];
-        // Cek ekstensi terakhir (.m4a, .mp3, dst)
-        const extMatch = pathOnly.match(/\.([a-zA-Z0-9]{2,5})(?:[^/]*)?$/);
-        if (extMatch) {
-            const ext = extMatch[1].toLowerCase();
-            if (AUDIO_MIMETYPE_MAP[ext]) return AUDIO_MIMETYPE_MAP[ext];
-        }
-        // Fallback: scan semua segmen path untuk ekstensi audio yang dikenal
-        // Contoh: ".plus.aac.ep.m4a" → cek tiap segment dari belakang
-        const segments = pathOnly.split('.');
-        for (let i = segments.length - 1; i >= 0; i--) {
-            const seg = segments[i].toLowerCase().split('/')[0].split('?')[0];
-            if (AUDIO_MIMETYPE_MAP[seg]) return AUDIO_MIMETYPE_MAP[seg];
-        }
-    }
-    // Cek magic bytes jika Buffer
-    if (Buffer.isBuffer(media)) {
-        const detected = detectAudioMimetypeFromBuffer(media);
-        if (detected) return detected;
-    }
-    // Fallback: default ogg/opus
-    return MIMETYPE_MAP.audio;
-};
-const MessageTypeProto = {
-    image: WAProto.Message.ImageMessage,
-    video: WAProto.Message.VideoMessage,
-    audio: WAProto.Message.AudioMessage,
-    sticker: WAProto.Message.StickerMessage,
-    document: WAProto.Message.DocumentMessage
-};
-/**
- * Uses a regex to test whether the string contains a URL, and returns the URL if it does.
- * @param text eg. hello https://google.com
- * @returns the URL, eg. https://google.com
- */
 export const extractUrlFromText = (text) => text.match(URL_REGEX)?.[0];
 export const generateLinkPreviewIfRequired = async (text, getUrlInfo, logger) => {
     const url = extractUrlFromText(text);
@@ -127,7 +29,6 @@ export const generateLinkPreviewIfRequired = async (text, getUrlInfo, logger) =>
             return urlInfo;
         }
         catch (error) {
-            // ignore if fails
             logger?.warn({ trace: error.stack }, 'url generation failed');
         }
     }
@@ -146,6 +47,13 @@ const assertColor = async (color) => {
         return assertedColor;
     }
 };
+const MessageTypeProto = {
+    image: WAProto.Message.ImageMessage,
+    video: WAProto.Message.VideoMessage,
+    audio: WAProto.Message.AudioMessage,
+    sticker: WAProto.Message.StickerMessage,
+    document: WAProto.Message.DocumentMessage
+};
 export const prepareWAMessageMedia = async (message, options) => {
     const logger = options.logger;
     let mediaType;
@@ -676,8 +584,8 @@ export const generateWAMessageContent = async (message, options) => {
         const { stickers, cover, name, publisher, packId, description } = message.stickerPack;
 
         // ── Validasi jumlah sticker ───────────────────────────────────────────
-        if (stickers.length > 60) {
-            throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
+        if (stickers.length > 120) {
+            throw new Boom('Sticker pack exceeds the maximum limit of 120 stickers', { statusCode: 400 });
         }
         if (stickers.length === 0) {
             throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 });
@@ -715,40 +623,87 @@ export const generateWAMessageContent = async (message, options) => {
 
         // ── Step 1: proses & zip semua sticker ────────────────────────────────
         const stickerData = {};
-        const stickerPromises = stickers.map(async (s, i) => {
-            const { stream } = await getStream(s.data || s.sticker);
-            const buffer = await toBuffer(stream);
+        const stickerMetadata = [];
+        
+        // Process stickers sequentially to avoid memory issues
+        for (let i = 0; i < stickers.length; i++) {
+            const s = stickers[i];
+            try {
+                const { stream } = await getStream(s.data || s.sticker);
+                const buffer = await toBuffer(stream);
 
-            let webpBuffer;
-            let isAnimated = false;
-            if (isWebPBuffer(buffer)) {
-                webpBuffer = buffer;
-                isAnimated = isAnimatedWebP(buffer);
-            } else if ('sharp' in lib && lib.sharp) {
-                webpBuffer = await lib.sharp.default(buffer).webp().toBuffer();
-            } else {
-                throw new Boom(
-                    'No image processing library (sharp) available for converting sticker to WebP. ' +
-                    'Either install sharp or provide stickers in WebP format.'
-                );
-            }
+                if (!buffer || buffer.length === 0) {
+                    continue;
+                }
+
+                let webpBuffer;
+                let isAnimated = false;
+                if (isWebPBuffer(buffer)) {
+                    isAnimated = isAnimatedWebP(buffer);
+                    // Compress animated WebP with sharp
+                    if ('sharp' in lib && lib.sharp) {
+                        webpBuffer = await lib.sharp.default(buffer)
+                            .resize(512, 512, { 
+                                fit: 'inside', 
+                                withoutEnlargement: true 
+                            })
+                            .webp({ 
+                                quality: 75, 
+                                effort: 6 // Maximum compression effort (0-6)
+                            })
+                            .toBuffer();
+                    } else {
+                        webpBuffer = buffer;
+                    }
+                } else if ('sharp' in lib && lib.sharp) {
+                    // Convert and compress static images
+                    webpBuffer = await lib.sharp.default(buffer)
+                        .resize(512, 512, { 
+                            fit: 'inside', 
+                            withoutEnlargement: true 
+                        })
+                        .webp({ 
+                            quality: 75, 
+                            effort: 6 // Maximum compression effort (0-6)
+                        })
+                        .toBuffer();
+                } else {
+                    throw new Boom(
+                        'No image processing library (sharp) available for converting sticker to WebP. ' +
+                        'Either install sharp or provide stickers in WebP format.'
+                    );
+                }
+
+                // Stricter size limit per sticker (1MB for larger packs)
+                const MAX_STICKER_SIZE = 1024 * 1024; // 1MB
+                if (webpBuffer.length > MAX_STICKER_SIZE) {
+                    continue;
+                }
 
-            if (webpBuffer.length > 1024 * 1024) {
-                throw new Boom(`Sticker at index ${i} exceeds the 1MB size limit`, { statusCode: 400 });
+                const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-');
+                const fileName = `${hash}.webp`;
+                // Use compression level 6 for individual stickers in ZIP (balanced)
+                stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 6 }];
+                stickerMetadata.push({
+                    fileName,
+                    mimetype: 'image/webp',
+                    isAnimated,
+                    emojis: s.emojis || [],
+                    accessibilityLabel: s.accessibilityLabel || ''
+                });
+            } catch (err) {
+                // Continue with next sticker instead of failing completely
             }
+        }
 
-            const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-');
-            const fileName = `${hash}.webp`;
-            stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 0 }];
-            return {
-                fileName,
-                mimetype: 'image/webp',
-                isAnimated,
-                emojis: s.emojis || [],
-                accessibilityLabel: s.accessibilityLabel || ''
-            };
-        });
-        const stickerMetadata = await Promise.all(stickerPromises);
+        // Check if we have at least one valid sticker
+        if (stickerMetadata.length === 0) {
+            throw new Boom('No valid stickers could be processed', { statusCode: 400 });
+        }
+
+        if (stickerMetadata.length < stickers.length) {
+            // Some stickers were skipped
+        }
 
         // ── Step 2: proses cover & masukkan ke dalam ZIP ──────────────────────
         const trayIconFileName = `${stickerPackId}.webp`;
@@ -756,37 +711,79 @@ export const generateWAMessageContent = async (message, options) => {
 
         let coverWebpBuffer;
         if (isWebPBuffer(coverBuffer)) {
-            coverWebpBuffer = coverBuffer;
+            // Compress cover WebP
+            if ('sharp' in lib && lib.sharp) {
+                coverWebpBuffer = await lib.sharp.default(coverBuffer)
+                    .resize(512, 512, { 
+                        fit: 'inside', 
+                        withoutEnlargement: true 
+                    })
+                    .webp({ 
+                        quality: 75, 
+                        effort: 6 
+                    })
+                    .toBuffer();
+            } else {
+                coverWebpBuffer = coverBuffer;
+            }
         } else if ('sharp' in lib && lib.sharp) {
-            coverWebpBuffer = await lib.sharp.default(coverBuffer).webp().toBuffer();
+            coverWebpBuffer = await lib.sharp.default(coverBuffer)
+                .resize(512, 512, { 
+                    fit: 'inside', 
+                    withoutEnlargement: true 
+                })
+                .webp({ 
+                    quality: 75, 
+                    effort: 6 
+                })
+                .toBuffer();
         } else {
             throw new Boom(
                 'No image processing library (sharp) available for converting cover to WebP. ' +
                 'Either install sharp or provide cover in WebP format.'
             );
         }
-        stickerData[trayIconFileName] = [new Uint8Array(coverWebpBuffer), { level: 0 }];
+        // Compress cover in ZIP as well (level 6 for balanced compression)
+        stickerData[trayIconFileName] = [new Uint8Array(coverWebpBuffer), { level: 6 }];
 
         // ── Step 3: buat ZIP buffer ───────────────────────────────────────────
         const zipBuffer = await new Promise((resolve, reject) => {
-            zip(stickerData, (err, data) => {
+            zip(stickerData, { level: 6, memLevel: 9 }, (err, data) => {
                 if (err) reject(err);
                 else resolve(Buffer.from(data));
             });
         });
 
+        // ── Validasi ukuran ZIP (WhatsApp limit ~10MB untuk sticker pack) ───
+        const MAX_STICKER_PACK_SIZE = 10 * 1024 * 1024; // 10MB
+        if (zipBuffer.length > MAX_STICKER_PACK_SIZE) {
+            throw new Boom(`Sticker pack too large: ${(zipBuffer.length / 1024 / 1024).toFixed(2)}MB (max: ${(MAX_STICKER_PACK_SIZE / 1024 / 1024).toFixed(2)}MB). Try reducing sticker count or size`, { statusCode: 400 });
+        }
+
         // ── Step 4: encrypt ZIP (generate random mediaKey) ────────────────────
         const stickerPackUpload = await encryptedStream(zipBuffer, 'sticker-pack', {
             logger: options.logger,
             opts: options.options
         });
 
+        options.logger?.info?.(`Sticker pack encrypted, fileSha256: ${stickerPackUpload.fileSha256.toString('base64')}`);
+
         // ── Step 5: upload ZIP ────────────────────────────────────────────────
-        const stickerPackUploadResult = await options.upload(stickerPackUpload.encWriteStream, {
-            fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
-            mediaType: 'sticker-pack',
-            timeoutMs: options.mediaUploadTimeoutMs
-        });
+        let stickerPackUploadResult;
+        try {
+            stickerPackUploadResult = await options.upload(stickerPackUpload.encWriteStream, {
+                fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+                mediaType: 'sticker-pack',
+                timeoutMs: options.mediaUploadTimeoutMs || 300000 // 300s (5 menit) untuk pack besar
+            });
+            options.logger?.info?.(`Sticker pack uploaded successfully: ${stickerPackUploadResult.directPath}`);
+        } catch (uploadError) {
+            options.logger?.error?.(`Sticker pack upload failed: ${uploadError.message}`);
+            throw new Boom(`Failed to upload sticker pack: ${uploadError.message}`, {
+                statusCode: 500,
+                data: { originalError: uploadError }
+            });
+        }
 
         // ── Step 6: build stickerPackMessage ──────────────────────────────────
         m.stickerPackMessage = {
@@ -810,7 +807,7 @@ export const generateWAMessageContent = async (message, options) => {
         try {
             let thumbnailBuffer;
             if ('sharp' in lib && lib.sharp) {
-                thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().toBuffer();
+                thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg({ quality: 80 }).toBuffer();
             } else if ('jimp' in lib && lib.jimp) {
                 const jimpImage = await (lib.jimp.Jimp || lib.jimp.default).read(coverBuffer);
                 thumbnailBuffer = await jimpImage.resize({ w: 252, h: 252 }).getBuffer('image/jpeg');
@@ -831,7 +828,7 @@ export const generateWAMessageContent = async (message, options) => {
             const thumbUploadResult = await options.upload(thumbUpload.encWriteStream, {
                 fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
                 mediaType: 'thumbnail-sticker-pack',
-                timeoutMs: options.mediaUploadTimeoutMs
+                timeoutMs: options.mediaUploadTimeoutMs || 60000
             });
 
             Object.assign(m.stickerPackMessage, {
@@ -842,8 +839,10 @@ export const generateWAMessageContent = async (message, options) => {
                 thumbnailWidth: 252,
                 imageDataHash: sha256(thumbnailBuffer).toString('base64')
             });
+            
+            options.logger?.info?.(`Thumbnail uploaded successfully`);
         } catch (e) {
-            options.logger?.warn?.(`Thumbnail generation failed: ${e}`);
+            options.logger?.warn?.(`Thumbnail generation/upload failed: ${e.message}`);
         }
 
         m.stickerPackMessage.contextInfo = {

package/lib/Utils/offline-node-processor.js

@@ -0,0 +1,39 @@
+/**
+ * Creates a processor for offline stanza nodes that:
+ * - Queues nodes for sequential processing
+ * - Yields to the event loop periodically to avoid blocking
+ * - Catches handler errors to prevent the processing loop from crashing
+ */
+export function makeOfflineNodeProcessor(nodeProcessorMap, deps, batchSize = 10) {
+    const nodes = [];
+    let isProcessing = false;
+    const enqueue = (type, node) => {
+        nodes.push({ type, node });
+        if (isProcessing) {
+            return;
+        }
+        isProcessing = true;
+        const promise = async () => {
+            let processedInBatch = 0;
+            while (nodes.length && deps.isWsOpen()) {
+                const { type, node } = nodes.shift();
+                const nodeProcessor = nodeProcessorMap.get(type);
+                if (!nodeProcessor) {
+                    deps.onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node');
+                    continue;
+                }
+                await nodeProcessor(node).catch(err => deps.onUnexpectedError(err, `processing offline ${type}`));
+                processedInBatch++;
+                // Yield to event loop after processing a batch
+                // This prevents blocking the event loop for too long when there are many offline nodes
+                if (processedInBatch >= batchSize) {
+                    processedInBatch = 0;
+                    await deps.yieldToEventLoop();
+                }
+            }
+            isProcessing = false;
+        };
+        promise().catch(error => deps.onUnexpectedError(error, 'processing offline nodes'));
+    };
+    return { enqueue };
+}

package/lib/Utils/rich-message-utils.js

@@ -0,0 +1,392 @@
+/**
+ * Lia@Changes 09-04-26 [WIP]
+ * Adds support for tables and code blocks with richResponseMessage (wrapped inside botForwardedMessage).
+ *
+ * If you use or copy this code, please credit my name or project.
+ * @itsliaaa/baileys
+ */
+import { getRandomValues, randomUUID, randomBytes } from 'crypto';
+import { BOT_RENDERING_CONFIG_METADATA, DONATE_URL, LEXER_REGEX } from '../Defaults/index.js';
+import { LANGUAGE_KEYWORDS } from '../WABinary/constants.js';
+import { CodeHighlightType, RichSubMessageType } from '../Types/RichType.js';
+import { proto } from '../../WAProto/index.js';
+import { unixTimestampSeconds } from './generics.js';
+const NOOP = new Set([]);
+export const tokenizeCode = (code, language = 'javascript') => {
+    const keywords = LANGUAGE_KEYWORDS[language] || NOOP;
+    const blocks = [];
+    LEXER_REGEX.lastIndex = 0;
+    let match;
+    while ((match = LEXER_REGEX.exec(code)) !== null) {
+        if (match[1]) {
+            blocks.push({ highlightType: CodeHighlightType.COMMENT, codeContent: match[1] });
+        }
+        else if (match[2]) {
+            blocks.push({ highlightType: CodeHighlightType.STRING, codeContent: match[2] });
+        }
+        else if (match[3]) {
+            blocks.push({
+                highlightType: keywords.has(match[3]) ? CodeHighlightType.KEYWORD : CodeHighlightType.METHOD,
+                codeContent: match[3],
+            });
+        }
+        else if (match[4]) {
+            blocks.push({
+                highlightType: keywords.has(match[4]) ? CodeHighlightType.KEYWORD : CodeHighlightType.DEFAULT,
+                codeContent: match[4],
+            });
+        }
+        else if (match[5]) {
+            blocks.push({ highlightType: CodeHighlightType.NUMBER, codeContent: match[5] });
+        }
+        else {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: match[6] });
+        }
+    }
+    return blocks;
+};
+// Lia@Changes 09-04-26 --- Inject buffer into unifiedResponse.data to support proper rendering of rich messages (ex: tables and code blocks)
+export const toUnified = (submessages) =>
+    ({
+        response_id: randomUUID(),
+        sections: submessages.map((submessage, index) => {
+            switch (submessage.messageType) {
+                case RichSubMessageType.CODE:
+                    const codeMetadata = submessage.codeMetadata;
+                    return {
+                        view_model: {
+                            primitive: {
+                                language: codeMetadata.codeLanguage,
+                                code_blocks: codeMetadata.codeBlocks.map((block) => ({ content: block.codeContent, type: CodeHighlightType[block.highlightType] })),
+                                __typename: 'GenAICodeUXPrimitive'
+                            },
+                            __typename: 'GenAISingleLayoutViewModel'
+                        }
+                    };
+                case RichSubMessageType.CONTENT_ITEMS:
+                    return {
+                        view_model: {
+                            primitives: submessage.contentItemsMetadata.itemsMetadata.map((item) => {
+                                const reelItem = item.reelItem
+                                return {
+                                    reels_url: reelItem.videoUrl,
+                                    thumbnail_url: reelItem.thumbnailUrl,
+                                    creator: reelItem.creator || '@itsliaaa/baileys',
+                                    avatar_url: reelItem.profileIconUrl,
+                                    reels_title: reelItem.title,
+                                    likes_count: reelItem.likesCount || 0,
+                                    shares_count: reelItem.sharesCount || 0,
+                                    view_count: reelItem.viewCount || 0,
+                                    reel_source: reelItem.reelSource || 'IG',
+                                    is_verified: reelItem.isVerified || false,
+                                    __typename: 'GenAIReelPrimitive'
+                                }
+                            }),
+                            __typename: 'GenAIHScrollLayoutViewModel'
+                        }
+                    };
+                case RichSubMessageType.LATEX:
+                    const latexMetadata = submessage.latexMetadata;
+                    const item = {
+                        latex_expression: latexMetadata.expressions[0]?.latexExpression,
+                        font_height: latexMetadata.expressions[0]?.fontHeight,
+                        padding: 15,
+                        latex_image: {
+                            url: latexMetadata.expressions[0]?.url,
+                            width: latexMetadata.expressions[0]?.width || 388,
+                            height: latexMetadata.expressions[0]?.height || 160
+                        }
+                    };
+                    return {
+                        view_model: {
+                            primitive: {
+                                item,
+                                ...item,
+                                __typename: 'GenAILatexUXPrimitive'
+                            },
+                            __typename: 'GenAISingleLayoutViewModel'
+                        }
+                    };
+                case RichSubMessageType.TABLE:
+                    const tableMetadata = submessage.tableMetadata;
+                    return {
+                        view_model: {
+                            primitive: {
+                                title: tableMetadata.title,
+                                rows: tableMetadata.rows.map((row) => ({ is_header: row.isHeading, cells: row.items, markdown_cells: [] })),
+                                __typename: 'GenATableUXPrimitive'
+                            },
+                            __typename: 'GenAISingleLayoutViewModel'
+                        }
+                    };
+                case RichSubMessageType.TEXT:
+                    return {
+                        view_model: {
+                            primitive: {
+                                text: submessage.messageText,
+                                inline_entities: submessage.inlineEntities || [],
+                                __typename: 'GenAIMarkdownTextUXPrimitive'
+                            },
+                            __typename: 'GenAISingleLayoutViewModel'
+                        }
+                    };
+            }
+            return submessage;
+        })
+    });
+// Lia@Note 17-04-26 --- WIP
+export const buildAdditionalBotMetadataContext = (submessages) => {
+    const sources = [];
+    const mediaDetailsMetadataList = [];
+    for (let i = 0; i < submessages.length; i++) {
+        const submessage = submessages[i];
+        switch (submessage.messageType) {
+            case RichSubMessageType.CONTENT_ITEMS:
+                const itemsMetadata = submessage.contentItemsMetadata.itemsMetadata;
+                for (let n = 0; n < itemsMetadata.length; n++) {
+                    const reelItem = itemsMetadata[n].reelItem;
+                    sources.push({
+                        provider: 0,
+                        thumbnailCdnUrl: reelItem.thumbnailUrl,
+                        sourceProviderUrl: reelItem.videoUrl,
+                        sourceQuery: '',
+                        faviconCdnUrl: '',
+                        citationNumber: i + 1,
+                        sourceTitle: reelItem.title
+                    });
+                    mediaDetailsMetadataList.push({
+                        id: randomBytes(32).toString('hex'),
+                        previewMedia: {
+                            fileSha256: '',
+                            mediaKey: '',
+                            fileEncSha256: '',
+                            directPath: '',
+                            mediaKeyTimestamp: unixTimestampSeconds(),
+                            mimetype: 'image/jpeg'
+                        }
+                    });
+                }
+                break;
+            case RichSubMessageType.LATEX:
+                const expressions = submessage.latexMetadata.expressions;
+                for (let n = 0; n < expressions.length; n++) {
+                    const expression = expressions[n];
+                    mediaDetailsMetadataList.push({
+                        id: randomBytes(32).toString('hex'),
+                        previewMedia: {
+                            fileSha256: '',
+                            mediaKey: '',
+                            fileEncSha256: '',
+                            directPath: '',
+                            mediaKeyTimestamp: unixTimestampSeconds(),
+                            mimetype: 'image/jpeg'
+                        }
+                    });
+                }
+                break;
+        }
+    }
+    return { sources, mediaDetailsMetadataList };
+}
+export const prepareRichResponseMessage = (content) => {
+    const { code, contentText, expressions, footerText, headerText, items, language, links, noHeading, richResponse, table, text, title } = content;
+    let submessages = [];
+    if (Array.isArray(richResponse)) {
+        submessages = richResponse.map((submessage) => {
+            if (submessage.text) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: submessage.text,
+                    inlineEntities: submessage.inlineEntities
+                };
+            }
+            else if (submessage.code) {
+                return {
+                    messageType: RichSubMessageType.CODE,
+                    codeMetadata: {
+                        codeLanguage: submessage.language,
+                        codeBlocks: submessage.code
+                    }
+                };
+            }
+            else if (submessage.expressions) {
+                return {
+                    messageType: RichSubMessageType.LATEX,
+                    latexMetadata: {
+                        text: submessage.text,
+                        expressions: submessage.expressions
+                    }
+                };
+            }
+            else if (submessage.items) {
+                return {
+                    messageType: RichSubMessageType.CONTENT_ITEMS,
+                    contentItemsMetadata: {
+                        itemsMetadata: submessage.items
+                    }
+                };
+            }
+            else if (submessage.table) {
+                return {
+                    messageType: RichSubMessageType.TABLE,
+                    tableMetadata: {
+                        title: submessage.title,
+                        rows: submessage.table
+                    }
+                };
+            }
+            return submessage;
+        });
+    }
+    else {
+        if (headerText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: headerText
+            });
+        }
+        if (contentText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: contentText
+            });
+        }
+        if (code) {
+            language ??= 'javascript';
+            submessages.push({
+                messageType: RichSubMessageType.CODE,
+                codeMetadata: {
+                    codeLanguage: language,
+                    codeBlocks: tokenizeCode(code, language)
+                }
+            });
+        }
+        else if (expressions) {
+            submessages.push({
+                messageType: RichSubMessageType.LATEX,
+                latexMetadata: {
+                    text,
+                    expressions
+                }
+            });
+        }
+        else if (items) {
+            submessages.push({
+                messageType: RichSubMessageType.CONTENT_ITEMS,
+                contentItemsMetadata: {
+                    itemsMetadata: items.map((item) => ({ reelItem: item })),
+                    contentType: proto.AIRichResponseContentItemsMetadata.ContentType.CAROUSEL
+                }
+            });
+        }
+        else if (links) {
+            links.forEach((linkField, index) => {
+                const prefix = 'SS_' + index;
+                const url = linkField.url || DONATE_URL;
+                const sources = linkField.sources?.map((sourceField) => ({
+                    source_type: 'THIRD_PARTY',
+                    source_display_name: sourceField.displayName || 'Donate',
+                    source_subtitle: sourceField.subtitle || 'Saweria',
+                    source_url: sourceField.url || url
+                }));
+                submessages.push({
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: linkField.text + ` {{${prefix}}}¹{{/${prefix}}} `,
+                    inlineEntities: [{
+                        key: prefix,
+                        metadata: {
+                            reference_id: index + 1,
+                            reference_url: url,
+                            reference_title: linkField.title || 'For Donation via Saweria',
+                            reference_display_name: linkField.displayName || 'Donation',
+                            sources: sources || [],
+                            __typename: 'GenAISearchCitationItem'
+                        }
+                    }]
+                });
+            });
+        }
+        else if (table) {
+            submessages.push({
+                messageType: RichSubMessageType.TABLE,
+                tableMetadata: {
+                    title,
+                    rows: table.map((items, index) => ({
+                        isHeading: !noHeading && index == 0,
+                        items
+                    }))
+                }
+            });
+        }
+        if (footerText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: footerText
+            });
+        }
+    }
+    const unified = toUnified(submessages);
+    const message = wrapToBotForwardedMessage({
+        submessages: [],
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: {
+            data: Buffer.from(JSON.stringify(unified), 'utf-8') // Lia@Note 25-04-26 --- Expects "ArrayBufferLike"
+        },
+        contextInfo: {
+            isForwarded: true,
+            forwardingScore: 1,
+            forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+            forwardOrigin: 4,
+            botMessageSharingInfo: { forwardScore: 1 }
+        }
+    });
+    // Lia@Note 17-04-26 --- TODO: Fill mediaDetailsMetadataList and sources field
+    const { sources, mediaDetailsMetadataList } = buildAdditionalBotMetadataContext(submessages);
+    const botMetadata = message.messageContextInfo.botMetadata;
+    if (sources.length > 0) {
+        botMetadata.richResponseSourcesMetadata = { sources };
+    }
+    if (mediaDetailsMetadataList.length > 0) {
+        botMetadata.unifiedResponseMutation = { mediaDetailsMetadataList };
+    }
+    return message;
+}
+// Lia@Note 17-04-26 --- signature and certificateChain for proofs[] field
+export const botMetadataSignature = () => {
+    const signature = new Uint8Array(64);
+    getRandomValues(signature);
+    return signature;
+}
+export const botMetadataCertificate = (length = 700) => {
+    const certificate = new Uint8Array(length);
+    certificate[0] = 48;
+    certificate[1] = 130;
+    getRandomValues(certificate.subarray(2));
+    return certificate;
+}
+export const wrapToBotForwardedMessage = (richResponseMessage) =>
+    ({
+        messageContextInfo: {
+            botMetadata: {
+                pluginMetadata: {},
+                // Lia@Note 09-04-26 --- TODO: Fill verificationMetadata field
+                verificationMetadata: {
+                    proofs: [
+                        {
+                            certificateChain: [
+                                botMetadataCertificate(684),
+                                botMetadataCertificate(892)
+                            ],
+                            version: 1,
+                            useCase: 1,
+                            signature: botMetadataSignature()
+                        }
+                    ]
+                },
+                botRenderingConfigMetadata: BOT_RENDERING_CONFIG_METADATA
+            }
+        },
+        botForwardedMessage: {
+            message: { richResponseMessage }
+        }
+    });

package/lib/Utils/stanza-ack.js

@@ -0,0 +1,37 @@
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ */
+export function buildAckStanza(node, errorCode, meId) {
+    const { tag, attrs } = node;
+    const stanza = {
+        tag: 'ack',
+        attrs: {
+            id: attrs.id,
+            to: attrs.from,
+            class: tag
+        }
+    };
+    if (errorCode) {
+        stanza.attrs.error = errorCode.toString();
+    }
+    if (attrs.participant) {
+        stanza.attrs.participant = attrs.participant;
+    }
+    if (attrs.recipient) {
+        stanza.attrs.recipient = attrs.recipient;
+    }
+    // WA Web always includes type when present: `n.type || DROP_ATTR`
+    if (attrs.type) {
+        stanza.attrs.type = attrs.type;
+    }
+    // WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs
+    if (tag === 'message' && meId) {
+        stanza.attrs.from = meId;
+    }
+    return stanza;
+}

package/lib/WABinary/constants.js

@@ -1298,4 +1298,77 @@ for (const [i, DOUBLE_BYTE_TOKEN] of DOUBLE_BYTE_TOKENS.entries()) {
         TOKEN_MAP[element] = { dict: i, index: j };
     }
 }
+
+export const CPP_KEYWORDS = new Set([
+    'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor', 'bool', 'break', 'case',
+    'catch', 'char', 'class', 'compl', 'concept', 'const', 'consteval', 'constexpr', 'constinit',
+    'const_cast', 'continue', 'co_await', 'co_return', 'co_yield', 'decltype', 'default', 'delete',
+    'do', 'double', 'dynamic_cast', 'else', 'enum', 'explicit', 'export', 'extern', 'false', 'float',
+    'for', 'friend', 'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new', 'noexcept',
+    'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq', 'private', 'protected', 'public', 'register',
+    'reinterpret_cast', 'requires', 'return', 'short', 'signed', 'sizeof', 'static', 'static_assert',
+    'static_cast', 'struct', 'switch', 'template', 'this', 'thread_local', 'throw', 'true', 'try',
+    'typedef', 'typeid', 'typename', 'union', 'unsigned', 'using', 'virtual', 'void', 'volatile',
+    'wchar_t', 'while', 'xor', 'xor_eq'
+]);
+export const CSS_KEYWORDS = new Set([
+    'import', 'media', 'font-face', 'keyframes', 'supports', 'charset',
+    'important', 'root', 'hover', 'active', 'focus', 'visited', 'before', 'after',
+    'not', 'nth-child', 'first-child', 'last-child', 'only-child',
+    'none', 'inherit', 'initial', 'unset', 'auto', 'transparent', 'currentcolor'
+]);
+export const GO_KEYWORDS = new Set([
+    'break', 'default', 'func', 'interface', 'select', 'case', 'defer', 'go', 'map', 'struct',
+    'chan', 'else', 'goto', 'package', 'switch', 'const', 'fallthrough', 'if', 'range', 'type',
+    'continue', 'for', 'import', 'return', 'var', 'true', 'false', 'nil'
+]);
+export const HTML_KEYWORDS = new Set([
+    'html', 'head', 'body', 'title', 'meta', 'link', 'script', 'style',
+    'header', 'footer', 'main', 'section', 'article', 'aside', 'nav',
+    'div', 'span', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'a', 'img',
+    'ul', 'ol', 'li', 'table', 'tr', 'td', 'th', 'thead', 'tbody',
+    'form', 'input', 'button', 'select', 'textarea', 'label', 'option',
+    'canvas', 'svg', 'iframe', 'video', 'audio', 'source'
+]);
+export const JS_KEYWORDS = new Set([
+    'import', 'export', 'from', 'default', 'as',
+    'const', 'let', 'var', 'function', 'class', 'extends', 'new',
+    'return', 'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue',
+    'try', 'catch', 'finally', 'throw',
+    'async', 'await', 'yield',
+    'typeof', 'instanceof', 'in', 'of', 'delete', 'void',
+    'true', 'false', 'null', 'undefined', 'NaN', 'Infinity',
+    'this', 'super', 'static', 'get', 'set',
+    'debugger', 'with'
+]);
+export const PYTHON_KEYWORDS = new Set([
+    'import', 'from', 'as', 'def', 'class', 'return', 'if', 'elif', 'else',
+    'for', 'while', 'break', 'continue', 'try', 'except', 'finally', 'raise',
+    'with', 'yield', 'lambda', 'pass', 'del', 'global', 'nonlocal', 'assert',
+    'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'async', 'await',
+    'self', 'print'
+]);
+export const RUST_KEYWORDS = new Set([
+    'as', 'break', 'const', 'continue', 'crate', 'else', 'enum', 'extern', 'false', 'fn', 'for',
+    'if', 'impl', 'in', 'let', 'loop', 'match', 'mod', 'move', 'mut', 'pub', 'ref', 'return',
+    'self', 'Self', 'static', 'struct', 'super', 'trait', 'true', 'type', 'unsafe', 'use',
+    'where', 'while', 'async', 'await', 'dyn', 'abstract', 'become', 'box', 'do', 'final',
+    'macro', 'override', 'priv', 'typeof', 'unsized', 'virtual', 'yield'
+]);
+export const LANGUAGE_KEYWORDS = {
+    css: CSS_KEYWORDS,
+    html: HTML_KEYWORDS,
+    javascript: JS_KEYWORDS,
+    typescript: JS_KEYWORDS,
+    js: JS_KEYWORDS,
+    ts: JS_KEYWORDS,
+    python: PYTHON_KEYWORDS,
+    py: PYTHON_KEYWORDS,
+    go: GO_KEYWORDS,
+    golang: GO_KEYWORDS,
+    cpp: CPP_KEYWORDS,
+    'c++': CPP_KEYWORDS,
+    rust: RUST_KEYWORDS,
+    rs: RUST_KEYWORDS,
+};
 //# sourceMappingURL=constants.js.map

package/lib/WAUSync/Protocols/USyncUsernameProtocol.js

@@ -0,0 +1,22 @@
+import { assertNodeErrorFree } from '../../WABinary/index.js';
+import { USyncUser } from '../USyncUser.js';
+export class USyncUsernameProtocol {
+    name = 'username';
+    getQueryElement() {
+        return {
+            tag: 'username',
+            attrs: {}
+        };
+    }
+    getUserElement(user) {
+        void user;
+        return null;
+    }
+    parser(node) {
+        if (node.tag === 'username') {
+            assertNodeErrorFree(node);
+            return typeof node.content === 'string' ? node.content : null;
+        }
+        return null;
+    }
+}

package/lib/WAUSync/Protocols/index.js

@@ -3,4 +3,5 @@ export * from './USyncContactProtocol.js';
 export * from './USyncStatusProtocol.js';
 export * from './USyncDisappearingModeProtocol.js';
 export * from './UsyncBotProfileProtocol.js';
-export * from './UsyncLIDProtocol.js';
+export * from './UsyncLIDProtocol.js';
+export * from './USyncUsernameProtocol.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blckrose/baileys",
   "type": "module",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",
@@ -82,4 +82,4 @@
   "engines": {
     "node": ">=20.0.0"
   }
-}
+}