violetics 7.0.6-alpha → 7.0.8-alpha

package/lib/Utils/messages.js

@@ -1,15 +1,16 @@
 import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
-import { zip } from 'fflate';
 import { promises as fs } from 'fs';
-import { } from 'stream';
+import {} from 'stream';
 import { proto } from '../../WAProto/index.js';
-import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, DONATE_URL, LIBRARY_NAME, MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { AssociationType, ButtonHeaderType, ButtonType, CarouselCardType, ListType, ProtocolType, WAMessageStatus, WAProto } from '../Types/index.js';
-import { isPnUser, isLidUser, isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
+import { CALL_AUDIO_PREFIX, CALL_VIDEO_PREFIX, MEDIA_KEYS, URL_REGEX, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
+import { WAMessageStatus, WAProto } from '../Types/index.js';
+import { isJidGroup, isJidNewsletter, isJidStatusBroadcast, jidNormalizedUser } from '../WABinary/index.js';
 import { sha256 } from './crypto.js';
 import { generateMessageIDV2, getKeyAuthor, unixTimestampSeconds } from './generics.js';
-import { downloadContentFromMessage, encryptedStream, generateThumbnail, getAudioDuration, getAudioWaveform, getImageProcessingLibrary, getRawMediaUploadData, getStream, toBuffer } from './messages-media.js';
+import { downloadContentFromMessage, encryptedStream, prepareStream, generateThumbnail, getAudioDuration, getAudioWaveform, getStream, toBuffer } from './messages-media.js';
+import { createRequire } from 'module';
+const _require = createRequire(import.meta.url);
 import { shouldIncludeReportingToken } from './reporting-utils.js';
 const MIMETYPE_MAP = {
     image: 'image/jpeg',
@@ -19,6 +20,92 @@ 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,
@@ -26,28 +113,6 @@ const MessageTypeProto = {
     sticker: WAProto.Message.StickerMessage,
     document: WAProto.Message.DocumentMessage
 };
-const mediaAnnotation = [
-    {
-        polygonVertices: [
-            { x: 60.71664810180664, y: -36.39784622192383 },
-            { x: -16.710189819335938, y: 49.263675689697266 },
-            { x: -56.585853576660156, y: 37.85963439941406 },
-            { x: 20.840980529785156, y: -47.80188751220703 }
-        ],
-        newsletter: {
-            // Lia@Note 03-02-26 --- You can change jid, message id, and name via .env (⁠≧⁠▽⁠≦⁠)
-            newsletterJid: process.env.NEWSLETTER_ID ||
-                Buffer.from('313230333633343034303036363434313339406e6577736c6574746572', 'hex').toString(),
-            serverMessageId: process.env.NEWSLETTER_MESSAGE_ID ||
-                Buffer.from('313033', 'hex').toString(),
-            newsletterName: process.env.NEWSLETTER_NAME ||
-                Buffer.from('f09d96b2f09d978df09d96baf09d978bf09d96bff09d96baf09d9785f09d9785', 'hex').toString(),
-            contentType: proto.ContextInfo.ForwardedNewsletterMessageInfo.ContentType.UPDATE,
-            accessibilityText: process.env.NEWSLETTER_ACCESSIBILITY_TEXT ||
-                'violetics'
-        }
-    }
-];
 /**
  * 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
@@ -96,18 +161,15 @@ export const prepareWAMessageMedia = async (message, options) => {
         ...message,
         media: message[mediaType]
     };
-    if (uploadData.image || uploadData.video) {
-        uploadData.annotations = mediaAnnotation;
-    }
     delete uploadData[mediaType];
     // check if cacheable + generate cache key
     const cacheableKey = typeof uploadData.media === 'object' &&
         'url' in uploadData.media &&
         !!uploadData.media.url &&
         !!options.mediaCache &&
-        mediaType + ':' + uploadData.media.url;
+        mediaType + ':' + uploadData.media.url.toString();
     if (mediaType === 'document' && !uploadData.fileName) {
-        uploadData.fileName = LIBRARY_NAME;
+        uploadData.fileName = 'file';
     }
     if (!uploadData.mimetype) {
         uploadData.mimetype = MIMETYPE_MAP[mediaType];
@@ -123,96 +185,45 @@ export const prepareWAMessageMedia = async (message, options) => {
         }
     }
     const isNewsletter = !!options.jid && isJidNewsletter(options.jid);
+    if (isNewsletter) options.newsletter = true;
     const requiresDurationComputation = mediaType === 'audio' && typeof uploadData.seconds === 'undefined';
     const requiresThumbnailComputation = (mediaType === 'image' || mediaType === 'video') && typeof uploadData['jpegThumbnail'] === 'undefined';
-    const requiresWaveformProcessing = mediaType === 'audio' && uploadData.ptt === true;
-    const requiresAudioBackground = options.backgroundColor && mediaType === 'audio' && uploadData.ptt === true;
+    const requiresWaveformProcessing = mediaType === 'audio' && (uploadData.ptt === true || !!options.backgroundColor);
+    const requiresAudioBackground = options.backgroundColor && mediaType === 'audio';
     const requiresOriginalForSomeProcessing = requiresDurationComputation || requiresThumbnailComputation || requiresWaveformProcessing;
-    // vltcs@changes 06-02-26 --- Add few support for sending media to newsletter (⁠≧⁠▽⁠≦⁠)
-    if (isNewsletter) {
-        logger?.info({ key: cacheableKey }, 'Preparing raw media for newsletter');
-        const { filePath, fileSha256, fileLength } = await getRawMediaUploadData(uploadData.media, options.mediaTypeOverride || mediaType, logger);
-        const fileSha256B64 = fileSha256.toString('base64');
-        const [{ mediaUrl, directPath }] = await Promise.all([
-            (async () => {
-                const result = options.upload(filePath, {
-                    fileEncSha256B64: fileSha256B64,
-                    mediaType,
-                    timeoutMs: options.mediaUploadTimeoutMs,
-                    newsletter: isNewsletter
-                });
-                logger?.debug({ mediaType, cacheableKey }, 'uploaded media');
-                return result;
-            })(),
-            (async () => {
-                try {
-                    if (requiresThumbnailComputation) {
-                        const { thumbnail } = await generateThumbnail(filePath, mediaType, options);
-                        uploadData.jpegThumbnail = thumbnail;
-                        logger?.debug('generated thumbnail');
-                    }
-                    if (requiresDurationComputation) {
-                        uploadData.seconds = await getAudioDuration(filePath);
-                        logger?.debug('computed audio duration');
-                    }
-                }
-                catch (error) {
-                    logger?.warn({ trace: error.stack }, 'failed to obtain extra info');
-                }
-            })()
-        ]).finally(async () => {
-            try {
-                await fs.unlink(filePath);
-                logger?.debug('removed tmp files');
-            }
-            catch (error) {
-                logger?.warn('failed to remove tmp file');
+    let streamResult;
+    try {
+        streamResult = await (options.newsletter ? prepareStream : encryptedStream)(
+            uploadData.media,
+            options.mediaTypeOverride || mediaType,
+            {
+                logger,
+                saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
+                opts: options.options,
+                isPtt: uploadData.ptt,
             }
-        });
-        delete uploadData.media;
-        const obj = proto.Message.create({
-            // todo: add more support here
-            [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
-                url: mediaUrl,
-                directPath,
-                fileSha256,
-                fileLength,
-                ...uploadData
-            })
-        });
-        if (uploadData.ptv) {
-            obj.ptvMessage = obj.videoMessage;
-            delete obj.videoMessage;
-        }
-        if (obj.stickerMessage) {
-            obj.stickerMessage.stickerSentTs = Date.now();
-        }
-        if (cacheableKey) {
-            logger?.debug({ cacheableKey }, 'set cache');
-            await options.mediaCache.set(cacheableKey, WAProto.Message.encode(obj).finish());
-        }
-        return obj;
-    }
-    const { mediaKey, encFilePath, originalFilePath, fileEncSha256, fileSha256, fileLength } = await encryptedStream(uploadData.media, options.mediaTypeOverride || mediaType, {
-        logger,
-        saveOriginalFileIfRequired: requiresOriginalForSomeProcessing,
-        opts: options.options
-    });
-    const fileEncSha256B64 = fileEncSha256.toString('base64');
-    const [{ mediaUrl, directPath }] = await Promise.all([
+        );
+    } catch (streamErr) {
+        throw streamErr;
+    }
+    const { mediaKey, encWriteStream, bodyPath, fileEncSha256, fileSha256, fileLength, didSaveToTmpPath } = streamResult;
+
+    const fileEncSha256B64 = (options.newsletter ? fileSha256 : fileEncSha256 ?? fileSha256).toString('base64');
+
+    const [{ mediaUrl, directPath, handle: uploadHandle }] = await Promise.all([
         (async () => {
-            const result = await options.upload(encFilePath, {
+            const result = await options.upload(encWriteStream, {
                 fileEncSha256B64,
                 mediaType,
-                timeoutMs: options.mediaUploadTimeoutMs
+                timeoutMs: options.mediaUploadTimeoutMs,
+                newsletter: !!options.newsletter
             });
-            logger?.debug({ mediaType, cacheableKey }, 'uploaded media');
             return result;
         })(),
         (async () => {
             try {
                 if (requiresThumbnailComputation) {
-                    const { thumbnail, originalImageDimensions } = await generateThumbnail(originalFilePath, mediaType, options);
+                    const { thumbnail, originalImageDimensions } = await generateThumbnail(bodyPath, mediaType, options);
                     uploadData.jpegThumbnail = thumbnail;
                     if (!uploadData.width && originalImageDimensions) {
                         uploadData.width = originalImageDimensions.width;
@@ -222,53 +233,71 @@ export const prepareWAMessageMedia = async (message, options) => {
                     logger?.debug('generated thumbnail');
                 }
                 if (requiresDurationComputation) {
-                    uploadData.seconds = await getAudioDuration(originalFilePath);
+                    try {
+                        if (bodyPath) {
+                            uploadData.seconds = await getAudioDuration(bodyPath, uploadData.mimetype);
+                        }
+                    } catch (err) {
+                        uploadData.seconds = 0;
+                    }
+                    // Pastikan seconds valid — NaN/undefined bikin WhatsApp tampilkan Loading...
+                    if (typeof uploadData.seconds !== 'number' || isNaN(uploadData.seconds)) {
+                        uploadData.seconds = 0;
+                    }
                     logger?.debug('computed audio duration');
                 }
                 if (requiresWaveformProcessing) {
-                    uploadData.waveform = await getAudioWaveform(originalFilePath, logger);
-                    logger?.debug('processed waveform');
+                    try {
+                        uploadData.waveform = await getAudioWaveform(bodyPath || encWriteStream, logger);
+                    } catch (err) {
+                    }
+                    if (!uploadData.waveform) {
+                        uploadData.waveform = new Uint8Array([0,99,0,99,0,99,0,99,88,99,0,99,0,55,0,99,0,99,0,99,0,99,0,99,88,99,0,99,0,55,0,99]);
+                    }
                 }
                 if (requiresAudioBackground) {
                     uploadData.backgroundArgb = await assertColor(options.backgroundColor);
                     logger?.debug('computed backgroundColor audio status');
                 }
-            }
-            catch (error) {
+            } catch (error) {
                 logger?.warn({ trace: error.stack }, 'failed to obtain extra info');
             }
         })()
     ]).finally(async () => {
         try {
-            await fs.unlink(encFilePath);
-            if (originalFilePath) {
-                await fs.unlink(originalFilePath);
+            if (!Buffer.isBuffer(encWriteStream)) {
+                encWriteStream.destroy?.();
             }
-            logger?.debug('removed tmp files');
-        }
-        catch (error) {
+            if (didSaveToTmpPath && bodyPath) {
+                await fs.unlink(bodyPath).catch(() => {});
+            }
+        } catch (error) {
             logger?.warn('failed to remove tmp file');
         }
     });
-    delete uploadData.media;
-    const obj = proto.Message.create({
+    const obj = WAProto.Message.fromObject({
         [`${mediaType}Message`]: MessageTypeProto[mediaType].fromObject({
-            url: mediaUrl,
+            url: uploadHandle ? undefined : mediaUrl,
             directPath,
-            mediaKey,
-            fileEncSha256,
+            mediaKey: mediaKey,
+            fileEncSha256: fileEncSha256,
             fileSha256,
             fileLength,
-            mediaKeyTimestamp: unixTimestampSeconds(),
-            ...uploadData
+            mediaKeyTimestamp: uploadHandle ? undefined : unixTimestampSeconds(),
+            ...uploadData,
+            media: undefined,
+            ...(options?.contextInfo ? { contextInfo: options.contextInfo } : {})
         })
     });
     if (uploadData.ptv) {
         obj.ptvMessage = obj.videoMessage;
         delete obj.videoMessage;
     }
-    if (obj.stickerMessage) {
-        obj.stickerMessage.stickerSentTs = Date.now();
+    // Attach uploadHandle so sendMessage can use it as media_id
+    if (uploadHandle) {
+        obj._uploadHandle = uploadHandle;
+    }
+    if (mediaType === 'audio') {
     }
     if (cacheableKey) {
         logger?.debug({ cacheableKey }, 'set cache');
@@ -282,335 +311,13 @@ export const prepareDisappearingMessageSettingContent = (ephemeralExpiration) =>
         ephemeralMessage: {
             message: {
                 protocolMessage: {
-                    type: ProtocolType.EPHEMERAL_SETTING,
+                    type: WAProto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
                     ephemeralExpiration
                 }
             }
         }
     };
-    return content;
-};
-// vltcs@changes 31-01-26 --- Extract product message into a standalone function so it can also be reused as the header for interactive messages
-const prepareProductMessage = async (message, options) => {
-    if (!message.businessOwnerJid) {
-        throw new Boom('"businessOwnerJid" is missing from the content', { statusCode: 400 });
-    }
-    const { imageMessage } = await prepareWAMessageMedia({ image: message.image || message.product.productImage }, options);
-    // vltcs@changes 01-02-26 --- Add product message default value
-    const content = {
-        ...message,
-        product: {
-            currencyCode: 'IDR',
-            priceAmount1000: 1000,
-            title: LIBRARY_NAME,
-            ...message.product,
-            productImage: imageMessage
-        }
-    };
-    delete content.image;
-    return content;
-};
-/**
- * Lia@Note 30-01-26
- * ---
- * Credits: Work on ensuring stickerPackMessage fields are valid by @jlucaso1 (https://github.com/jlucaso1).
- * based on https://github.com/WhiskeySockets/Baileys/pull/1561
- */
-const prepareStickerPackMessage = async (message, options) => {
-    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'GitHub: itsliaaa', description = '🏷️ itsliaaa/baileys' } = message;
-    if (stickers.length > 60) {
-        throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
-    }
-    if (stickers.length === 0) {
-        throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 });
-    }
-    if (!cover) {
-        throw new Boom('Sticker pack must contain a cover', { statusCode: 400 });
-    }
-    // vltcs@changes 01-02-26 --- Add caching for sticker pack (similiar to prepareWAMessageMedia)
-    const cacheableKey = Array.isArray(stickers) &&
-        stickers.length &&
-        !!options.mediaCache &&
-        'sticker:' + stickers
-            .reduce((acc, x) => {
-                const url = typeof x.data === 'object' &&
-                    'url' in x.data &&
-                    !!x.data.url &&
-                    x.data.url;
-                if (url) acc.push(url);
-                return acc;
-            }, [])
-            .join('@');
-    if (cacheableKey) {
-        const mediaBuff = await options.mediaCache.get(cacheableKey);
-        if (mediaBuff) {
-            options.logger?.debug({ cacheableKey }, 'got media cache hit');
-            return proto.Message.StickerPackMessage.decode(mediaBuff);
-        }
-    }
-    const lib = await getImageProcessingLibrary();
-    const stickerPackIdValue = generateMessageIDV2();
-    const stickerData = {};
-    const stickerPromises = stickers.map(async (sticker, i) => {
-        const { stream } = await getStream(sticker.data);
-        const buffer = await toBuffer(stream);
-        let webpBuffer,
-            isAnimated = false;
-        const isWebP = isWebPBuffer(buffer);
-        if (isWebP) {
-            // Already WebP - preserve original to keep exif metadata and animation
-            webpBuffer = buffer;
-            isAnimated = isAnimatedWebP(buffer);
-        }
-        else if ('sharp' in lib && lib.sharp?.default) {
-            // Convert to WebP, preserving metadata
-            webpBuffer = await lib
-                .sharp
-                .default(buffer)
-                .resize(512, 512, { fit: 'inside' })
-                .webp({ quality: 80 })
-                .toBuffer();
-            // Non-WebP inputs converted to WebP are not animated
-            isAnimated = false;
-        }
-        else if ('image' in lib && lib.image?.Transformer) {
-            webpBuffer = await new lib
-                .image
-                .Transformer(buffer)
-                .resize(512, 512)
-                .webp(80);
-            // Non-WebP inputs converted to WebP are not animated
-            isAnimated = false;
-        }
-        else {
-            throw new Boom('No image processing library (sharp or @napi-rs/image) available for converting sticker to WebP. Either install sharp or @napi-rs/image or provide stickers in WebP format.');
-        }
-        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';
-        stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 0 }];
-        return {
-            fileName,
-            mimetype: 'image/webp',
-            isAnimated,
-            emojis: sticker.emojis || ['✨'],
-            accessibilityLabel: sticker.accessibilityLabel || '‎'
-        };
-    });
-    const stickerMetadata = await Promise.all(stickerPromises);
-    // Process and add cover/tray icon to the ZIP
-    const trayIconFileName = stickerPackIdValue + '.webp';
-    const { stream: coverStream } = await getStream(cover);
-    const coverBuffer = await toBuffer(coverStream);
-    let coverWebpBuffer;
-    const isCoverWebP = isWebPBuffer(coverBuffer);
-    if (isCoverWebP) {
-        // Already WebP - preserve original to keep exif metadata
-        coverWebpBuffer = coverBuffer;
-    }
-    else if ('sharp' in lib && lib.sharp?.default) {
-        coverWebpBuffer = await lib
-            .sharp
-            .default(coverBuffer)
-            .resize(512, 512, { fit: 'inside' })
-            .webp({ quality: 80 })
-            .toBuffer();
-    }
-    else if ('image' in lib && lib.image?.Transformer) {
-        coverWebpBuffer = await new lib
-            .image
-            .Transformer(coverBuffer)
-            .resize(512, 512)
-            .webp(80);
-    }
-    else {
-        throw new Boom('No image processing library (sharp or @napi-rs/image) available for converting cover to WebP. Either install sharp or @napi-rs/image or provide cover in WebP format.');
-    }
-    // Add cover to ZIP data
-    stickerData[trayIconFileName] = [new Uint8Array(coverWebpBuffer), { level: 0 }];
-    const zipBuffer = await new Promise((resolve, reject) => {
-        zip(stickerData, (error, data) => {
-            if (error) {
-                reject(error);
-            } else {
-                resolve(Buffer.from(data));
-            }
-        });
-    });
-    const stickerPackSize = zipBuffer.length;
-    const stickerPackUpload = await encryptedStream(zipBuffer, 'sticker-pack', {
-        logger: options.logger,
-        opts: options.options
-    });
-    const stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
-        fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
-        mediaType: 'sticker-pack',
-        timeoutMs: options.mediaUploadTimeoutMs
-    });
-    await fs.unlink(stickerPackUpload.encFilePath);
-    const obj = {
-        name: name,
-        publisher: publisher,
-        stickerPackId: stickerPackIdValue,
-        packDescription: description,
-        stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
-        stickerPackSize: stickerPackSize,
-        stickers: stickerMetadata,
-        fileSha256: stickerPackUpload.fileSha256,
-        fileEncSha256: stickerPackUpload.fileEncSha256,
-        mediaKey: stickerPackUpload.mediaKey,
-        directPath: stickerPackUploadResult.directPath,
-        fileLength: stickerPackUpload.fileLength,
-        mediaKeyTimestamp: unixTimestampSeconds(),
-        trayIconFileName: trayIconFileName
-    };
-    try {
-        // Reuse the cover buffer we already processed for thumbnail generation
-        let thumbnailBuffer;
-        if ('sharp' in lib && lib.sharp?.default) {
-            thumbnailBuffer = await lib
-                .sharp
-                .default(coverBuffer)
-                .resize(252, 252)
-                .jpeg()
-                .toBuffer();
-        }
-        if ('image' in lib && lib.image?.Transformer) {
-            thumbnailBuffer = await new lib
-                .image
-                .Transformer(coverBuffer)
-                .resize(252, 252)
-                .jpeg();
-        }
-        else if ('jimp' in lib && lib.jimp?.Jimp) {
-            const jimpImage = await lib.jimp.Jimp.read(coverBuffer);
-            thumbnailBuffer = await jimpImage
-                .resize({ w: 252, h: 252 })
-                .getBuffer('image/jpeg');
-        }
-        else {
-            throw new Error('No image processing library available for thumbnail generation');
-        }
-        if (!thumbnailBuffer || thumbnailBuffer.length === 0) {
-            throw new Error('Failed to generate thumbnail buffer');
-        }
-        const thumbUpload = await encryptedStream(thumbnailBuffer, 'thumbnail-sticker-pack', {
-            logger: options.logger,
-            opts: options.options,
-            mediaKey: stickerPackUpload.mediaKey // Use same mediaKey as the sticker pack ZIP
-        });
-        const thumbUploadResult = await options.upload(thumbUpload.encFilePath, {
-            fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
-            mediaType: 'thumbnail-sticker-pack',
-            timeoutMs: options.mediaUploadTimeoutMs
-        });
-        await fs.unlink(thumbUpload.encFilePath);
-        Object.assign(obj, {
-            thumbnailDirectPath: thumbUploadResult.directPath,
-            thumbnailSha256: thumbUpload.fileSha256,
-            thumbnailEncSha256: thumbUpload.fileEncSha256,
-            thumbnailHeight: 252,
-            thumbnailWidth: 252,
-            imageDataHash: sha256(thumbnailBuffer).toString('base64')
-        });
-    }
-    catch (error) {
-        options.logger?.warn?.(`Thumbnail generation failed: ${error}`);
-    }
-    const content = obj;
-    if (cacheableKey) {
-        options.logger?.debug({ cacheableKey }, 'set cache');
-        await options.mediaCache.set(cacheableKey, WAProto.Message.StickerPackMessage.encode(content).finish());
-    }
-    return WAProto.Message.StickerPackMessage.fromObject(content);
-};
-// vltcs@changes 30-01-26 --- Add native flow button helper for interactive message
-const prepareNativeFlowButtons = (message) => {
-    const buttons = message.nativeFlow
-    const isButtonsFieldArray = Array.isArray(buttons);
-    const correctedField = isButtonsFieldArray ? buttons : buttons.buttons;
-    const messageParamsJson = {};
-    // vltcs@changes 31-01-26 --- Add coupon and options inside interactive message
-    if (hasOptionalProperty(message, 'couponCode') && !!message.couponCode) {
-        Object.assign(messageParamsJson, {
-            limited_time_offer: {
-                text: message.couponText || LIBRARY_NAME,
-                url: message.couponUrl || DONATE_URL, // Lia@Note 02-02-26 --- Apologies if this feels cheeky, just a fallback
-                copy_code: message.couponCode,
-                expiration_time: Date.now() * 2
-            }
-        });
-    }
-    if (hasOptionalProperty(message, 'optionText') && !!message.optionText) {
-        Object.assign(messageParamsJson, {
-            bottom_sheet: {
-                in_thread_buttons_limit: 1,
-                divider_indices: Array.from(
-                    { length: correctedField.length },
-                    (_, index) => index
-                ),
-                list_title: message.optionTitle || '📄 Select Options',
-                button_title: message.optionText
-            }
-        });
-    }
-    return {
-        buttons: correctedField.map(button => {
-            const buttonText = button.text || button.buttonText;
-            if (hasOptionalProperty(button, 'id') && !!button.id) {
-                return {
-                    name: 'quick_reply',
-                    buttonParamsJson: JSON.stringify({
-                        display_text: buttonText || '👉🏻 Click',
-                        id: button.id
-                    })
-                };
-            }
-            else if (hasOptionalProperty(button, 'copy') && !!button.copy) {
-                return {
-                    name: 'cta_copy',
-                    buttonParamsJson: JSON.stringify({
-                        display_text: buttonText || '📋 Copy',
-                        copy_code: button.copy
-                    })
-                };
-            }
-            else if (hasOptionalProperty(button, 'url') && !!button.url) {
-                return {
-                    name: 'cta_url',
-                    buttonParamsJson: JSON.stringify({
-                        display_text: buttonText || '🌐 Visit',
-                        url: button.url,
-                        merchant_url: button.url
-                    })
-                };
-            }
-            else if (hasOptionalProperty(button, 'call') && !!button.call) {
-                return {
-                    name: 'cta_call',
-                    buttonParamsJson: JSON.stringify({
-                        display_text: buttonText || '📞 Call',
-                        phone_number: button.call
-                    })
-                };
-            }
-            // vltcs@changes 12-03-26 --- Add "single_select" shortcut ＼⁠(⁠°⁠o⁠°⁠)⁠／
-            else if (hasOptionalProperty(button, 'sections') && !!button.sections) {
-                return {
-                    name: 'single_select',
-                    buttonParamsJson: JSON.stringify({
-                        title: buttonText || '📋 Select',
-                        sections: button.sections
-                    })
-                };
-            }
-            return button;
-        }),
-        messageParamsJson: JSON.stringify(messageParamsJson),
-        messageVersion: 1
-    };
+    return WAProto.Message.fromObject(content);
 };
 /**
  * Generate forwarded message content like WA does
@@ -618,7 +325,7 @@ const prepareNativeFlowButtons = (message) => {
  * @param options.forceForward will show the message as forwarded even if it is from you
  */
 export const generateForwardMessageContent = (message, forceForward) => {
-    let content = message.message || message;
+    let content = message.message;
     if (!content) {
         throw new Boom('no content in message', { statusCode: 400 });
     }
@@ -634,24 +341,12 @@ export const generateForwardMessageContent = (message, forceForward) => {
         key = 'extendedTextMessage';
     }
     const key_ = content?.[key];
-    const contextInfo = {};
     if (score > 0) {
-        contextInfo.forwardingScore = score;
-        contextInfo.isForwarded = true;
-    }
-    // when forwarding a newsletter/channel message, add the newsletter context
-    // so the server knows where to find the original media
-    const remoteJid = message.key?.remoteJid;
-    if (remoteJid && isJidNewsletter(remoteJid)) {
-        contextInfo.forwardedNewsletterMessageInfo = {
-            newsletterJid: remoteJid,
-            serverMessageId: message.key?.server_id ? parseInt(message.key.server_id) : null,
-            newsletterName: null
-        };
-        // strip messageContextInfo (contains messageSecret etc.) as WA Web does
-        delete content.messageContextInfo;
+        key_.contextInfo = { forwardingScore: score, isForwarded: true };
+    }
+    else {
+        key_.contextInfo = {};
     }
-    key_.contextInfo = contextInfo;
     return content;
 };
 export const hasNonNullishProperty = (message, key) => {
@@ -661,39 +356,13 @@ export const hasNonNullishProperty = (message, key) => {
         message[key] !== null &&
         message[key] !== undefined);
 };
-export const hasOptionalProperty = (obj, key) => {
-    return typeof obj === 'object' &&
-        obj !== null &&
-        key in obj &&
-        obj[key] !== null;
-};
-// vltcs@changes 06-02-26 --- Validate album message media to avoid bug 👀
-export const hasValidAlbumMedia = (message) => {
-    return Boolean(message.imageMessage ||
-        message.videoMessage);
-};
-export const hasValidInteractiveHeader = (message) => {
-    return Boolean(message.imageMessage ||
-        message.videoMessage ||
-        message.documentMessage ||
-        message.productMessage ||
-        message.locationMessage);
-};
-// vltcs@changes 30-01-26 --- Validate carousel cards header to avoid bug 👀
-export const hasValidCarouselHeader = (message) => {
-    return Boolean(message.imageMessage ||
-        message.videoMessage ||
-        message.productMessage);
-};
+function hasOptionalProperty(obj, key) {
+    return typeof obj === 'object' && obj !== null && key in obj && obj[key] !== null;
+}
 export const generateWAMessageContent = async (message, options) => {
     var _a, _b;
     let m = {};
-    // vltcs@changes 30-01-26 --- Add "raw" boolean to send raw messages directly via generateWAMessage()
-    if (hasNonNullishProperty(message, 'raw')) {
-        delete message.raw;
-        return proto.Message.create(message);
-    }
-    else if (hasNonNullishProperty(message, 'text')) {
+    if (hasNonNullishProperty(message, 'text')) {
         const extContent = { text: message.text };
         let urlInfo = message.linkPreview;
         if (typeof urlInfo === 'undefined') {
@@ -725,58 +394,65 @@ export const generateWAMessageContent = async (message, options) => {
         m.extendedTextMessage = extContent;
     }
     else if (hasNonNullishProperty(message, 'contacts')) {
-        const { contacts } = message; // vltcs@changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
-        const contactLen = contacts.contacts.length;
+        const contactLen = message.contacts.contacts.length;
         if (!contactLen) {
             throw new Boom('require atleast 1 contact', { statusCode: 400 });
         }
         if (contactLen === 1) {
-            m.contactMessage = contacts.contacts[0];
+            m.contactMessage = WAProto.Message.ContactMessage.create(message.contacts.contacts[0]);
         }
         else {
-            m.contactsArrayMessage = contacts;
+            m.contactsArrayMessage = WAProto.Message.ContactsArrayMessage.create(message.contacts);
         }
     }
     else if (hasNonNullishProperty(message, 'location')) {
-        m.locationMessage = message.location;
+        if (message.live) {
+            m.liveLocationMessage = WAProto.Message.LiveLocationMessage.create(message.location);
+        } else {
+            m.locationMessage = WAProto.Message.LocationMessage.create(message.location);
+        }
+        const locType = message.live ? 'liveLocationMessage' : 'locationMessage';
+        if (m[locType]) {
+            m[locType].contextInfo = {
+                ...(message.contextInfo || {}),
+                ...(message.mentions ? { mentionedJid: message.mentions } : {})
+            };
+        }
     }
     else if (hasNonNullishProperty(message, 'react')) {
-        const { react } = message; // vltcs@changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
-        if (!react.senderTimestampMs) {
-            react.senderTimestampMs = Date.now();
+        if (!message.react.senderTimestampMs) {
+            message.react.senderTimestampMs = Date.now();
         }
-        m.reactionMessage = react;
+        m.reactionMessage = WAProto.Message.ReactionMessage.create(message.react);
     }
     else if (hasNonNullishProperty(message, 'delete')) {
         m.protocolMessage = {
             key: message.delete,
-            type: ProtocolType.REVOKE
+            type: WAProto.Message.ProtocolMessage.Type.REVOKE
         };
     }
     else if (hasNonNullishProperty(message, 'forward')) {
         m = generateForwardMessageContent(message.forward, message.force);
     }
     else if (hasNonNullishProperty(message, 'disappearingMessagesInChat')) {
-        const { disappearingMessagesInChat } = message; // vltcs@changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
-        const exp = typeof disappearingMessagesInChat === 'boolean'
-            ? disappearingMessagesInChat
+        const exp = typeof message.disappearingMessagesInChat === 'boolean'
+            ? message.disappearingMessagesInChat
                 ? WA_DEFAULT_EPHEMERAL
                 : 0
-            : disappearingMessagesInChat;
+            : message.disappearingMessagesInChat;
         m = prepareDisappearingMessageSettingContent(exp);
     }
     else if (hasNonNullishProperty(message, 'groupInvite')) {
-        const { groupInvite } = message; // vltcs@changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
         m.groupInviteMessage = {};
-        m.groupInviteMessage.inviteCode = groupInvite.inviteCode;
-        m.groupInviteMessage.inviteExpiration = groupInvite.inviteExpiration;
-        m.groupInviteMessage.caption = groupInvite.text;
-        m.groupInviteMessage.groupJid = groupInvite.jid;
-        m.groupInviteMessage.groupName = groupInvite.subject;
+        m.groupInviteMessage.inviteCode = message.groupInvite.inviteCode;
+        m.groupInviteMessage.inviteExpiration = message.groupInvite.inviteExpiration;
+        m.groupInviteMessage.caption = message.groupInvite.text;
+        m.groupInviteMessage.groupJid = message.groupInvite.jid;
+        m.groupInviteMessage.groupName = message.groupInvite.subject;
         //TODO: use built-in interface and get disappearing mode info etc.
         //TODO: cache / use store!?
         if (options.getProfilePicUrl) {
-            const pfpUrl = await options.getProfilePicUrl(groupInvite.jid, 'preview');
+            const pfpUrl = await options.getProfilePicUrl(message.groupInvite.jid, 'preview');
             if (pfpUrl) {
                 const resp = await fetch(pfpUrl, { method: 'GET', dispatcher: options?.options?.dispatcher });
                 if (resp.ok) {
@@ -786,137 +462,206 @@ export const generateWAMessageContent = async (message, options) => {
             }
         }
     }
-    else if (hasNonNullishProperty(message, 'stickers')) {
-        m.stickerPackMessage = await prepareStickerPackMessage(message, options);
-    }
     else if (hasNonNullishProperty(message, 'pin')) {
         m.pinInChatMessage = {};
         m.messageContextInfo = {};
-        m.pinInChatMessage.key = message.pin;
-        m.pinInChatMessage.type = message.type;
-        m.pinInChatMessage.senderTimestampMs = Date.now();
-        m.messageContextInfo.messageAddOnDurationInSecs = message.type === 1 ? message.time || 86400 : 0;
+        m.pinInChatMessage.key = message.pin.key;
+        m.pinInChatMessage.type = message.pin?.type || 1;
+        m.pinInChatMessage.senderTimestampMs = message.pin?.time || Date.now();
+        m.messageContextInfo.messageAddOnDurationInSecs = message.pin.type === 1 ? message.pin.time || 86400 : 0;
+        m.messageContextInfo.messageAddOnExpiryType = proto.MessageContextInfo.MessageAddonExpiryType.STATIC;
     }
     else if (hasNonNullishProperty(message, 'keep')) {
         m.keepInChatMessage = {};
-        m.keepInChatMessage.key = message.keep;
-        m.keepInChatMessage.keepType = message.type;
-        m.keepInChatMessage.timestampMs = Date.now();
-    }
-    else if (hasNonNullishProperty(message, 'flowReply')) {
-        const { flowReply } = message; // vltcs@changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
-        m.interactiveResponseMessage = {
-            body: {
-                format: flowReply.format || proto.Message.InteractiveResponseMessage.Body.Format.DEFAULT,
-                text: flowReply.text
-            },
-            nativeFlowResponseMessage: {
-                name: flowReply.name,
-                paramsJson: flowReply.paramsJson || '{}',
-                version: flowReply.version || 1
-            }
+        m.keepInChatMessage.key = message.keep.key;
+        m.keepInChatMessage.keepType = message.keep?.type || 1;
+        m.keepInChatMessage.timestampMs = message.keep?.time || Date.now();
+    }
+    else if (hasNonNullishProperty(message, 'call')) {
+        m.scheduledCallCreationMessage = {};
+        m.scheduledCallCreationMessage.scheduledTimestampMs = message.call?.time || Date.now();
+        m.scheduledCallCreationMessage.callType = message.call?.type || 1;
+        m.scheduledCallCreationMessage.title = message.call?.name || 'Call Creation';
+        m.scheduledCallCreationMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+    }
+    else if (hasNonNullishProperty(message, 'paymentInvite')) {
+        m.messageContextInfo = {};
+        m.paymentInviteMessage = {};
+        m.paymentInviteMessage.expiryTimestamp = message.paymentInvite?.expiry || 0;
+        m.paymentInviteMessage.serviceType = message.paymentInvite?.type || 2;
+        m.paymentInviteMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
         };
     }
     else if (hasNonNullishProperty(message, 'buttonReply')) {
-        const { buttonReply } = message; // vltcs@changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
         switch (message.type) {
+            case 'list':
+                m.listResponseMessage = {
+                    title: message.buttonReply.title,
+                    description: message.buttonReply.description,
+                    singleSelectReply: {
+                        selectedRowId: message.buttonReply.rowId
+                    },
+                    listType: proto.Message.ListResponseMessage.ListType.SINGLE_SELECT
+                };
+                break;
             case 'template':
                 m.templateButtonReplyMessage = {
-                    selectedDisplayText: buttonReply.displayText,
-                    selectedId: buttonReply.id,
-                    selectedIndex: buttonReply.index
+                    selectedDisplayText: message.buttonReply.displayText,
+                    selectedId: message.buttonReply.id,
+                    selectedIndex: message.buttonReply.index
                 };
                 break;
             case 'plain':
                 m.buttonsResponseMessage = {
-                    selectedButtonId: buttonReply.id,
-                    selectedDisplayText: buttonReply.displayText,
+                    selectedButtonId: message.buttonReply.id,
+                    selectedDisplayText: message.buttonReply.displayText,
                     type: proto.Message.ButtonsResponseMessage.Type.DISPLAY_TEXT
                 };
                 break;
+            case 'interactive':
+                m.interactiveResponseMessage = {
+                    body: {
+                        text: message.buttonReply.displayText,
+                        format: proto.Message.InteractiveResponseMessage.Body.Format.EXTENSIONS_1
+                    },
+                    nativeFlowResponseMessage: {
+                        name: message.buttonReply.nativeFlows.name,
+                        paramsJson: message.buttonReply.nativeFlows.paramsJson,
+                        version: message.buttonReply.nativeFlows.version
+                    }
+                };
+                break;
         }
     }
-    else if (hasNonNullishProperty(message, 'listReply')) {
-        const { listReply } = message; // vltcs@changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
-        m.listResponseMessage = {
-            description: listReply.description,
-            listType: proto.Message.ListResponseMessage.ListType.SINGLE_SELECT,
-            singleSelectReply: {
-                selectedRowId: listReply.id
+    else if (hasNonNullishProperty(message, 'album')) {
+        const imageMessages = message.album.filter(item => 'image' in item);
+        const videoMessages = message.album.filter(item => 'video' in item);
+        m.albumMessage = WAProto.Message.AlbumMessage.fromObject({
+            expectedImageCount: imageMessages.length,
+            expectedVideoCount: videoMessages.length
+        });
+    }
+    else if (hasNonNullishProperty(message, 'order')) {
+        m.orderMessage = WAProto.Message.OrderMessage.fromObject(message.order);
+        m.orderMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+    }
+    else if (hasNonNullishProperty(message, 'payment')) {
+        const requestPaymentMessage = {
+            amount: {
+                currencyCode: message.payment?.currency || 'IDR',
+                offset: message.payment?.offset || 0,
+                value: message.payment?.amount || 999999999
             },
-            title: listReply.title
+            expiryTimestamp: message.payment?.expiry || 0,
+            amount1000: (message.payment?.amount || 999999999) * 1000,
+            currencyCodeIso4217: message.payment?.currency || 'IDR',
+            requestFrom: message.payment?.from || '0@s.whatsapp.net',
+            noteMessage: {
+                extendedTextMessage: {
+                    text: message.payment?.note || 'Notes'
+                }
+            },
+            background: {
+                placeholderArgb: message.payment?.image?.placeholderArgb || 4278190080,
+                textArgb: message.payment?.image?.textArgb || 4294967295,
+                subtextArgb: message.payment?.image?.subtextArgb || 4294967295,
+                type: 1
+            }
+        };
+        requestPaymentMessage.noteMessage.extendedTextMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
         };
+        m.requestPaymentMessage = requestPaymentMessage;
+    }
+    else if (hasNonNullishProperty(message, 'pollResult')) {
+        if (!Array.isArray(message.pollResult.values)) {
+            throw new Boom('Invalid pollResult values', { statusCode: 400 });
+        }
+        const pollResultSnapshotMessage = {
+            name: message.pollResult.name,
+            pollVotes: message.pollResult.values.map(([optionName, optionVoteCount]) => ({
+                optionName,
+                optionVoteCount
+            }))
+        };
+        pollResultSnapshotMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m.pollResultSnapshotMessage = pollResultSnapshotMessage;
     }
     else if (hasOptionalProperty(message, 'ptv') && message.ptv) {
         const { videoMessage } = await prepareWAMessageMedia({ video: message.video }, options);
         m.ptvMessage = videoMessage;
     }
     else if (hasNonNullishProperty(message, 'product')) {
-        m.productMessage = await prepareProductMessage(message, options);
+        const { imageMessage } = await prepareWAMessageMedia({ image: message.product.productImage }, options);
+        m.productMessage = WAProto.Message.ProductMessage.create({
+            ...message,
+            product: {
+                ...message.product,
+                productImage: imageMessage
+            }
+        });
+    }
+    else if (hasNonNullishProperty(message, 'listReply')) {
+        m.listResponseMessage = { ...message.listReply };
     }
     else if (hasNonNullishProperty(message, 'event')) {
-        const { event } = message; // vltcs@changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
         m.eventMessage = {};
-        const startTime = Math.floor(event.startDate.getTime() / 1000);
-        if (event.call && options.getCallLink) {
-            const token = await options.getCallLink(event.call, { startTime });
-            m.eventMessage.joinLink = (event.call === 'audio' ? CALL_AUDIO_PREFIX : CALL_VIDEO_PREFIX) + token;
+        const startTime = Math.floor(message.event.startDate.getTime() / 1000);
+        if (message.event.call && options.getCallLink) {
+            const token = await options.getCallLink(message.event.call, { startTime });
+            m.eventMessage.joinLink = (message.event.call === 'audio' ? CALL_AUDIO_PREFIX : CALL_VIDEO_PREFIX) + token;
         }
         m.messageContextInfo = {
             // encKey
-            messageSecret: event.messageSecret || randomBytes(32)
+            messageSecret: message.event.messageSecret || randomBytes(32)
         };
-        m.eventMessage.name = event.name;
-        m.eventMessage.description = event.description;
+        m.eventMessage.name = message.event.name;
+        m.eventMessage.description = message.event.description;
         m.eventMessage.startTime = startTime;
-        m.eventMessage.endTime = event.endDate ? event.endDate.getTime() / 1000 : undefined;
-        m.eventMessage.isCanceled = event.isCancelled ?? false;
-        m.eventMessage.extraGuestsAllowed = event.extraGuestsAllowed;
-        m.eventMessage.isScheduleCall = event.isScheduleCall ?? false;
-        m.eventMessage.location = event.location;
+        m.eventMessage.endTime = message.event.endDate ? message.event.endDate.getTime() / 1000 : undefined;
+        m.eventMessage.isCanceled = message.event.isCancelled ?? false;
+        m.eventMessage.extraGuestsAllowed = message.event.extraGuestsAllowed;
+        m.eventMessage.isScheduleCall = message.event.isScheduleCall ?? false;
+        m.eventMessage.location = message.event.location;
     }
     else if (hasNonNullishProperty(message, 'poll')) {
-        const { poll } = message; // vltcs@changes 04-02-26 --- Destructured for readability & cleaner access (⁠✷⁠‿⁠✷⁠)
-        (_a = poll).selectableCount || (_a.selectableCount = 0);
-        (_b = poll).toAnnouncementGroup || (_b.toAnnouncementGroup = false);
-        if (!Array.isArray(poll.values)) {
+        (_a = message.poll).selectableCount || (_a.selectableCount = 0);
+        (_b = message.poll).toAnnouncementGroup || (_b.toAnnouncementGroup = false);
+        if (!Array.isArray(message.poll.values)) {
             throw new Boom('Invalid poll values', { statusCode: 400 });
         }
-        if (poll.selectableCount < 0 || poll.selectableCount > poll.values.length) {
-            throw new Boom(`poll.selectableCount in poll should be >= 0 and <= ${poll.values.length}`, {
+        if (message.poll.selectableCount < 0 || message.poll.selectableCount > message.poll.values.length) {
+            throw new Boom(`poll.selectableCount in poll should be >= 0 and <= ${message.poll.values.length}`, {
                 statusCode: 400
             });
         }
         m.messageContextInfo = {
             // encKey
-            messageSecret: poll.messageSecret || randomBytes(32)
+            messageSecret: message.poll.messageSecret || randomBytes(32)
         };
         const pollCreationMessage = {
-            name: poll.name,
-            selectableOptionsCount: poll.selectableCount,
-            options: poll.values.map(optionName => ({ optionName }))
+            name: message.poll.name,
+            selectableOptionsCount: message.poll.selectableCount,
+            options: message.poll.values.map(optionName => ({ optionName }))
         };
-        if (poll.toAnnouncementGroup) {
+        if (message.poll.toAnnouncementGroup) {
             // poll v2 is for community announcement groups (single select and multiple)
             m.pollCreationMessageV2 = pollCreationMessage;
         }
         else {
-            // vltcs@changes 08-02-26 --- Add quiz message support
-            if (poll.pollType === 1) {
-                if (!poll.correctAnswer) {
-                    throw new Boom('No "correctAnswer" provided for quiz', { statusCode: 400 });
-                }
-                m.pollCreationMessageV5 = {
-                    // Lia@Note 08-02-26 --- quiz for newsletter only
-                    ...pollCreationMessage,
-                    correctAnswer: {
-                        optionName: poll.correctAnswer.toString()
-                    },
-                    pollType: poll.pollType,
-                    selectableOptionsCount: 1
-                };
-            }
-            else if (poll.selectableCount === 1) {
+            if (message.poll.selectableCount === 1) {
                 //poll v3 is for single select polls
                 m.pollCreationMessageV3 = pollCreationMessage;
             }
@@ -926,44 +671,211 @@ export const generateWAMessageContent = async (message, options) => {
             }
         }
     }
-    // vltcs@changes 08-02-26 --- Add poll result snapshot message
-    else if (hasNonNullishProperty(message, 'pollResult')) {
-        const { pollResult } = message;
-        const pollResultSnapshotMessage = {
-            name: pollResult.name,
-            pollVotes: pollResult.votes.map(vote => ({
-                optionName: vote.name,
-                optionVoteCount: parseInt(vote.voteCount)
-            }))
+    else if (hasNonNullishProperty(message, 'stickerPack')) {
+        const { zip } = _require('fflate');
+        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 === 0) {
+            throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 });
+        }
+
+        const stickerPackId = packId || generateMessageIDV2();
+        const [_sharp, _jimp] = await Promise.all([import('sharp').catch(() => null), import('jimp').catch(() => null)]);
+        const lib = _sharp ? { sharp: _sharp } : _jimp ? { jimp: _jimp } : null;
+        if (!lib) throw new Boom('No image processing library available (install sharp or jimp)');
+
+        // ── Helper: deteksi WebP dari magic bytes ─────────────────────────────
+        const isWebPBuffer = (buf) => (
+            buf.length >= 12 &&
+            buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46 &&
+            buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50
+        );
+
+        // ── Helper: deteksi animasi WebP (VP8X/ANIM/ANMF chunks) ─────────────
+        const isAnimatedWebP = (buf) => {
+            if (!isWebPBuffer(buf)) return false;
+            let offset = 12;
+            while (offset < buf.length - 8) {
+                const fourCC = buf.toString('ascii', offset, offset + 4);
+                const chunkSize = buf.readUInt32LE(offset + 4);
+                if (fourCC === 'VP8X') {
+                    const flagsOffset = offset + 8;
+                    if (flagsOffset < buf.length && (buf[flagsOffset] & 0x02)) return true;
+                } else if (fourCC === 'ANIM' || fourCC === 'ANMF') {
+                    return true;
+                }
+                offset += 8 + chunkSize + (chunkSize % 2);
+            }
+            return false;
         };
-        if (pollResult.pollType === 1) {
-            pollResultSnapshotMessage.pollType = proto.Message.PollType.QUIZ;
-            m.pollResultSnapshotMessageV3 = pollResultSnapshotMessage;
-        }
-        else {
-            pollResultSnapshotMessage.pollType = proto.Message.PollType.POLL;
-            m.pollResultSnapshotMessage = pollResultSnapshotMessage;
+
+        // ── 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);
+
+            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 (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`;
+            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);
+
+        // ── Step 2: proses cover & masukkan ke dalam ZIP ──────────────────────
+        const trayIconFileName = `${stickerPackId}.webp`;
+        const coverBuffer = await toBuffer((await getStream(cover)).stream);
+
+        let coverWebpBuffer;
+        if (isWebPBuffer(coverBuffer)) {
+            coverWebpBuffer = coverBuffer;
+        } else if ('sharp' in lib && lib.sharp) {
+            coverWebpBuffer = await lib.sharp.default(coverBuffer).webp().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 }];
+
+        // ── Step 3: buat ZIP buffer ───────────────────────────────────────────
+        const zipBuffer = await new Promise((resolve, reject) => {
+            zip(stickerData, (err, data) => {
+                if (err) reject(err);
+                else resolve(Buffer.from(data));
+            });
+        });
+
+        // ── Step 4: encrypt ZIP (generate random mediaKey) ────────────────────
+        const stickerPackUpload = await encryptedStream(zipBuffer, 'sticker-pack', {
+            logger: options.logger,
+            opts: options.options
+        });
+
+        // ── Step 5: upload ZIP ────────────────────────────────────────────────
+        const stickerPackUploadResult = await options.upload(stickerPackUpload.encWriteStream, {
+            fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+            mediaType: 'sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs
+        });
+
+        // ── Step 6: build stickerPackMessage ──────────────────────────────────
+        m.stickerPackMessage = {
+            name,
+            publisher,
+            stickerPackId,
+            packDescription: description,
+            stickerPackOrigin: WAProto.Message.StickerPackMessage.StickerPackOrigin.THIRD_PARTY,
+            stickerPackSize: zipBuffer.length,
+            stickers: stickerMetadata,
+            fileSha256: stickerPackUpload.fileSha256,
+            fileEncSha256: stickerPackUpload.fileEncSha256,
+            mediaKey: stickerPackUpload.mediaKey,
+            directPath: stickerPackUploadResult.directPath,
+            fileLength: stickerPackUpload.fileLength,
+            mediaKeyTimestamp: unixTimestampSeconds(),
+            trayIconFileName
+        };
+
+        // ── Step 7: generate & upload thumbnail (pakai mediaKey yang sama) ────
+        try {
+            let thumbnailBuffer;
+            if ('sharp' in lib && lib.sharp) {
+                thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().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');
+            } else {
+                throw new Error('No image processing library available for thumbnail generation');
+            }
+
+            if (!thumbnailBuffer || thumbnailBuffer.length === 0) {
+                throw new Error('Failed to generate thumbnail buffer');
+            }
+
+            const thumbUpload = await encryptedStream(thumbnailBuffer, 'thumbnail-sticker-pack', {
+                logger: options.logger,
+                opts: options.options,
+                mediaKey: stickerPackUpload.mediaKey
+            });
+
+            const thumbUploadResult = await options.upload(thumbUpload.encWriteStream, {
+                fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+                mediaType: 'thumbnail-sticker-pack',
+                timeoutMs: options.mediaUploadTimeoutMs
+            });
+
+            Object.assign(m.stickerPackMessage, {
+                thumbnailDirectPath: thumbUploadResult.directPath,
+                thumbnailSha256: thumbUpload.fileSha256,
+                thumbnailEncSha256: thumbUpload.fileEncSha256,
+                thumbnailHeight: 252,
+                thumbnailWidth: 252,
+                imageDataHash: sha256(thumbnailBuffer).toString('base64')
+            });
+        } catch (e) {
+            options.logger?.warn?.(`Thumbnail generation failed: ${e}`);
         }
+
+        m.stickerPackMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
     }
-    // vltcs@changes 08-02-26 --- Add poll update message
-    else if (hasNonNullishProperty(message, 'pollUpdate')) {
-        const { pollUpdate } = message;
-        if (!pollUpdate.key) {
-            throw new Boom('Message key is required', { statusCode: 400 });
-        }
-        if (!pollUpdate.vote) {
-            throw new Boom('Encrypted vote payload is required', { statusCode: 400 });
+    else if (hasNonNullishProperty(message, 'adminInvite')) {
+        m.newsletterAdminInviteMessage = {};
+        m.newsletterAdminInviteMessage.newsletterJid = message.adminInvite.jid;
+        m.newsletterAdminInviteMessage.newsletterName = message.adminInvite.name;
+        m.newsletterAdminInviteMessage.caption = message.adminInvite.caption;
+        m.newsletterAdminInviteMessage.inviteExpiration = message.adminInvite.expiration;
+        if (message.adminInvite.jpegThumbnail) {
+            m.newsletterAdminInviteMessage.jpegThumbnail = message.adminInvite.jpegThumbnail;
+        } else if (options.getProfilePicUrl) {
+            try {
+                const pfpUrl = await options.getProfilePicUrl(message.adminInvite.jid);
+                if (pfpUrl) {
+                    const { thumbnail } = await generateThumbnail(pfpUrl, 'image');
+                    m.newsletterAdminInviteMessage.jpegThumbnail = thumbnail;
+                }
+            } catch (_) {}
         }
-        m.pollUpdateMessage = {
-            metadata: pollUpdate.metadata,
-            pollCreationMessageKey: pollUpdate.key,
-            senderTimestampMs: Date.now(),
-            vote: pollUpdate.vote
+        m.newsletterAdminInviteMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
         };
     }
     else if (hasNonNullishProperty(message, 'sharePhoneNumber')) {
         m.protocolMessage = {
-            type: ProtocolType.SHARE_PHONE_NUMBER
+            type: proto.Message.ProtocolMessage.Type.SHARE_PHONE_NUMBER
         };
     }
     else if (hasNonNullishProperty(message, 'requestPhoneNumber')) {
@@ -971,7 +883,7 @@ export const generateWAMessageContent = async (message, options) => {
     }
     else if (hasNonNullishProperty(message, 'limitSharing')) {
         m.protocolMessage = {
-            type: ProtocolType.LIMIT_SHARING,
+            type: proto.Message.ProtocolMessage.Type.LIMIT_SHARING,
             limitSharing: {
                 sharingLimited: message.limitSharing === true,
                 trigger: 1,
@@ -980,444 +892,288 @@ export const generateWAMessageContent = async (message, options) => {
             }
         };
     }
-    // vltcs@changes 01-02-26 --- Add payment invite message
-    else if (hasNonNullishProperty(message, 'paymentInviteServiceType')) {
-        m.paymentInviteMessage = {
-            expiryTimestamp: Date.now(),
-            serviceType: message.paymentInviteServiceType
-        };
+    else if ('interactiveMessage' in message && !!message.interactiveMessage) {
+        // ── Passthrough interactiveMessage raw object ──────────────────────
+        // Must be BEFORE the else block to avoid hitting prepareWAMessageMedia
+        // which throws 'Invalid media type' for interactiveMessage keys.
+        m = { interactiveMessage: message.interactiveMessage };
     }
-    // vltcs@changes 01-02-26 --- Add order message
-    else if (hasNonNullishProperty(message, 'orderText')) {
-        if (!Buffer.isBuffer(message.thumbnail)) {
-            throw new Boom('Must provide thumbnail buffer in order message', { statusCode: 400 });
-        }
-        m.orderMessage = {
-            itemCount: 1,
-            messageVersion: 1,
-            orderTitle: LIBRARY_NAME,
-            status: proto.Message.OrderMessage.OrderStatus.INQUIRY,
-            surface: proto.Message.OrderMessage.OrderSurface.CATALOG,
-            token: generateMessageIDV2(),
-            totalAmount1000: 1000,
-            totalCurrencyCode: 'IDR',
-            ...message,
-            message: message.orderText
-        };
-        delete m.orderMessage.orderText;
+    else {
+        m = await prepareWAMessageMedia(message, options);
     }
-    // vltcs@changes 31-01-26 --- Add support for album messages
-    else if (hasNonNullishProperty(message, 'album')) {
-        const { album } = message;
-        if (!Array.isArray(album)) {
-            throw new Boom('Invalid album type. Expected an array.', { statusCode: 400 });
-        }
-        let videoCount = 0;
-        for (let i = 0; i < album.length; i++) {
-            if (album[i].video) videoCount++;
-        };
-        let imageCount = 0;
-        for (let i = 0; i < album.length; i++) {
-            if (album[i].image) imageCount++;
+    if ('sections' in message && !!message.sections) {
+        const listMessage = {
+            title: message.title,
+            buttonText: message.buttonText,
+            footerText: message.footer,
+            description: message.text,
+            sections: message.sections,
+            listType: proto.Message.ListMessage.ListType.SINGLE_SELECT
         };
-        if ((videoCount + imageCount) < 2) {
-            throw new Boom('Minimum provide 2 media to upload album message', { statusCode: 400 });
-        }
-        m.albumMessage = {
-            expectedImageCount: imageCount,
-            expectedVideoCount: videoCount
+        listMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
         };
+        m = { listMessage };
     }
-    else {
-        m = await prepareWAMessageMedia(message, options);
+    else if ('productList' in message && !!message.productList) {
+        const thumbnail = message.thumbnail ? await generateThumbnail(message.thumbnail, 'image') : null;
+        const listMessage = {
+            title: message.title,
+            buttonText: message.buttonText,
+            footerText: message.footer,
+            description: message.text,
+            productListInfo: {
+                productSections: message.productList,
+                headerImage: {
+                    productId: message.productList[0].products[0].productId,
+                    jpegThumbnail: thumbnail?.thumbnail || null
+                },
+                businessOwnerJid: message.businessOwnerJid
+            },
+            listType: proto.Message.ListMessage.ListType.PRODUCT_LIST
+        };
+        listMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { listMessage };
     }
-    // vltcs@changes 30-01-26 --- Add interactive messages (buttonsMessage, listMessage, interactiveMessage, templateMessage, and carouselMessage)
-    if (hasNonNullishProperty(message, 'buttons')) {
+    else if ('buttons' in message && !!message.buttons) {
         const buttonsMessage = {
-            buttons: message.buttons.map(button => {
-                // vltcs@changes 12-03-26 --- Add "single_select" shortcut!
-                const buttonText = button.text || button.buttonText
-                if (hasOptionalProperty(button, 'sections')) {
-                    return {
-                        nativeFlowInfo: {
-                            name: 'single_select',
-                            paramsJson: JSON.stringify({
-                                title: buttonText,
-                                sections: button.sections
-                            })
-                        },
-                        type: ButtonType.NATIVE_FLOW
-                    };
-                }
-                else if (hasOptionalProperty(button, 'name')) {
-                    return {
-                        nativeFlowInfo: {
-                            name: button.name,
-                            paramsJson: button.paramsJson
-                        },
-                        type: ButtonType.NATIVE_FLOW
-                    };
-                }
-                return {
-                    buttonId: button.id || button.buttonId,
-                    buttonText: typeof buttonText === 'string' ? { displayText: buttonText } : buttonText,
-                    type: button.type || ButtonType.RESPONSE
-                };
-            })
+            buttons: message.buttons.map(b => ({ ...b, type: proto.Message.ButtonsMessage.Button.Type.RESPONSE }))
         };
-        if (hasOptionalProperty(message, 'text')) {
+        if ('text' in message) {
             buttonsMessage.contentText = message.text;
-            buttonsMessage.headerType = ButtonHeaderType.EMPTY;
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType.EMPTY;
         }
         else {
-            if (hasOptionalProperty(message, 'caption')) {
+            if ('caption' in message) {
                 buttonsMessage.contentText = message.caption;
             }
             const type = Object.keys(m)[0].replace('Message', '').toUpperCase();
-            buttonsMessage.headerType = ButtonHeaderType[type];
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType[type];
             Object.assign(buttonsMessage, m);
         }
-        if (hasOptionalProperty(message, 'footer')) {
+        if ('footer' in message && !!message.footer) {
             buttonsMessage.footerText = message.footer;
         }
-        m = { buttonsMessage };
-    }
-    else if (hasNonNullishProperty(message, 'sections')) {
-        const listMessage = {
-            sections: message.sections,
-            buttonText: message.buttonText,
-            title: message.title,
-            footerText: message.footer,
-            description: message.text,
-            listType: ListType.SINGLE_SELECT
+        if ('title' in message && !!message.title) {
+            buttonsMessage.text = message.title;
+            buttonsMessage.headerType = proto.Message.ButtonsMessage.HeaderType.TEXT;
+        }
+        buttonsMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
         };
-        m = { listMessage };
+        m = { buttonsMessage };
     }
-    // Lia@Note 03-02-26 --- This message type is shown on WhatsApp Web/Desktop and iOS (I guess ｡⁠◕⁠‿⁠◕⁠｡). On Android, it only appears in newsletter (so far ಥ⁠‿⁠ಥ)
-    else if (hasNonNullishProperty(message, 'templateButtons')) {
+    else if ('templateButtons' in message && !!message.templateButtons) {
         const hydratedTemplate = {
-            hydratedButtons: message.templateButtons.map((button, i) => {
-                if (hasOptionalProperty(button, 'id')) {
-                    return {
-                        index: i,
-                        quickReplyButton: {
-                            displayText: button.text || button.buttonText || '👉🏻 Click',
-                            id: button.id
-                        }
-                    };
-                }
-                else if (hasOptionalProperty(button, 'url')) {
-                    return {
-                        index: i,
-                        urlButton: {
-                            displayText: button.text || button.buttonText || '🌐 Visit',
-                            url: button.url
-                        }
-                    };
-                }
-                else if (hasOptionalProperty(button, 'call')) {
-                    return {
-                        index: i,
-                        callButton: {
-                            displayText: button.text || button.buttonText || '📞 Call',
-                            phoneNumber: button.call
-                        }
-                    };
-                }
-                button.index = button.index || i;
-                return button;
-            })
+            hydratedButtons: message.templateButtons
         };
-        if (hasOptionalProperty(message, 'text')) {
+        if ('text' in message) {
             hydratedTemplate.hydratedContentText = message.text;
         }
         else {
-            if (hasOptionalProperty(message, 'caption')) {
-                hydratedTemplate.hydratedTitleText = message.title;
+            if ('caption' in message) {
                 hydratedTemplate.hydratedContentText = message.caption;
-            };
+            }
             Object.assign(hydratedTemplate, m);
         }
-        if (hasOptionalProperty(message, 'footer')) {
+        if ('footer' in message && !!message.footer) {
             hydratedTemplate.hydratedFooterText = message.footer;
         }
-        hydratedTemplate.templateId = message.id || 'template-' + Date.now(); // Lia@Note 04-02-26 --- Minimal templateId to satisfy WhatsApp (⁠ ⁠ꈍ⁠ᴗ⁠ꈍ⁠)
-        m = {
-            templateMessage: {
-                hydratedFourRowTemplate: hydratedTemplate,
-                hydratedTemplate: hydratedTemplate
-            }
-        }
+        hydratedTemplate.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { templateMessage: { fourRowTemplate: hydratedTemplate, hydratedTemplate } };
     }
-    else if (hasNonNullishProperty(message, 'nativeFlow')) {
+    else if ('interactiveButtons' in message && !!message.interactiveButtons) {
         const interactiveMessage = {
-            nativeFlowMessage: prepareNativeFlowButtons(message)
+            nativeFlowMessage: proto.Message.InteractiveMessage.NativeFlowMessage.fromObject({
+                buttons: message.interactiveButtons,
+            })
         };
-        if (hasOptionalProperty(message, 'bizJid')) {
-            interactiveMessage.collectionMessage = {
-                bizJid: message.bizJid,
-                id: message.id,
-                messageVersion: 1
-            };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
         }
-        else if (hasOptionalProperty(message, 'shopSurface')) {
-            interactiveMessage.shopStorefrontMessage = {
-                surface: message.shopSurface,
-                id: message.id,
-                messageVersion: 1
+        else if ('caption' in message) {
+            interactiveMessage.body = { text: message.caption };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: message?.media ?? false,
             };
+            Object.assign(interactiveMessage.header, m);
         }
-        if (hasOptionalProperty(message, 'text')) {
-            interactiveMessage.body = { text: message.text };
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
         }
-        else {
-            if (hasOptionalProperty(message, 'caption')) {
-                const isValidHeader = hasValidInteractiveHeader(m)
-                if (!isValidHeader) {
-                    throw new Boom('Invalid media type for interactive message header', { statusCode: 400 });
-                }
-                interactiveMessage.header = {
-                    title: message.title || '',
-                    subtitle: message.subtitle || '',
-                    hasMediaAttachment: isValidHeader
-                };
-                interactiveMessage.body = { text: message.caption };
-            }
-            if (hasOptionalProperty(message, 'thumbnail') && !!message.thumbnail) {
-                interactiveMessage.jpegThumbnail = message.thumbnail;
-            }
+        if ('title' in message && !!message.title) {
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: message?.media ?? false,
+            };
             Object.assign(interactiveMessage.header, m);
         }
-        if (hasOptionalProperty(message, 'audioFooter')) {
-            const parseFooter = await prepareWAMessageMedia({
-                audio: message.audioFooter
-            }, options);
-            interactiveMessage.footer = {
-                audioMessage: parseFooter.audioMessage,
-                hasMediaAttachment: true
-            };
+        if ('contextInfo' in message && !!message.contextInfo) {
+            interactiveMessage.contextInfo = message.contextInfo;
         }
-        else if (hasOptionalProperty(message, 'footer')) {
-            interactiveMessage.footer = { text: message.footer };
+        if ('mentions' in message && !!message.mentions) {
+            interactiveMessage.contextInfo = { mentionedJid: message.mentions };
         }
         m = { interactiveMessage };
     }
-    else if (hasNonNullishProperty(message, 'cards')) {
+    else if ('shop' in message && !!message.shop) {
         const interactiveMessage = {
-            carouselMessage: {
-                cards: await Promise.all(message.cards.map(async card => {
-                    let carouselHeader = {};
-                    if (hasNonNullishProperty(card, 'product')) {
-                        carouselHeader.productMessage = await prepareProductMessage(card, options);
-                    }
-                    else {
-                        carouselHeader = await prepareWAMessageMedia(card, options).catch(() => ({}));
-                    }
-                    const isValidHeader = hasValidCarouselHeader(carouselHeader)
-                    if (!isValidHeader) {
-                        throw new Boom('Invalid media type for carousel card', { statusCode: 400 });
-                    }
-                    const carouselCard = {
-                        nativeFlowMessage: prepareNativeFlowButtons(card.nativeFlow ? card : [])
-                    };
-                    if (hasOptionalProperty(card, 'text')) {
-                        carouselCard.body = { text: card.text };
-                    }
-                    else {
-                        if (hasOptionalProperty(card, 'caption')) {
-                            carouselCard.header = {
-                                title: card.title || '',
-                                subtitle: card.subtitle || '',
-                                hasMediaAttachment: isValidHeader
-                            };
-                            carouselCard.body = { text: card.caption };
-                        }
-                        if (hasOptionalProperty(card, 'thumbnail') && !!card.thumbnail) {
-                            carouselCard.jpegThumbnail = card.thumbnail;
-                        }
-                        Object.assign(carouselCard.header, carouselHeader);
-                    }
-                    if (hasOptionalProperty(card, 'audioFooter')) {
-                        const parseFooter = await prepareWAMessageMedia({
-                            audio: card.audioFooter
-                        }, options);
-                        carouselCard.footer = {
-                            audioMessage: parseFooter.audioMessage,
-                            hasMediaAttachment: true
-                        };
-                    }
-                    else if (hasOptionalProperty(card, 'footer')) {
-                        carouselCard.footer = { text: card.footer };
-                    }
-                    return carouselCard
-                })),
-                carouselCardType: CarouselCardType.UNKNOWN,
-                messageVersion: 1
-            }
+            shopStorefrontMessage: proto.Message.InteractiveMessage.ShopMessage.fromObject({
+                surface: message.shop,
+                id: message.id
+            })
         };
-        if (hasOptionalProperty(message, 'text')) {
+        if ('text' in message) {
             interactiveMessage.body = { text: message.text };
         }
-        if (hasOptionalProperty(message, 'footer')) {
-            interactiveMessage.footer = { text: message.footer };
+        else if ('caption' in message) {
+            interactiveMessage.body = { text: message.caption };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: message?.media ?? false,
+            };
+            Object.assign(interactiveMessage.header, m);
         }
-        m = { interactiveMessage };
-    }
-    // vltcs@changes 01-02-26 --- Add request payment message
-    else if (hasNonNullishProperty(message, 'requestPaymentFrom')) {
-        const requestPaymentMessage = {
-            amount: {
-                currencyCode: 'IDR',
-                offset: 1000,
-                value: 1000
-            },
-            amount1000: 1000,
-            currencyCodeIso4217: 'IDR',
-            expiryTimestamp: Date.now(),
-            noteMessage: m,
-            requestFrom: message.requestPaymentFrom,
-            ...message
-        };
-        delete requestPaymentMessage.requestPaymentFrom;
-        if (hasNonNullishProperty(m, 'extendedTextMessage') || hasNonNullishProperty(m, 'stickerMessage')) {
-            Object.assign(requestPaymentMessage.noteMessage, m);
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
         }
-        else {
-            throw new Boom('Invalid message type for request payment note message', { statusCode: 400 });
+        if ('title' in message && !!message.title) {
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: message?.media ?? false,
+            };
+            Object.assign(interactiveMessage.header, m);
         }
-        m = { requestPaymentMessage };
-    }
-    // vltcs@changes 01-02-26 --- Add invoice message
-    else if (hasNonNullishProperty(message, 'invoiceNote')) {
-        const attachment = m.imageMessage || m.documentMessage;
-        const type = Object.keys(m)[0].replace('Message', '').toUpperCase();
-        const invoiceMessage = {
-            attachmentType: proto.Message.InvoiceMessage.AttachmentType[type === 'DOCUMENT' ? 'PDF' : 'IMAGE'],
-            note: message.invoiceNote
-        };
-        if (attachment) {
-            const { directPath, fileEncSha256, fileSha256, jpegThumbnail = undefined, mediaKey, mediaKeyTimestamp, mimetype } = attachment;
-            Object.assign(invoiceMessage, {
-                attachmentDirectPath: directPath,
-                attachmentFileEncSha256: fileEncSha256,
-                attachmentFileSha256: fileSha256,
-                attachmentJpegThumbnail: jpegThumbnail,
-                attachmentMediaKey: mediaKey,
-                attachmentMediaKeyTimestamp: mediaKeyTimestamp,
-                attachmentMimetype: mimetype,
-                token: generateMessageIDV2()
-            });
+        if ('contextInfo' in message && !!message.contextInfo) {
+            interactiveMessage.contextInfo = message.contextInfo;
         }
-        else {
-            throw new Boom('Invalid media type for invoice message', { statusCode: 400 });
+        if ('mentions' in message && !!message.mentions) {
+            interactiveMessage.contextInfo = { mentionedJid: message.mentions };
         }
-        m = { invoiceMessage };
+        m = { interactiveMessage };
     }
-    // vltcs@changes 31-01-26 --- Add direct externalAdReply access (no need to create contextInfo first)
-    if (hasOptionalProperty(message, 'externalAdReply') && !!message.externalAdReply) {
-        const messageType = Object.keys(m)[0];
-        const key = m[messageType];
-        const content = message.externalAdReply;
-        if ('thumbnail' in content && !Buffer.isBuffer(content.thumbnail)) {
-            throw new Boom('Thumbnail must in buffer type', { statusCode: 400 });
-        }
-        if (!content.url || typeof content.url !== 'string') {
-            content.url = DONATE_URL; // Lia@Note 02-02-26 --- Apologies if this feels cheeky, just a fallback
-        }
-        const externalAdReply = {
-            ...content,
-            body: content.body,
-            mediaType: content.mediaType || 1,
-            mediaUrl: content.url + '?update=' + Date.now(),
-            renderLargerThumbnail: content.largeThumbnail,
-            thumbnail: content.thumbnail,
-            thumbnailUrl: content.url,
-            title: content.title || LIBRARY_NAME
+    else if ('collection' in message && !!message.collection) {
+        const interactiveMessage = {
+            collectionMessage: {
+                bizJid: message.collection.bizJid,
+                id: message.collection.id,
+                messageVersion: message?.collection?.version
+            }
         };
-        delete externalAdReply.subTitle;
-        delete externalAdReply.largeThumbnail;
-        delete externalAdReply.url;
-        if ('contextInfo' in key && !!key.contextInfo) {
-            key.contextInfo.externalAdReply = { ...key.contextInfo.externalAdReply, ...externalAdReply };
-        }
-        else if (key) {
-            key.contextInfo = { externalAdReply };
-        }
-    }
-    if (
-        (hasOptionalProperty(message, 'mentions') && message.mentions?.length) ||
-        (hasOptionalProperty(message, 'mentionAll') && message.mentionAll)
-    ) {
-        const messageType = Object.keys(m)[0];
-        const key = m[messageType];
-        if ('contextInfo' in key && !!key.contextInfo) {
-            key.contextInfo.mentionedJid = message.mentions || [];
-        }
-        else if (key) {
-            key.contextInfo = {
-                mentionedJid: message.mentions || []
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: false
             };
         }
-        if (message.mentionAll) {
-            key.contextInfo.mentionedJid = [];
-            key.contextInfo.nonJidMentions = 1;
-        }
-    }
-    if (hasOptionalProperty(message, 'contextInfo') && !!message.contextInfo) {
-        const messageType = Object.keys(m)[0];
-        const key = m[messageType];
-        if ('contextInfo' in key && !!key.contextInfo) {
-            key.contextInfo = { ...key.contextInfo, ...message.contextInfo };
+        else {
+            if ('caption' in message) {
+                interactiveMessage.body = { text: message.caption };
+                interactiveMessage.header = {
+                    title: message.title,
+                    subtitle: message.subtitle,
+                    hasMediaAttachment: message.hasMediaAttachment ? message.hasMediaAttachment : false,
+                    ...Object.assign(interactiveMessage, m)
+                };
+            }
         }
-        else if (key) {
-            key.contextInfo = message.contextInfo;
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
         }
+        interactiveMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
+        };
+        m = { interactiveMessage };
     }
-    // vltcs@changes 31-01-26 --- Add "groupStatus" boolean to set contextInfo.isGroupStatus and wrap message into groupStatusMessageV2
-    if (hasOptionalProperty(message, 'groupStatus') && !!message.groupStatus) {
-        const messageType = Object.keys(m)[0];
-        const key = m[messageType];
-        if ('contextInfo' in key && !!key.contextInfo) {
-            key.contextInfo.isGroupStatus = message.groupStatus;
-        }
-        else if (key) {
-            key.contextInfo = {
-                isGroupStatus: message.groupStatus
+    else if ('cards' in message && !!message.cards) {
+        const slides = await Promise.all(message.cards.map(async (slide) => {
+            const { image, video, product, title, body, footer, buttons } = slide;
+            let header;
+            if (product) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: product.productImage, ...options }, options);
+                header = {
+                    productMessage: {
+                        product: {
+                            ...product,
+                            productImage: imageMessage,
+                        },
+                        ...slide
+                    }
+                };
+            }
+            else if (image) {
+                header = await prepareWAMessageMedia({ image: image, ...options }, options);
+            }
+            else if (video) {
+                header = await prepareWAMessageMedia({ video: video, ...options }, options);
             }
+            return {
+                header: {
+                    title,
+                    hasMediaAttachment: true,
+                    ...header
+                },
+                body: { text: body },
+                footer: { text: footer },
+                nativeFlowMessage: { buttons }
+            };
+        }));
+        const interactiveMessage = {
+            carouselMessage: { cards: slides }
+        };
+        if ('text' in message) {
+            interactiveMessage.body = { text: message.text };
+            interactiveMessage.header = {
+                title: message.title,
+                subtitle: message.subtitle,
+                hasMediaAttachment: false
+            };
         }
-        m = { groupStatusMessageV2: { message: m } };
-        delete message.groupStatus;
-    }
-    // vltcs@changes 02-02-26 --- Add "interactiveAsTemplate" boolean to wrap interactiveMessage into templateMessage
-    else if (hasOptionalProperty(message, 'interactiveAsTemplate') && !!message.interactiveAsTemplate) {
-        if (!m.interactiveMessage) {
-            throw new Boom('Invalid message type for template', { statusCode: 400 }); // Lia@Note 02-02-26 --- To avoid bug 👀
+        if ('footer' in message && !!message.footer) {
+            interactiveMessage.footer = { text: message.footer };
         }
-        m = {
-            templateMessage: {
-                interactiveMessageTemplate: m.interactiveMessage,
-                templateId: message.id || 'template-' + Date.now() // Lia@Note 04-02-26 --- Minimal templateId to satisfy WhatsApp (⁠ ⁠ꈍ⁠ᴗ⁠ꈍ⁠)
-            }
+        interactiveMessage.contextInfo = {
+            ...(message.contextInfo || {}),
+            ...(message.mentions ? { mentionedJid: message.mentions } : {})
         };
-        delete message.interactiveAsTemplate;
+        m = { interactiveMessage };
     }
-    // vltcs@changes 30-01-26 --- Add "ephemeral" boolean to wrap message into ephemeralMessage like "viewOnce"
     if (hasOptionalProperty(message, 'ephemeral') && !!message.ephemeral) {
         m = { ephemeralMessage: { message: m } };
-        delete message.ephemeral;
-    }
-    else if (hasOptionalProperty(message, 'viewOnce') && !!message.viewOnce) {
-        m = { viewOnceMessage: { message: m } };
     }
-    // vltcs@changes 03-02-26 --- Add "viewOnceV2" boolean to wrap message into viewOnceMessageV2 like "viewOnce"
-    else if (hasOptionalProperty(message, 'viewOnceV2') && !!message.viewOnceV2) {
+    if (hasOptionalProperty(message, 'viewOnce') && !!message.viewOnce) {
         m = { viewOnceMessageV2: { message: m } };
-        delete message.viewOnceV2;
     }
-    // vltcs@changes 03-02-26 --- Add "viewOnceV2Extension" boolean to wrap message into viewOnceMessageV2Extension like "viewOnce"
-    else if (hasOptionalProperty(message, 'viewOnceV2Extension') && !!message.viewOnceV2Extension) {
+    if (hasOptionalProperty(message, 'viewOnceExt') && !!message.viewOnceExt) {
         m = { viewOnceMessageV2Extension: { message: m } };
-        delete message.viewOnceV2Extension;
+    }
+    if (hasOptionalProperty(message, 'mentions') && message.mentions?.length) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        if ('contextInfo' in key && !!key.contextInfo) {
+            key.contextInfo.mentionedJid = message.mentions;
+        }
+        else if (key) {
+            key.contextInfo = {
+                mentionedJid: message.mentions
+            };
+        }
     }
     if (hasOptionalProperty(message, 'edit')) {
         m = {
@@ -1425,31 +1181,39 @@ export const generateWAMessageContent = async (message, options) => {
                 key: message.edit,
                 editedMessage: m,
                 timestampMs: Date.now(),
-                type: ProtocolType.MESSAGE_EDIT
+                type: WAProto.Message.ProtocolMessage.Type.MESSAGE_EDIT
             }
+        };
+    }
+    if (hasOptionalProperty(message, 'contextInfo') && !!message.contextInfo) {
+        const messageType = Object.keys(m)[0];
+        const key = m[messageType];
+        if ('contextInfo' in key && !!key.contextInfo) {
+            key.contextInfo = { ...key.contextInfo, ...message.contextInfo };
+        }
+        else if (key) {
+            key.contextInfo = message.contextInfo;
         }
     }
-    if (shouldIncludeReportingToken(m)) {
+    if (shouldIncludeReportingToken(m) && !options.newsletter) {
         m.messageContextInfo = m.messageContextInfo || {};
         if (!m.messageContextInfo.messageSecret) {
             m.messageContextInfo.messageSecret = randomBytes(32);
         }
     }
-    return proto.Message.create(m);
+    return WAProto.Message.create(m);
 };
 export const generateWAMessageFromContent = (jid, message, options) => {
     // set timestamp to now
     // if not specified
     if (!options.timestamp) {
-        options.timestamp = Date.now();
+        options.timestamp = new Date();
     }
-    const messageContextInfo = message.messageContextInfo
     const innerMessage = normalizeMessageContent(message);
     const key = getContentType(innerMessage);
     const timestamp = unixTimestampSeconds(options.timestamp);
-    const isNewsletter = isJidNewsletter(jid);
     const { quoted, userJid } = options;
-    if (quoted && !isNewsletter) {
+    if (quoted && !isJidNewsletter(jid)) {
         const participant = quoted.key.fromMe
             ? userJid // TODO: Add support for LIDs
             : quoted.participant || quoted.key.participant || quoted.key.remoteJid;
@@ -1476,14 +1240,14 @@ export const generateWAMessageFromContent = (jid, message, options) => {
         }
     }
     if (
-        // if we want to send a disappearing message
-        !!options?.ephemeralExpiration &&
+    // if we want to send a disappearing message
+    !!options?.ephemeralExpiration &&
         // and it's not a protocol message -- delete, toggle disappear message
         key !== 'protocolMessage' &&
         // already not converted to disappearing message
         key !== 'ephemeralMessage' &&
         // newsletters don't support ephemeral messages
-        !isNewsletter) {
+        !isJidNewsletter(jid)) {
         /* @ts-ignore */
         innerMessage[key].contextInfo = {
             ...(innerMessage[key].contextInfo || {}),
@@ -1491,15 +1255,7 @@ export const generateWAMessageFromContent = (jid, message, options) => {
             //ephemeralSettingTimestamp: options.ephemeralOptions.eph_setting_ts?.toString()
         };
     }
-    // vltcs@changes 30-01-26 --- Add deviceListMetadata inside messageContextInfo for private chat
-    else if (messageContextInfo?.messageSecret && (isPnUser(jid) || isLidUser(jid))) {
-        messageContextInfo.deviceListMetadata = {
-            recipientKeyHash: randomBytes(10),
-            recipientTimestamp: unixTimestampSeconds()
-        };
-        messageContextInfo.deviceListMetadataVersion = 2
-    }
-    message = proto.Message.create(message);
+    message = WAProto.Message.create(message);
     const messageJSON = {
         key: {
             remoteJid: jid,
@@ -1514,14 +1270,12 @@ export const generateWAMessageFromContent = (jid, message, options) => {
     };
     return WAProto.WebMessageInfo.fromObject(messageJSON);
 };
-export const generateWAMessage = async (jid, content, options = {}) => {
+export const generateWAMessage = async (jid, content, options) => {
     // ensure msg ID is with every log
     options.logger = options?.logger?.child({ msgId: options.messageId });
-    // Pass jid in the options to generateWAMessageContent
-    if (jid && typeof options === 'object') {
-        options.jid = jid;
-    }
-    return generateWAMessageFromContent(jid, await generateWAMessageContent(content, options), options);
+    // Pass jid + newsletter flag to generateWAMessageContent (like wiley)
+    const _isNewsletter = typeof jid === 'string' && jid.endsWith('@newsletter');
+    return generateWAMessageFromContent(jid, await generateWAMessageContent(content, { newsletter: _isNewsletter, ...options, jid }), options);
 };
 /** Get the key to access the true type of content */
 export const getContentType = (content) => {
@@ -1531,6 +1285,21 @@ export const getContentType = (content) => {
         return key;
     }
 };
+/**
+ * Maps a message content type key to its MediaType string.
+ * Handles ptvMessage → 'ptv', audioMessage ptt → 'ptt', etc.
+ */
+export const getMediaTypeFromContentType = (contentType, content) => {
+    if (!contentType)
+        return undefined;
+    if (contentType === 'ptvMessage')
+        return 'ptv';
+    if (contentType === 'audioMessage' && content?.[contentType]?.ptt)
+        return 'ptt';
+    if (contentType === 'videoMessage' && content?.[contentType]?.gifPlayback)
+        return 'gif';
+    return contentType.replace('Message', '');
+};
 /**
  * Normalizes ephemeral, view once messages to regular message content
  * Eg. image messages in ephemeral messages, in view once messages etc.
@@ -1550,33 +1319,16 @@ export const normalizeMessageContent = (content) => {
         content = inner.message;
     }
     return content;
-    // vltcs@changes 03-02-26 --- Add all futureProofMessage into getFutureProofMessage()
     function getFutureProofMessage(message) {
-        return (
-            message?.associatedChildMessage ||
-            message?.botForwardedMessage ||
-            message?.botInvokeMessage ||
-            message?.botTaskMessage ||
+        return (message?.ephemeralMessage ||
+            message?.viewOnceMessage ||
             message?.documentWithCaptionMessage ||
+            message?.viewOnceMessageV2 ||
+            message?.viewOnceMessageV2Extension ||
             message?.editedMessage ||
-            message?.ephemeralMessage ||
-            message?.eventCoverImage ||
-            message?.groupMentionedMessage ||
-            message?.groupStatusMentionMessage ||
+            message?.associatedChildMessage ||
             message?.groupStatusMessage ||
-            message?.groupStatusMessageV2 ||
-            message?.limitSharingMessage ||
-            message?.lottieStickerMessage ||
-            message?.pollCreationMessageV4 ||
-            message?.pollCreationOptionImageMessage ||
-            message?.questionMessage ||
-            message?.questionReplyMessage ||
-            message?.statusAddYours ||
-            message?.statusMentionMessage ||
-            message?.viewOnceMessage ||
-            message?.viewOnceMessageV2 ||
-            message?.viewOnceMessageV2Extension
-        );
+            message?.groupStatusMessageV2);
     }
 };
 /**
@@ -1769,7 +1521,7 @@ export const downloadMediaMessage = async (message, type, options, ctx) => {
             throw new Boom('No message present', { statusCode: 400, data: message });
         }
         const contentType = getContentType(mContent);
-        let mediaType = contentType?.replace('Message', '');
+        let mediaType = getMediaTypeFromContentType(contentType, mContent);
         const media = mContent[contentType];
         if (!media || typeof media !== 'object' || (!('url' in media) && !('thumbnailDirectPath' in media))) {
             throw new Boom(`"${contentType}" message is not a media message`);
@@ -1809,77 +1561,138 @@ export const assertMediaContent = (content) => {
     }
     return mediaContent;
 };
-/**
- * Checks if a WebP buffer is animated by looking for VP8X chunk with animation flag
- * or ANIM/ANMF chunks
- */
-const isAnimatedWebP = (buffer) => {
-    // WebP must start with RIFF....WEBP
-    if (
-        buffer.length < 12 ||
-        buffer[0] !== 0x52 ||
-        buffer[1] !== 0x49 ||
-        buffer[2] !== 0x46 ||
-        buffer[3] !== 0x46 ||
-        buffer[8] !== 0x57 ||
-        buffer[9] !== 0x45 ||
-        buffer[10] !== 0x42 ||
-        buffer[11] !== 0x50
+
+export const patchMessageForMdIfRequired = (message) => {
+    if (message?.buttonsMessage ||
+        message?.templateMessage ||
+        message?.listMessage ||
+        message?.interactiveMessage?.nativeFlowMessage
     ) {
-        return false;
-    };
-    // Parse chunks starting after RIFF header (12 bytes)
-    let offset = 12;
-    while (offset < buffer.length - 8) {
-        const chunkFourCC = buffer.toString('ascii', offset, offset + 4);
-        const chunkSize = buffer.readUInt32LE(offset + 4);
-        if (chunkFourCC === 'VP8X') {
-            // VP8X extended header, check animation flag (bit 1 at offset+8)
-            const flagsOffset = offset + 8;
-            if (flagsOffset < buffer.length) {
-                const flags = buffer[flagsOffset];
-                if (flags & 0x02) {
-                    return true;
-                };
-            };
-        } else if (chunkFourCC === 'ANIM' || chunkFourCC === 'ANMF') {
-            // ANIM or ANMF chunks indicate animation
-            return true;
+        message = {
+            viewOnceMessageV2Extension: {
+                message: {
+                    messageContextInfo: {
+                        deviceListMetadataVersion: 2,
+                        deviceListMetadata: {}
+                    },
+                    ...message
+                }
+            }
         };
-        // Move to next chunk (chunk size + 8 bytes header, padded to even)
-        offset += 8 + chunkSize + (chunkSize % 2);
-    };
-    return false;
+    }
+    return message;
 };
-/**
- * Checks if a buffer is a WebP file
- */
-const isWebPBuffer = (buffer) => {
-    return (
-        buffer.length >= 12 &&
-        buffer[0] === 0x52 &&
-        buffer[1] === 0x49 &&
-        buffer[2] === 0x46 &&
-        buffer[3] === 0x46 &&
-        buffer[8] === 0x57 &&
-        buffer[9] === 0x45 &&
-        buffer[10] === 0x42 &&
-        buffer[11] === 0x50
-    );
+export const prepareAlbumMessageContent = async (jid, albums, options) => {
+    let mediaHandle;
+    let mediaMsg;
+    const message = [];
+    const albumMsg = generateWAMessageFromContent(jid, {
+        albumMessage: {
+            expectedImageCount: albums.filter(item => 'image' in item).length,
+            expectedVideoCount: albums.filter(item => 'video' in item).length
+        }
+    }, options);
+    await options.sock.relayMessage(jid, albumMsg.message, { messageId: albumMsg.key.id });
+    for (const i in albums) {
+        const media = albums[i];
+        if ('image' in media) {
+            mediaMsg = await generateWAMessage(jid, { image: media.image, ...media, ...options }, {
+                userJid: options.userJid,
+                upload: async (encFilePath, opts) => {
+                    const up = await options.sock.waUploadToServer(encFilePath, { ...opts, newsletter: isJidNewsletter(jid) });
+                    mediaHandle = up.handle;
+                    return up;
+                },
+                ...options
+            });
+        } else if ('video' in media) {
+            mediaMsg = await generateWAMessage(jid, { video: media.video, ...media, ...options }, {
+                userJid: options.userJid,
+                upload: async (encFilePath, opts) => {
+                    const up = await options.sock.waUploadToServer(encFilePath, { ...opts, newsletter: isJidNewsletter(jid) });
+                    mediaHandle = up.handle;
+                    return up;
+                },
+                ...options
+            });
+        }
+        if (mediaMsg) {
+            mediaMsg.message.messageContextInfo = {
+                messageSecret: randomBytes(32),
+                messageAssociation: {
+                    associationType: 1,
+                    parentMessageKey: albumMsg.key
+                }
+            };
+        }
+        message.push(mediaMsg);
+    }
+    return message;
 };
 /**
- * vltcs@changes 30-01-26
- * ---
- * Determines whether a message should include a Biz Binary Node.
- * A Biz Binary Node is added only for interactive messages
- * such as buttons or other supported interactive types.
+ * Ekstrak quoted message dari contextInfo pesan.
+ * Return object yang sudah dinormalisasi, termasuk debug info LID/PN.
+ *
+ * @param {object} msg - WAMessage object dari event messages.upsert
+ * @param {object} [options]
+ * @param {boolean} [options.debug] - jika true, log info ke console
+ * @returns {object|null} quoted message info atau null jika tidak ada
  */
-export const shouldIncludeBizBinaryNode = (message) => {
-    const messageType = getContentType(message);
-    return (
-        messageType === 'buttonsMessage' ||
-        messageType === 'interactiveMessage' ||
-        messageType === 'listMessage' ||
-        messageType === 'templateMessage'
-    );
-};
+export const getQuotedMsg = (msg, options = {}) => {
+    const { debug = false } = options;
+    const msgContent = normalizeMessageContent(msg?.message);
+    if (!msgContent) return null;
+    const msgType = getContentType(msgContent);
+    if (!msgType) return null;
+    const innerMsg = msgContent[msgType];
+    if (!innerMsg) return null;
+    const contextInfo = innerMsg.contextInfo;
+    if (!contextInfo?.stanzaId || !contextInfo?.quotedMessage) return null;
+
+    // Normalisasi participant (sender quoted message)
+    const participant = contextInfo.participant || msg.key?.participant || msg.key?.remoteJid || '';
+
+    // Normalisasi mentionedJid di quoted message
+    const quotedMsgContent = normalizeMessageContent(contextInfo.quotedMessage);
+    const quotedMsgType = getContentType(quotedMsgContent);
+    const quotedInnerMsg = quotedMsgType ? quotedMsgContent?.[quotedMsgType] : null;
+    const quotedMentionedJid = quotedInnerMsg?.contextInfo?.mentionedJid || [];
+    const quotedText = quotedInnerMsg?.text || quotedInnerMsg?.caption || quotedInnerMsg?.conversation || '';
+
+    const result = {
+        key: {
+            id: contextInfo.stanzaId,
+            remoteJid: contextInfo.remoteJid || msg.key?.remoteJid || '',
+            participant: participant,
+            fromMe: false
+        },
+        message: contextInfo.quotedMessage,
+        participant,
+        sender: participant,
+        text: quotedText,
+        type: quotedMsgType || '',
+        mentionedJid: quotedMentionedJid,
+        // Debug info
+        _rawContextInfo: debug ? contextInfo : undefined
+    };
+
+    if (debug) {
+        const hasLidInText = typeof quotedText === 'string' && /@\d{13,20}/.test(quotedText);
+        const hasLidInMentioned = quotedMentionedJid.some(j => j?.endsWith('@lid'));
+        const hasLidParticipant = participant?.endsWith('@lid');
+        console.log('[getQuotedMsg DEBUG]', JSON.stringify({
+            stanzaId: contextInfo.stanzaId,
+            participant,
+            participantIsLid: hasLidParticipant,
+            quotedText,
+            textHasLid: hasLidInText,
+            mentionedJid: quotedMentionedJid,
+            mentionedHasLid: hasLidInMentioned,
+            quotedMsgType
+        }, null, 2));
+    }
+
+    return result;
+};
+
+//# sourceMappingURL=messages.js.map