@crysnovax/baileys 2.6.4 → 2.6.5

package/README.md

@@ -732,6 +732,42 @@ await sock.sendMessage(jid, {
 })
 ```
 
+### Rich preview for group status 
+```
+// Fully auto — fetches title, description, image from the URL
+await sock.sendMessage(jid, {
+    text: 'https://facebook.com/share/v/14i...',
+    richPreview: true
+})
+
+// Group status with auto-fetched preview
+await sock.sendMessage(jid, {
+    text: 'https://chat.whatsapp.com/CODE',
+    richPreview: true,
+    groupStatus: true
+})
+```
+### SEND MESSAGES EXACTLY AS IS NO PROCESSING 
+```
+// Relay a received message exactly as-is
+await sock.sendMessage(jid, {
+    likeThis: true,
+    ...m.message  // spread the captured message directly
+})
+
+// Send a manually constructed proto without normalization
+await sock.sendMessage(jid, {
+    likeThis: true,
+    imageMessage: { ...rawFields }
+})
+
+// Re-forward with original quality intact
+await sock.sendMessage(jid, {
+    likeThis: true,
+    ...capturedMsg.message
+})
+```
+
 ### WHATSAPP VERIFIED ☑️ ⚉
 send Media messages with verified WhatsApp check ✔️ 
 ```
@@ -741,6 +777,7 @@ await sock.sendMessage(jid, {
     verifiedMe: true
 })
 ```
+
 ---
 
 ## Meta AI Features

package/lib/Socket/messages-send.js

@@ -3,7 +3,7 @@ import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, buildLinkPreview, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
 import { AssociationType } from '../Types/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex, makeMutex } from '../Utils/make-mutex.js';
@@ -1269,6 +1269,7 @@ export const makeMessagesSocket = (config) => {
                     previewTitle,
                     previewDescription,
                     previewImage,
+                    groupStatus: isGroupStatus,
                     quoted,
                     ...restContent
                 } = content;
@@ -1277,24 +1278,35 @@ export const makeMessagesSocket = (config) => {
                     throw new Boom('richPreview requires a `text` field containing the URL', { statusCode: 400 });
                 }
 
-                // Resolve previewImage into a raw Buffer, whether given as
-                // a Buffer directly or a URL string to fetch
-                let imageBuffer = null;
-                if (previewImage) {
-                    if (Buffer.isBuffer(previewImage)) {
-                        imageBuffer = previewImage;
+                // Auto-fetch metadata (title, description, image) when not provided.
+                // Uses library helpers: fetchLinkMeta, resolvePreviewMeta, resolvePreviewImage,
+                // with special handling for chat.whatsapp.com invite links (uses groupGetInviteInfo
+                // + profilePictureUrl instead of scraping the bot-blocked page).
+                const _preview = await buildLinkPreview(
+                    previewLink,
+                    sock,
+                    {
+                        customTitle: previewTitle || '',
+                        customDesc: previewDescription || '',
+                        customImage: Buffer.isBuffer(previewImage) ? previewImage : null
                     }
-                    else if (typeof previewImage === 'string') {
-                        try {
-                            const res = await fetch(previewImage);
-                            imageBuffer = Buffer.from(await res.arrayBuffer());
-                        }
-                        catch (err) {
-                            logger?.warn({ err }, 'richPreview: failed to fetch previewImage URL');
-                        }
+                );
+
+                let imageBuffer = _preview.imageBuffer;
+
+                // If previewImage was a URL string, fetch it (overrides auto-fetch)
+                if (!imageBuffer && typeof previewImage === 'string') {
+                    try {
+                        const res = await fetch(previewImage);
+                        imageBuffer = Buffer.from(await res.arrayBuffer());
+                    } catch (err) {
+                        logger?.warn({ err }, 'richPreview: failed to fetch previewImage URL');
                     }
                 }
 
+                const resolvedTitle = previewTitle || _preview.title || '';
+                const resolvedDescription = previewDescription || _preview.description || '';
+
                 // Small embedded jpegThumbnail — kept under the ~7KB ceiling
                 // that causes WA clients to render a blank/black preview if exceeded.
                 // 296px @ quality 50 (fixed internally by extractImageThumb) sits
@@ -1323,41 +1335,48 @@ export const makeMessagesSocket = (config) => {
                     }
                 }
 
-                const previewMessage = {
-                    extendedTextMessage: {
-                        text: previewLink,
-                        matchedText: previewLink,
-                        canonicalUrl: previewLink,
-                        title: previewTitle || '',
-                        description: previewDescription || '',
-                        previewType: 5, // IMAGE
-                        jpegThumbnail: smallThumb || undefined,
-                        ...(hq
-                            ? {
-                                thumbnailDirectPath: hq.directPath,
-                                mediaKey: hq.mediaKey,
-                                mediaKeyTimestamp: hq.mediaKeyTimestamp,
-                                thumbnailWidth: hq.width,
-                                thumbnailHeight: hq.height,
-                                thumbnailSha256: hq.fileSha256,
-                                thumbnailEncSha256: hq.fileEncSha256
-                            }
-                            : {}),
-                        ...restContent
-                    }
+                const extendedText = {
+                    text: previewLink,
+                    matchedText: previewLink,
+                    canonicalUrl: previewLink,
+                    title: resolvedTitle,
+                    description: resolvedDescription,
+                    previewType: 5, // IMAGE
+                    jpegThumbnail: smallThumb || undefined,
+                    ...(hq
+                        ? {
+                            thumbnailDirectPath: hq.directPath,
+                            mediaKey: hq.mediaKey,
+                            mediaKeyTimestamp: hq.mediaKeyTimestamp,
+                            thumbnailWidth: hq.width,
+                            thumbnailHeight: hq.height,
+                            thumbnailSha256: hq.fileSha256,
+                            thumbnailEncSha256: hq.fileEncSha256
+                        }
+                        : {}),
+                    ...restContent
                 };
 
-                const msgId = options.messageId || generateMessageIDV2(userJid);
-
                 if (quoted) {
-                    previewMessage.extendedTextMessage.contextInfo = {
-                        ...(previewMessage.extendedTextMessage.contextInfo || {}),
+                    extendedText.contextInfo = {
+                        ...(extendedText.contextInfo || {}),
                         stanzaId: quoted.key.id,
                         participant: jidNormalizedUser(quoted.key.fromMe ? userJid : (quoted.key.participant || quoted.key.remoteJid)),
                         quotedMessage: quoted.message
                     };
                 }
 
+                // Support groupStatus:true alongside richPreview:true
+                if (isGroupStatus) {
+                    extendedText.contextInfo = { ...(extendedText.contextInfo || {}), isGroupStatus: true };
+                }
+
+                const previewMessage = isGroupStatus
+                    ? { groupStatusMessageV2: { message: { extendedTextMessage: extendedText } } }
+                    : { extendedTextMessage: extendedText };
+
+                const msgId = options.messageId || generateMessageIDV2(userJid);
+
                 await relayMessage(jid, previewMessage, {
                     messageId: msgId,
                     additionalAttributes: options.additionalAttributes || {},
@@ -1381,14 +1400,54 @@ export const makeMessagesSocket = (config) => {
                 }
                 return fullMsg;
             }
-            else {
-                const fullMsg = await generateWAMessage(jid, content, {
-                    logger,
-                    userJid,
-                    getUrlInfo: text => getUrlInfo(text, {
-                        thumbnailWidth: linkPreviewImageThumbnailWidth,
-                        fetchOpts: {
-                            timeout: 3000,
+            // crysnovax@LikeThis --- likeThis:true relays the message object exactly as-is,
+            // bypassing generateWAMessage/generateWAMessageContent entirely.
+            // No re-encoding, no normalization, no transformation — what you pass is what WA gets.
+            //
+            // Useful for:
+            //   - Forwarding a message with original proto fields intact (no re-upload)
+            //   - Relaying a captured incoming message verbatim
+            //   - Sending a manually constructed proto without fighting normalization
+            //   - Re-sending albums/carousels without re-uploading every item
+            //
+            // WARNING: bypasses all validation — broken proto fields go straight to WA.
+            //
+            // Usage:
+            //   sock.sendMessage(jid, {
+            //       likeThis: true,
+            //       imageMessage: { ...rawProtoFields }
+            //   })
+            //   sock.sendMessage(jid, {
+            //       likeThis: true,
+            //       ...capturedMessage.message   // spread a received message directly
+            //   })
+            else if ('likeThis' in content && content.likeThis === true) {
+                const { likeThis: _, ...rawMessage } = content;
+                const msgId = options.messageId || generateMessageIDV2(userJid);
+
+                await relayMessage(jid, rawMessage, {
+                    messageId: msgId,
+                    additionalAttributes: options.additionalAttributes || {},
+                    additionalNodes: options.additionalNodes || []
+                });
+
+                const fullMsg = {
+                    key: {
+                        remoteJid: jid,
+                        fromMe: true,
+                        id: msgId
+                    },
+                    message: rawMessage,
+                    messageTimestamp: unixTimestampSeconds()
+                };
+
+                if (config.emitOwnEvents) {
+                    process.nextTick(async () => {
+                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                    });
+                }
+                return fullMsg;
+            }
                             ...(httpRequestOptions || {})
                         },
                         logger,

package/lib/Socket/messages-send.js[old]

@@ -3,7 +3,7 @@ import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, assertMeId, bindWaitForEvent, decryptMediaRetryData, DEF_MEDIA_HOST, delay, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, extractDeviceJids, extractImageThumb, generateMessageIDV2, generateParticipantHashV2, generateWAMessage, generateWAMessageFromContent, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, hasValidAlbumMedia, MessageRetryManager, normalizeMessageContent, parseAndInjectE2ESessions, prepareWAMessageMedia, shouldIncludeBizBinaryNode, unixTimestampSeconds } from '../Utils/index.js';
 import { AssociationType } from '../Types/index.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { makeKeyedMutex, makeMutex } from '../Utils/make-mutex.js';
@@ -1248,6 +1248,139 @@ export const makeMessagesSocket = (config) => {
                 }
                 return fullMsg;
             }
+            // crysnovax@RichPreview --- richPreview:true auto-builds a manually-constructed
+            // extendedTextMessage with a large preview image, bypassing generateWAMessage's
+            // getUrlInfo scraper (which fails on bot-blocked domains like chat.whatsapp.com)
+            // and avoiding the undocumented ~7KB jpegThumbnail size ceiling that causes a
+            // blank/black render on WA clients when exceeded.
+            //
+            // Usage:
+            //   sock.sendMessage(jid, {
+            //       text: 'https://chat.whatsapp.com/CODE',
+            //       richPreview: true,
+            //       previewTitle: 'Group Name',
+            //       previewDescription: '12 members · Tap to join',
+            //       previewImage: imageBufferOrUrl   // Buffer, or a URL string to fetch
+            //   })
+            else if ('richPreview' in content && content.richPreview === true) {
+                const {
+                    richPreview: __rp,
+                    text: previewLink,
+                    previewTitle,
+                    previewDescription,
+                    previewImage,
+                    quoted,
+                    ...restContent
+                } = content;
+
+                if (!previewLink || typeof previewLink !== 'string') {
+                    throw new Boom('richPreview requires a `text` field containing the URL', { statusCode: 400 });
+                }
+
+                // Resolve previewImage into a raw Buffer, whether given as
+                // a Buffer directly or a URL string to fetch
+                let imageBuffer = null;
+                if (previewImage) {
+                    if (Buffer.isBuffer(previewImage)) {
+                        imageBuffer = previewImage;
+                    }
+                    else if (typeof previewImage === 'string') {
+                        try {
+                            const res = await fetch(previewImage);
+                            imageBuffer = Buffer.from(await res.arrayBuffer());
+                        }
+                        catch (err) {
+                            logger?.warn({ err }, 'richPreview: failed to fetch previewImage URL');
+                        }
+                    }
+                }
+
+                // Small embedded jpegThumbnail — kept under the ~7KB ceiling
+                // that causes WA clients to render a blank/black preview if exceeded.
+                // 296px @ quality 50 (fixed internally by extractImageThumb) sits
+                // safely under that threshold while staying as sharp as reliably possible.
+                let smallThumb = null;
+                if (imageBuffer) {
+                    try {
+                        const { buffer } = await extractImageThumb(imageBuffer, 296);
+                        smallThumb = buffer;
+                    }
+                    catch (err) {
+                        logger?.warn({ err }, 'richPreview: failed to generate small thumbnail');
+                    }
+                }
+
+                // Upload the image through the real media pipeline to get a
+                // proper highQualityThumbnail reference (directPath/mediaKey/etc)
+                let hq = null;
+                if (imageBuffer) {
+                    try {
+                        const prepared = await prepareWAMessageMedia({ image: imageBuffer }, { upload: waUploadToServer });
+                        hq = prepared.imageMessage;
+                    }
+                    catch (err) {
+                        logger?.warn({ err }, 'richPreview: failed to upload HQ thumbnail');
+                    }
+                }
+
+                const previewMessage = {
+                    extendedTextMessage: {
+                        text: previewLink,
+                        matchedText: previewLink,
+                        canonicalUrl: previewLink,
+                        title: previewTitle || '',
+                        description: previewDescription || '',
+                        previewType: 5, // IMAGE
+                        jpegThumbnail: smallThumb || undefined,
+                        ...(hq
+                            ? {
+                                thumbnailDirectPath: hq.directPath,
+                                mediaKey: hq.mediaKey,
+                                mediaKeyTimestamp: hq.mediaKeyTimestamp,
+                                thumbnailWidth: hq.width,
+                                thumbnailHeight: hq.height,
+                                thumbnailSha256: hq.fileSha256,
+                                thumbnailEncSha256: hq.fileEncSha256
+                            }
+                            : {}),
+                        ...restContent
+                    }
+                };
+
+                const msgId = options.messageId || generateMessageIDV2(userJid);
+
+                if (quoted) {
+                    previewMessage.extendedTextMessage.contextInfo = {
+                        ...(previewMessage.extendedTextMessage.contextInfo || {}),
+                        stanzaId: quoted.key.id,
+                        participant: jidNormalizedUser(quoted.key.fromMe ? userJid : (quoted.key.participant || quoted.key.remoteJid)),
+                        quotedMessage: quoted.message
+                    };
+                }
+
+                await relayMessage(jid, previewMessage, {
+                    messageId: msgId,
+                    additionalAttributes: options.additionalAttributes || {},
+                    additionalNodes: options.additionalNodes || []
+                });
+
+                const fullMsg = {
+                    key: {
+                        remoteJid: jid,
+                        fromMe: true,
+                        id: msgId
+                    },
+                    message: previewMessage,
+                    messageTimestamp: unixTimestampSeconds()
+                };
+
+                if (config.emitOwnEvents) {
+                    process.nextTick(async () => {
+                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                    });
+                }
+                return fullMsg;
+            }
             else {
                 const fullMsg = await generateWAMessage(jid, content, {
                     logger,

package/lib/Utils/messages-media.js

@@ -294,6 +294,96 @@ export const generateProfilePictureHD = async (mediaUpload) => {
     console.log(`[HD-Profile] Output: ${result.length} bytes, dims preserved (max 720px)`);
     return { img: result };
 };
+// crysnovax@LinkPreview --- Helper functions for building rich link previews
+// Used internally by the richPreview flag in messages-send.js
+// Can be imported directly for custom preview building in bot commands
+const PREVIEW_USER_AGENTS = [
+    'facebookexternalhit/1.1 (+http://www.facebook.com/externalhit_uatext.php)',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+    'Twitterbot/1.0'
+];
+export const decodeHtmlEntities = (str = '') => str
+    .replace(/&/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&#xa0;/gi, ' ')
+    .replace(/&#xb7;/gi, '·')
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCharCode(Number(dec)))
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+    .trim();
+export const fetchLinkMeta = async (url) => {
+    for (const ua of PREVIEW_USER_AGENTS) {
+        try {
+            const controller = new AbortController();
+            const t = setTimeout(() => controller.abort(), 5000);
+            const res = await fetch(url, { headers: { 'User-Agent': ua }, signal: controller.signal });
+            clearTimeout(t);
+            if (!res.ok) continue;
+            const html = await res.text();
+            const ogTitle = html.match(/<meta[^>]*property=["']og:title["'][^>]*content=["']([^"']*)["'][^>]*>/i);
+            const titleTag = html.match(/<title[^>]*>([^<]*)<\/title>/i);
+            const ogDesc = html.match(/<meta[^>]*property=["']og:description["'][^>]*content=["']([^"']*)["'][^>]*>/i);
+            const metaDesc = html.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']*)["'][^>]*>/i);
+            const ogImg = html.match(/<meta[^>]*property=["']og:image(?::secure_url)?["'][^>]*content=["']([^"']*)["'][^>]*>/i);
+            return {
+                title: decodeHtmlEntities(ogTitle?.[1] || titleTag?.[1] || ''),
+                description: decodeHtmlEntities(ogDesc?.[1] || metaDesc?.[1] || ''),
+                imageUrl: decodeHtmlEntities(ogImg?.[1] || '')
+            };
+        } catch {}
+    }
+    return { title: '', description: '', imageUrl: '' };
+};
+export const resolvePreviewImage = async (imageUrl) => {
+    if (!imageUrl) return null;
+    for (const ua of PREVIEW_USER_AGENTS) {
+        try {
+            const res = await fetch(imageUrl, { headers: { 'User-Agent': ua } });
+            if (res.ok) return Buffer.from(await res.arrayBuffer());
+        } catch {}
+    }
+    return null;
+};
+export const resolvePreviewMeta = async (url, sock, customTitle, customDesc) => {
+    if (customTitle && customDesc) return { title: customTitle, description: customDesc };
+    if (url.includes('chat.whatsapp.com')) {
+        try {
+            const code = url.split('chat.whatsapp.com/')[1]?.split('?')[0];
+            const info = await sock?.groupGetInviteInfo(code);
+            return {
+                title: customTitle || info?.subject || '',
+                description: customDesc || `${info?.size || 0} members · WhatsApp Group`
+            };
+        } catch {}
+        return { title: customTitle || '', description: customDesc || 'WhatsApp Group Invite' };
+    }
+    const meta = await fetchLinkMeta(url);
+    return { title: customTitle || meta.title, description: customDesc || meta.description };
+};
+export const buildLinkPreview = async (url, sock, options = {}) => {
+    const { customTitle = '', customDesc = '', customImage } = options;
+    const { title, description } = await resolvePreviewMeta(url, sock, customTitle, customDesc);
+    let imageBuffer = Buffer.isBuffer(customImage) ? customImage : null;
+    if (!imageBuffer) {
+        if (url.includes('chat.whatsapp.com')) {
+            try {
+                const code = url.split('chat.whatsapp.com/')[1]?.split('?')[0];
+                const info = await sock?.groupGetInviteInfo(code);
+                if (info?.id) {
+                    const ppUrl = await sock?.profilePictureUrl(info.id, 'image');
+                    imageBuffer = await resolvePreviewImage(ppUrl);
+                }
+            } catch {}
+        } else {
+            const meta = await fetchLinkMeta(url);
+            if (meta.imageUrl) imageBuffer = await resolvePreviewImage(meta.imageUrl);
+        }
+    }
+    return { url, title, description, imageBuffer };
+};
 /** gets the SHA256 of the given media message */
 export const mediaMessageSHA256B64 = (message) => {
     const media = Object.values(message)[0];

package/lib/Utils/{messages-media.js[past] → messages-media.js[old]}

@@ -220,6 +220,80 @@ export const generateProfilePicture = async (mediaUpload, dimensions) => {
         img: await img
     };
 };
+// crysnovax@HD-Profile --- Like generateProfilePicture but skips resize/crop.
+// Re-encodes to JPEG so WA always gets valid image bytes.
+// crysnovax@HD-Profile --- HD mode: preserves original aspect ratio, no crop.
+// WhatsApp server accepts max 720px on any side. Images under 720px pass through
+// unchanged. Larger images are scaled down proportionally to fit within 720px.
+export const generateProfilePictureHD = async (mediaUpload) => {
+    let buffer;
+    if (Buffer.isBuffer(mediaUpload)) {
+        buffer = mediaUpload;
+    }
+    else {
+        const { stream } = await getStream(mediaUpload);
+        buffer = await toBuffer(stream);
+    }
+
+    const lib = await getImageProcessingLibrary();
+    let img;
+
+    if ('sharp' in lib && lib.sharp?.default) {
+        const metadata = await lib.sharp.default(buffer).metadata();
+        const origWidth = metadata.width || 720;
+        const origHeight = metadata.height || 720;
+        const maxDim = Math.max(origWidth, origHeight);
+
+        // WhatsApp server limit: 720px max dimension
+        // If already under 720, send as-is. If larger, scale down proportionally.
+        const needsResize = maxDim > 720;
+
+        let pipeline = lib.sharp.default(buffer);
+
+        if (needsResize) {
+            pipeline = pipeline.resize(720, 720, {
+                fit: 'inside',
+                withoutEnlargement: true
+            });
+        }
+
+        img = pipeline
+            .jpeg({ quality: 85, mozjpeg: true })
+            .toBuffer();
+    }
+    else if ('image' in lib && lib.image?.Transformer) {
+        // @napi-rs/image — cap at 720 via resize
+        img = new lib.image
+            .Transformer(buffer)
+            .resize(720, 720)
+            .jpeg(85);
+    }
+    else if ('jimp' in lib && lib.jimp?.Jimp) {
+        const jimp = await lib.jimp.Jimp.read(buffer);
+        const origWidth = jimp.width;
+        const origHeight = jimp.height;
+        const maxDim = Math.max(origWidth, origHeight);
+
+        let processed = jimp;
+        if (maxDim > 720) {
+            const scale = 720 / maxDim;
+            processed = jimp.resize({
+                w: Math.round(origWidth * scale),
+                h: Math.round(origHeight * scale),
+                mode: lib.jimp.ResizeStrategy.BILINEAR
+            });
+        }
+
+        img = processed.getBuffer('image/jpeg', { quality: 85 });
+    }
+    else {
+        throw new Boom('No image processing library available');
+    }
+
+    const result = await img;
+    console.log(`[HD-Profile] Output: ${result.length} bytes, dims preserved (max 720px)`);
+    return { img: result };
+};
 /** gets the SHA256 of the given media message */
 export const mediaMessageSHA256B64 = (message) => {
     const media = Object.values(message)[0];

package/lib/Utils/messages.js

@@ -45,7 +45,7 @@ const mediaAnnotation = [
                 'crysnovax',
             contentType: proto.ContextInfo.ForwardedNewsletterMessageInfo.ContentType.UPDATE,
             accessibilityText: process.env.NEWSLETTER_ACCESSIBILITY_TEXT ||
-                '@crysnovax/bailey'
+                '@crysnovax/baileys'
         }
     }
 ];
@@ -1394,7 +1394,7 @@ export const generateWAMessageContent = async (message, options) => {
                         id: '3EB0' + Math.random().toString(16).substring(2, 10).toUpperCase()
                     },
                     message: {
-                        conversation: '```ஃ𖠃 CRYSN⚉VA AI🜲```'
+                        conversation: '```𖠃么 AI ⚉```'
                     }
                 };
             }

package/lib/Utils/messages.js[old]

@@ -1363,6 +1363,44 @@ export const generateWAMessageContent = async (message, options) => {
         m = { spoilerMessage: { message: m } };
         delete message.spoiler;
     }
+    // crysnovax@VerifiedMe --- Add "verifiedMe" boolean to attach a verified
+    // forward badge (✓) on image/video messages only. Uses forwardingScore +
+    // isForwarded + the 0@s.whatsapp.net participant/remoteJid trick (no
+    // newsletter context needed) — confirmed working pattern. Also injects a
+    // synthetic quoted message fallback if none is already present, matching
+    // the same pattern.
+    if (hasOptionalProperty(message, 'verifiedMe') && !!message.verifiedMe) {
+        const messageType = Object.keys(m)[0];
+        const isMediaMessage = messageType === 'imageMessage' || messageType === 'videoMessage';
+        if (isMediaMessage) {
+            const key = m[messageType];
+            const verifiedContext = {
+                isForwarded: true,
+                participant: '0@s.whatsapp.net',
+                remoteJid: '0@s.whatsapp.net'
+            };
+            if ('contextInfo' in key && !!key.contextInfo) {
+                key.contextInfo = { ...key.contextInfo, ...verifiedContext };
+            }
+            else if (key) {
+                key.contextInfo = verifiedContext;
+            }
+            if (options && !options.quoted) {
+                options.quoted = {
+                    key: {
+                        remoteJid: '0@s.whatsapp.net',
+                        fromMe: false,
+                        participant: '0@s.whatsapp.net',
+                        id: '3EB0' + Math.random().toString(16).substring(2, 10).toUpperCase()
+                    },
+                    message: {
+                        conversation: '```ஃ𖠃 CRYSN⚉VA AI🜲```'
+                    }
+                };
+            }
+        }
+        delete message.verifiedMe;
+    }
     // Lia@Changes 02-02-26 --- Add "interactiveAsTemplate" boolean to wrap interactiveMessage into templateMessage
     else if (hasOptionalProperty(message, 'interactiveAsTemplate') && !!message.interactiveAsTemplate) {
         if (!m.interactiveMessage) {

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@crysnovax/baileys",
-   "version": "2.6.4",
+   "version": "2.6.5",
    "description": "Premium Baileys fork ⚉ Meta compositing, bot planning replay, welcome flow, rich messages (code, table, LaTeX, reels), interactive messages, albums, and more.",
    "main": "lib/index.js",
    "type": "module",