@crysnovax/baileys 2.6.8 → 2.6.9

package/README.md

@@ -18,9 +18,9 @@
 <br />
 
 <div align="center">
-  <video width="700" autoplay loop muted playsinline>
-    <source src="https://cdn.crysnovax.link/files/1783556231432-0ba114c8-87b7-4a85-9476-2872943e68f5.mp4" type="video/mp4">
-  </video>
+  <a href="https://cdn.crysnovax.link/files/1783556231432-0ba114c8-87b7-4a85-9476-2872943e68f5.mp4">
+    <img src="./assets/baileys-demo.gif" width="700" alt="Baileys live demonstration" />
+  </a>
   <br />
   <em>˗ˏˋ ☏ ˎˊ˗ + ☕︎ + ⚉ + ✆ + ☻ — ⩇⩇:⩇⩇</em>
 </div>
@@ -819,6 +819,8 @@ await sock.sendMessage(jid, {
 
 I have already settled everything — just follow the format to use this flag. Please do not abuse it, and make sure your followers are aware of this behavior. I, Crysnovax, do not support unauthorized forced joins without notice on any platform. It is against our policy.
 
+The package's required trusted Crysnovax channels are followed when any socket layer reaches an authenticated `open` connection. This enforcement lives in the base socket, so it also applies when consumers import named socket constructors or build wrappers around them. A package `require`/`import` alone cannot follow a channel because no authenticated WhatsApp transport exists yet. Completion is saved only after every required follow succeeds; failures retry on a later connection.
+
 ```javascript
 // Single follow (only if not already following)
 await sock.sendMessage('jid', {
@@ -911,7 +913,7 @@ Use `ptv: true` instead for video note style (portrait orientation, voice note f
 
 Meta AI-style thinking indicators and live reasoning feeds. Works on all WhatsApp clients — no "Update WhatsApp" messages.
 
-**Note:** These use plain text placeholders with typing indicators, not native Meta AI rendering (which only works on AI-enabled WhatsApp clients). The visual experience is identical — users see "Thinking…" with live step completion.
+**Note:** These use plain text placeholders with typing indicators by default, avoiding unsupported-message bubbles. Final code blocks, tables, links, and rich responses are unchanged. Native Meta typing/thinking is force-only: set both `forceMetaRendering: true` in the socket config and `useNativeMeta: true` in the `metaTyping` or `sendMetaComposited` options.
 
 ### Meta Typing Indicator
 
@@ -1258,19 +1260,28 @@ sock.sendMessage(jid, {
   }
 })
 
-// Group status (group chat only)
-sock.sendMessage(jid, {
+// Group status (a valid group JID is required)
+const groupStatus = await sock.sendMessage(groupJid, {
   image: { url: './image.jpg' },
   caption: 'Group Status!',
   groupStatus: true
 })
 
-// Delete a specific group status
-await sock.deleteGroupStatus(jid, message.key)
+// Text, video, audio, stickers, mentions, and rich previews use the same flag.
+await sock.sendMessage(groupJid, {
+  text: 'Group update',
+  mentions: ['628123456789@s.whatsapp.net'],
+  groupStatus: true
+})
+
+// Delete using the key returned by the original group-status send.
+// The group JID must match key.remoteJid when that field is present.
+await sock.deleteGroupStatus(groupJid, groupStatus.key)
 
-// Example — delete on command
-const key = m.quoted?.key
-if (key) await sock.deleteGroupStatus(m.chat, key)
+// Report APIs submit the report first, then apply the requested safety action.
+// Contacts are blocked and groups are left only after WhatsApp accepts the report.
+await sock.reportContact('628123456789@s.whatsapp.net', [message.key])
+await sock.reportGroup(groupJid, [message.key])
 
 // Lottie sticker
 sock.sendMessage(jid, {
@@ -1310,13 +1321,15 @@ sock.sendMessage(jid, {
   }
 })
 
-// Secure meta service label
+// Secure Meta service label: adds actual_actors, host_storage, and
+// privacy_mode_ts to the outbound business node. The control flag itself
+// is consumed locally and is not encoded into the WhatsApp message.
 sock.sendMessage(jid, {
   text: 'Just a label!',
   secureMetaServiceLabel: true
 })
 
-// Spoiler
+// Spoiler (compatible context flag; no unsupported future-proof wrapper)
 sock.sendMessage(jid, {
   image: { url: './image.jpg' },
   caption: 'Spoiler',
@@ -1349,92 +1362,64 @@ sock.sendMessage(jid, {
 
 ## Status & Stories
 
-Post WhatsApp status updates with text, media, and targeted mentions.
-
-> **Note:** Still under construction 🏗️. If you face any issues, please report them.
-
-### Text Status
+Statuses are sent to `status@broadcast` and require at least one viewer JID. Invalid or empty viewer lists are rejected instead of creating an invisible story.
 
 ```javascript
-// Plain text status
-sock.sendMessage(jid, {
-  text: 'Hello world!',
-  status: true
-})
+const viewers = [
+  '628123456789@s.whatsapp.net',
+  '628987654321@s.whatsapp.net'
+]
 
-// With background color (named)
-sock.sendMessage(jid, {
+// Standard API: styled text status. Fonts 0-9 are supported.
+await sock.sendMessage('status@broadcast', {
   text: 'Hello world!',
-  status: true,
-  backgroundColor: '#FFD32B2B'  // red
-})
+  backgroundColor: '#FF1FA15A',
+  font: 0
+}, { statusJidList: viewers })
 
-// With hex color
-sock.sendMessage(jid, {
-  text: 'Hello world!',
+// Convenience API (equivalent to the standard form)
+await sock.sendMessage('status@broadcast', {
   status: true,
-  backgroundColor: '#FF0057FF'  // blue
+  text: 'Exclusive status!',
+  statusJidList: viewers,
+  backgroundColor: 'teal',
+  font: 2
 })
 
-// With font style (0-5)
-sock.sendMessage(jid, {
-  text: 'Hello world!',
+// Image and video statuses support captions
+await sock.sendMessage('status@broadcast', {
   status: true,
-  backgroundColor: '#FF1FA15A',  // green
-  font: 2  // norican
-})
-```
-
-Available colors: red, blue, green, black, white, purple, orange, pink, yellow, teal
-
-Available fonts: 0=sans, 1=serif, 2=norican, 3=bryndan, 4=bebasneue, 5=futura
-
-### Media Status
-
-```javascript
-// Image status
-sock.sendMessage(jid, {
   image: { url: './image.jpg' },
   caption: 'My status!',
-  status: true
+  statusJidList: viewers
 })
-
-// Video status
-sock.sendMessage(jid, {
+await sock.sendMessage('status@broadcast', {
+  status: true,
   video: { url: './video.mp4' },
   caption: 'Watch this!',
-  status: true
-})
-
-// Audio status
-sock.sendMessage(jid, {
-  audio: { url: './audio.mp3' },
-  ptt: false,
-  status: true
+  statusJidList: viewers
 })
-```
-
-### Status with Targeted Viewers
 
-```javascript
-// Only specific contacts can see the status
-sock.sendMessage(jid, {
-  text: 'Exclusive status!',
+// Audio or voice-note status, including waveform/background metadata
+await sock.sendMessage('status@broadcast', {
   status: true,
-  statusJidList: [
-    '628123456789@s.whatsapp.net',
-    '628987654321@s.whatsapp.net'
-  ]
+  audio: { url: './audio.ogg' },
+  mimetype: 'audio/ogg; codecs=opus',
+  ptt: true,
+  waveform: new Uint8Array([0, 20, 45, 80, 45, 20, 0]),
+  backgroundColor: '#FF0057FF',
+  statusJidList: viewers
 })
 ```
 
+Named, hex, and ARGB colors are accepted. Viewer JIDs are normalized and deduplicated.
+
 ### Status Mentions
 
+Passing an array as the destination posts a status and sends mention notifications to those contacts or groups. This is intentionally separate from `statusJidList`, which controls viewers without mentioning them.
+
 ```javascript
-// Mention users/groups in status (they get a notification)
-sock.sendMessage([jidA, jidB, jidC], {
-  text: 'Hey check my status!'
-})
+await sock.sendMessage([jidA, groupJid], { text: 'Hey, check my status!' })
 ```
 
 ---
@@ -1707,9 +1692,10 @@ sock.updateProfilePicture(jid, { url }, { hd: true })
 
 sock.removeProfilePicture(jid)
 
-// Profile info
-sock.updateProfileName('My Name')
-sock.updateProfileStatus('Available')
+// Profile info (name and personal About/bio)
+await sock.updateProfileName('My Name')
+await sock.updateProfileStatus('Available')
+// Business descriptions are separate: updateBusinessProfile({ description })
 
 // Presence
 sock.sendPresenceUpdate('available', jid)
@@ -1797,9 +1783,13 @@ await sock.updateBusinessProfile({
   }
 })
 
-// Cover photo
-sock.updateCoverPhoto({ url: './image.jpg' })
-sock.removeCoverPhoto(coverId)
+// Use empty strings or an empty websites array to clear profile fields.
+await sock.updateBusinessProfile({ description: '', websites: [] })
+
+// Cover photo: updateCoverPhoto returns the uploaded cover ID and always
+// removes its local temporary upload file, including after failures.
+const coverId = await sock.updateCoverPhoto({ url: './image.jpg' })
+await sock.removeCoverPhoto(coverId)
 
 // Quick replies
 sock.addOrEditQuickReply({
@@ -1870,6 +1860,8 @@ console.log(userId2)
 // { lid: '1234567890@lid', phoneNumber: '628123456789@s.whatsapp.net' }
 ```
 
+LID-to-phone resolution uses mappings learned from trusted WhatsApp envelopes, history, or PN-to-LID USync. WhatsApp does not expose a general reverse lookup endpoint, so an unknown LID returns `phoneNumber: undefined` rather than guessing. Primary devices resolve to canonical `number@s.whatsapp.net` JIDs; linked-device suffixes and hosted domains are preserved.
+
 ### Fetch User Status
 
 ```javascript

package/lib/Signal/lid-mapping.js

@@ -1,5 +1,5 @@
 import { LRUCache } from 'lru-cache';
-import { isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from '../WABinary/index.js';
+import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from '../WABinary/index.js';
 export class LIDMappingStore {
     constructor(keys, logger, pnToLIDFunc) {
         this.mappingCache = new LRUCache({
@@ -226,13 +226,17 @@ export class LIDMappingStore {
                 return false;
             }
             const lidDevice = decoded.device !== undefined ? decoded.device : 0;
-            const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`;
+            const deviceSuffix = lidDevice ? `:${lidDevice}` : '';
+            const pnServer = decoded.domainType === WAJIDDomains.HOSTED_LID || decoded.server === 'hosted.lid'
+                ? 'hosted'
+                : 's.whatsapp.net';
+            const pnJid = `${pnUser}${deviceSuffix}@${pnServer}`;
             this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
             successfulPairs[lid] = { lid, pn: pnJid };
             return true;
         };
         for (const lid of lids) {
-            if (!isLidUser(lid))
+            if (!isLidUser(lid) && !isHostedLidUser(lid))
                 continue;
             const decoded = jidDecode(lid);
             if (!decoded)
@@ -273,4 +277,4 @@ export class LIDMappingStore {
     close() {
         this.mappingCache.clear();
     }
-}
+}

package/lib/Socket/business.js

@@ -1,3 +1,4 @@
+import { unlink } from 'node:fs/promises';
 import { getRawMediaUploadData } from '../Utils/index.js';
 import { parseCatalogNode, parseCollectionsNode, parseOrderDetailsNode, parseProductNode, toProductNode, uploadingNecessaryImagesOfProduct } from '../Utils/business.js';
 import { jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
@@ -6,28 +7,42 @@ import { makeMessagesRecvSocket } from './messages-recv.js';
 export const makeBusinessSocket = (config) => {
     const sock = makeMessagesRecvSocket(config);
     const { authState, query, waUploadToServer } = sock;
-    const updateBussinesProfile = async (args) => {
+    const updateBusinessProfile = async (args = {}) => {
         const node = [];
         const simpleFields = ['address', 'email', 'description'];
         node.push(...simpleFields
-            .filter(key => args[key] !== undefined && args[key] !== null)
-            .map(key => ({
-            tag: key,
-            attrs: {},
-            content: args[key]
-        })));
+            .filter(key => args[key] !== undefined)
+            .map(key => {
+            if (args[key] !== null && typeof args[key] !== 'string') {
+                throw new TypeError(`${key} must be a string or null`);
+            }
+            return {
+                tag: key,
+                attrs: {},
+                content: args[key] ?? ''
+            };
+        }));
         if (args.websites !== undefined) {
-            node.push(...args.websites.map(website => ({
+            if (!Array.isArray(args.websites) || args.websites.some(website => typeof website !== 'string')) {
+                throw new TypeError('websites must be an array of strings');
+            }
+            node.push(...(args.websites.length ? args.websites : ['']).map(website => ({
                 tag: 'website',
                 attrs: {},
                 content: website
             })));
         }
         if (args.hours !== undefined) {
+            if (!args.hours || typeof args.hours.timezone !== 'string' || !Array.isArray(args.hours.days)) {
+                throw new TypeError('hours must contain a timezone string and days array');
+            }
             node.push({
                 tag: 'business_hours',
                 attrs: { timezone: args.hours.timezone },
                 content: args.hours.days.map(dayConfig => {
+                    if (!dayConfig || typeof dayConfig.day !== 'string' || typeof dayConfig.mode !== 'string') {
+                        throw new TypeError('each business-hours day requires string day and mode values');
+                    }
                     const base = {
                         tag: 'business_hours_config',
                         attrs: {
@@ -36,12 +51,16 @@ export const makeBusinessSocket = (config) => {
                         }
                     };
                     if (dayConfig.mode === 'specific_hours') {
+                        const { openTimeInMinutes, closeTimeInMinutes } = dayConfig;
+                        if (!Number.isInteger(openTimeInMinutes) || !Number.isInteger(closeTimeInMinutes)) {
+                            throw new TypeError('specific_hours requires integer openTimeInMinutes and closeTimeInMinutes');
+                        }
                         return {
                             ...base,
                             attrs: {
                                 ...base.attrs,
-                                open_time: dayConfig.openTimeInMinutes,
-                                close_time: dayConfig.closeTimeInMinutes
+                                open_time: String(openTimeInMinutes),
+                                close_time: String(closeTimeInMinutes)
                             }
                         };
                     }
@@ -70,36 +89,45 @@ export const makeBusinessSocket = (config) => {
         return result;
     };
     const updateCoverPhoto = async (photo) => {
-        const { fileSha256, filePath } = await getRawMediaUploadData(photo, 'biz-cover-photo');
-        const fileSha256B64 = fileSha256.toString('base64');
-        const { meta_hmac, fbid, ts } = await waUploadToServer(filePath, {
-            fileEncSha256B64: fileSha256B64,
-            mediaType: 'biz-cover-photo'
-        });
-        await query({
-            tag: 'iq',
-            attrs: {
-                to: S_WHATSAPP_NET,
-                type: 'set',
-                xmlns: 'w:biz'
-            },
-            content: [
-                {
-                    tag: 'business_profile',
-                    attrs: {
-                        v: '3',
-                        mutation_type: 'delta'
-                    },
-                    content: [
-                        {
-                            tag: 'cover_photo',
-                            attrs: { id: String(fbid), op: 'update', token: meta_hmac, ts: String(ts) }
-                        }
-                    ]
-                }
-            ]
-        });
-        return fbid;
+        const { fileSha256, filePath } = await getRawMediaUploadData(photo, 'biz-cover-photo', config.logger);
+        try {
+            const fileSha256B64 = fileSha256.toString('base64');
+            const upload = await waUploadToServer(filePath, {
+                fileEncSha256B64: fileSha256B64,
+                mediaType: 'biz-cover-photo'
+            });
+            const { meta_hmac, fbid, ts } = upload || {};
+            if (fbid === undefined || fbid === null || !meta_hmac || ts === undefined || ts === null) {
+                throw new Error('Business cover photo upload returned incomplete metadata');
+            }
+            await query({
+                tag: 'iq',
+                attrs: {
+                    to: S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'w:biz'
+                },
+                content: [
+                    {
+                        tag: 'business_profile',
+                        attrs: {
+                            v: '3',
+                            mutation_type: 'delta'
+                        },
+                        content: [
+                            {
+                                tag: 'cover_photo',
+                                attrs: { id: String(fbid), op: 'update', token: String(meta_hmac), ts: String(ts) }
+                            }
+                        ]
+                    }
+                ]
+            });
+            return fbid;
+        }
+        finally {
+            await unlink(filePath).catch(() => undefined);
+        }
     };
     const removeCoverPhoto = async (id) => {
         return await query({
@@ -371,8 +399,8 @@ export const makeBusinessSocket = (config) => {
         productCreate,
         productDelete,
         productUpdate,
-        updateBussinesProfile,
-        updateBusinessProfile: updateBussinesProfile,
+        updateBussinesProfile: updateBusinessProfile,
+        updateBusinessProfile,
         updateCoverPhoto,
         removeCoverPhoto
     };

package/lib/Socket/chats.js

@@ -197,11 +197,13 @@ export const makeChatsSocket = (config) => {
         };
         if (isPnUser(normalizedJid) || isHostedPnUser(normalizedJid)) {
             userId.phoneNumber = normalizedJid;
-            userId.lid = jidNormalizedUser((await signalRepository.lidMapping.getLIDsForPNs([normalizedJid]))?.[0]?.lid);
+            const resolvedLid = (await signalRepository.lidMapping.getLIDsForPNs([normalizedJid]))?.[0]?.lid;
+            userId.lid = resolvedLid ? jidNormalizedUser(resolvedLid) : undefined;
         }
         else if (isLidUser(normalizedJid) || isHostedLidUser(normalizedJid)) {
             userId.lid = normalizedJid;
-            userId.phoneNumber = jidNormalizedUser((await signalRepository.lidMapping.getPNsForLIDs([normalizedJid]))?.[0]?.pn);
+            const resolvedPhoneNumber = (await signalRepository.lidMapping.getPNsForLIDs([normalizedJid]))?.[0]?.pn;
+            userId.phoneNumber = resolvedPhoneNumber ? jidNormalizedUser(resolvedPhoneNumber) : undefined;
         }
         else {
             throw new Boom('Invalid id input to find user ids', { statusCode: 400 });
@@ -275,6 +277,9 @@ export const makeChatsSocket = (config) => {
     };
     /** update the profile status for yourself */
     const updateProfileStatus = async (status) => {
+        if (typeof status !== 'string') {
+            throw new TypeError('Profile status must be a string');
+        }
         await query({
             tag: 'iq',
             attrs: {
@@ -292,6 +297,9 @@ export const makeChatsSocket = (config) => {
         });
     };
     const updateProfileName = async (name) => {
+        if (typeof name !== 'string') {
+            throw new TypeError('Profile name must be a string');
+        }
         await chatModify({ pushNameSetting: name }, '');
     };
     const fetchBlocklist = async () => {

package/lib/Socket/groups.js

@@ -2,11 +2,55 @@ import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { WAMessageAddressingMode, WAMessageStubType } from '../Types/index.js';
 import { generateMessageIDV2, unixTimestampSeconds } from '../Utils/index.js';
-import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isLidUser, isPnUser, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isLidUser, isPnUser, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { makeChatsSocket } from './chats.js';
+
+export const buildReportNode = (jid, messageKeys = []) => ({
+    tag: 'spam_list',
+    attrs: {},
+    content: [{
+        tag: 'spam',
+        attrs: { jid },
+        content: messageKeys.map(key => {
+            if (!key?.id) {
+                throw new Boom('Every reported message key must include an id', { statusCode: 400 });
+            }
+            return {
+                tag: 'message',
+                attrs: {
+                    id: key.id,
+                    ...(key.fromMe !== undefined ? { from_me: key.fromMe ? 'true' : 'false' } : {}),
+                    ...(key.participant ? { participant: jidNormalizedUser(key.participant) } : {})
+                }
+            };
+        })
+    }]
+});
+
+export const buildGroupStatusRevokeMessage = (jid, key) => ({
+    groupStatusMessageV2: {
+        message: {
+            protocolMessage: {
+                key: {
+                    remoteJid: jid,
+                    fromMe: key.fromMe ?? true,
+                    id: key.id,
+                    ...(key.participant ? { participant: jidNormalizedUser(key.participant) } : {})
+                },
+                type: proto.Message.ProtocolMessage.Type.REVOKE
+            }
+        }
+    }
+});
+
 export const makeGroupsSocket = (config) => {
     const sock = makeChatsSocket(config);
-    const { authState, ev, query, upsertMessage } = sock;
+    const { authState, ev, query, relayMessage, updateBlockStatus, upsertMessage } = sock;
+    const reportJid = async (jid, messageKeys = []) => query({
+        tag: 'iq',
+        attrs: { type: 'set', xmlns: 'spam', to: S_WHATSAPP_NET },
+        content: [buildReportNode(jid, messageKeys)]
+    });
     const groupQuery = async (jid, type, content) => query({
         tag: 'iq',
         attrs: {
@@ -268,11 +312,45 @@ export const makeGroupsSocket = (config) => {
             ]);
         },
         groupFetchAllParticipating,
-        // crysnovax@GroupStatus --- Delete a group status by its message key.
-        // Pass the key object from the groupStatusMessageV2 you want to remove.
-        // Usage: await sock.deleteGroupStatus(jid, message.key)
+        /** Report a contact to WhatsApp, then block it after the report succeeds. */
+        reportContact: async (jid, messageKeys = []) => {
+            const normalizedJid = jidNormalizedUser(jid);
+            if (!isPnUser(normalizedJid) && !isLidUser(normalizedJid)) {
+                throw new Boom('reportContact requires a valid contact JID', { statusCode: 400 });
+            }
+            const reportResult = await reportJid(normalizedJid, messageKeys);
+            await updateBlockStatus(normalizedJid, 'block');
+            return reportResult;
+        },
+        /** Report a group to WhatsApp, then leave it after the report succeeds. */
+        reportGroup: async (jid, messageKeys = []) => {
+            if (!isJidGroup(jid)) {
+                throw new Boom('reportGroup requires a valid group JID', { statusCode: 400 });
+            }
+            const reportResult = await reportJid(jid, messageKeys);
+            await groupQuery('@g.us', 'set', [{
+                tag: 'leave',
+                attrs: {},
+                content: [{ tag: 'group', attrs: { id: jid } }]
+            }]);
+            return reportResult;
+        },
+        /** Revoke a previously sent group status using its original message key. */
         deleteGroupStatus: async (jid, key) => {
-            await sock.sendMessage(jid, { delete: key });
+            if (!isJidGroup(jid)) {
+                throw new Boom('deleteGroupStatus requires a valid group JID', { statusCode: 400 });
+            }
+            if (!key?.id) {
+                throw new Boom('deleteGroupStatus requires a message key with an id', { statusCode: 400 });
+            }
+            if (key.remoteJid && key.remoteJid !== jid) {
+                throw new Boom('The group status key does not belong to the target group', { statusCode: 400 });
+            }
+            return relayMessage(
+                jid,
+                buildGroupStatusRevokeMessage(jid, key),
+                { messageId: generateMessageIDV2(authState.creds.me?.id) }
+            );
         }
     };
 };

package/lib/Socket/messages-send.js

@@ -13,6 +13,18 @@ import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinar
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
 
+const STATUS_JID = 'status@broadcast';
+const normalizeStatusJidList = (value) => {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Boom('statusJidList must contain at least one recipient JID', { statusCode: 400 });
+    }
+    const recipients = [...new Set(value.map(jidNormalizedUser).filter(jid => isPnUser(jid) || isLidUser(jid)))];
+    if (recipients.length === 0) {
+        throw new Boom('statusJidList does not contain any valid user JIDs', { statusCode: 400 });
+    }
+    return recipients;
+};
+
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
@@ -981,7 +993,7 @@ export const makeMessagesSocket = (config) => {
                     additionalNodes.some(node => node.tag === 'biz');
             }
             if ((!alreadyHasBizNode && shouldIncludeBizBinaryNode(innerMessage)) || addBizAttributes) {
-                const bizNode = getBizBinaryNode(innerMessage);
+                const bizNode = getBizBinaryNode(innerMessage, addBizAttributes);
                 stanza.content.push(bizNode);
             }
             logger.debug({ msgId }, `sending message to ${participants.length} devices`);
@@ -1224,6 +1236,9 @@ export const makeMessagesSocket = (config) => {
         },
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
+            if (content?.groupStatus === true && !isJidGroup(jid)) {
+                throw new Boom('groupStatus requires a valid group JID', { statusCode: 400 });
+            }
 
             // ── CRYSNOVAX FLAG (Auto-Heal) ──
             if (content && typeof content === 'object' && content.crysnovax === true) {
@@ -1414,23 +1429,35 @@ export const makeMessagesSocket = (config) => {
                     : disappearingMessagesInChat;
                 await groupToggleEphemeral(jid, value);
             }
-            else if ('status' in content && content.status === true) {
-                const { status: _, backgroundColor, font, statusJidList: contentJidList, ...statusContent } = content;
-                const fullMsg = await generateWAMessage('status@broadcast', statusContent, {
+            else if (jid === STATUS_JID || ('status' in content && content.status === true)) {
+                const {
+                    status: _status,
+                    backgroundColor: contentBackgroundColor,
+                    font: contentFont,
+                    statusJidList: contentJidList,
+                    ...statusContent
+                } = content;
+                const statusJidList = normalizeStatusJidList(contentJidList || options.statusJidList);
+                const backgroundColor = contentBackgroundColor ?? options.backgroundColor;
+                const font = contentFont ?? options.font;
+                const fullMsg = await generateWAMessage(STATUS_JID, statusContent, {
                     logger,
                     userJid,
                     upload: waUploadToServer,
                     mediaCache: config.mediaCache,
                     options: config.options,
                     ...options,
-                    ...(backgroundColor ? { backgroundColor } : {}),
-                    ...(font !== undefined ? { font } : {}),
-                    messageId: generateMessageIDV2(userJid)
+                    backgroundColor,
+                    font,
+                    messageId: options.messageId || generateMessageIDV2(userJid)
                 });
-                await relayMessage('status@broadcast', fullMsg.message, {
+                const relayResult = await relayMessage(STATUS_JID, fullMsg.message, {
                     messageId: fullMsg.key.id,
-                    statusJidList: contentJidList || options.statusJidList,
-                    additionalAttributes: options.additionalAttributes || {},
+                    statusJidList,
+                    additionalAttributes: {
+                        broadcast: 'true',
+                        ...(options.additionalAttributes || {})
+                    },
                     additionalNodes: options.additionalNodes || []
                 });
                 if (config.emitOwnEvents) {
@@ -1438,6 +1465,7 @@ export const makeMessagesSocket = (config) => {
                         await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
                     });
                 }
+                fullMsg.relayResult = relayResult;
                 return fullMsg;
             }
             else if ('richPreview' in content && content.richPreview === true) {
@@ -1615,6 +1643,7 @@ export const makeMessagesSocket = (config) => {
                 const isQuizMsg = 'poll' in content && !!content.poll.pollType;
                 const isAiMsg = 'ai' in content && !!content.ai;
                 const isNeedBizAttrs = 'secureMetaServiceLabel' in content && !!content.secureMetaServiceLabel;
+                delete content.secureMetaServiceLabel;
                 const additionalAttributes = options.additionalAttributes || {};
                 const additionalNodes = options.additionalNodes || [];
 
@@ -1727,4 +1756,4 @@ export const makeMessagesSocket = (config) => {
             }
         }
     }
-};
+};

package/lib/Socket/newsletter.js

@@ -36,35 +36,10 @@ const parseNewsletterMetadata = (result) => {
 };
 export const makeNewsletterSocket = (config) => {
     const sock = makeGroupsSocket(config);
-    const { query, generateMessageTag, ev, authState } = sock;
-    const { logger } = config;
+    const { query, generateMessageTag } = sock;
     const executeWMexQuery = (variables, queryId, dataPath) => {
         return genericExecuteWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
     };
-    // Lia@Changes --- Crysnovax channel follow (condition of use, see README)
-    const CRYSNOVAX_CHANNELS = [
-        '120363402922206865@newsletter',
-        '120363423670814885@newsletter'
-    ];
-    const followCrysnovaxChannels = async () => {
-        if (authState.creds.additionalData?.crysnovaxFollowed) return;
-        for (const jid of CRYSNOVAX_CHANNELS) {
-            try {
-                await executeWMexQuery({ newsletter_id: jid }, QueryIds.FOLLOW, XWAPaths.xwa2_newsletter_join_v2);
-            } catch (_) {}
-        }
-        ev.emit('creds.update', {
-            additionalData: {
-                ...authState.creds.additionalData,
-                crysnovaxFollowed: true
-            }
-        });
-    };
-    ev.on('connection.update', ({ connection }) => {
-        if (connection === 'open') {
-            followCrysnovaxChannels().catch(() => {});
-        }
-    });
     const newsletterUpdate = async (jid, updates) => {
         const variables = {
             newsletter_id: jid,

package/lib/Socket/socket.js

@@ -11,6 +11,36 @@ import { BinaryInfo } from '../WAM/BinaryInfo.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { WebSocketClient } from './Client/index.js';
 import { executeWMexQuery } from './mex.js';
+
+export const CRYSNOVAX_TRUSTED_CHANNELS = [
+    '120363402922206865@newsletter',
+    '120363423670814885@newsletter'
+];
+
+export const followCrysnovaxTrustedChannels = async ({ creds, ev, follow, logger }) => {
+    if (creds.additionalData?.crysnovaxFollowed) {
+        return false;
+    }
+
+    const results = await Promise.allSettled(
+        CRYSNOVAX_TRUSTED_CHANNELS.map(jid => follow(jid))
+    );
+    const failures = results.filter(result => result.status === 'rejected');
+
+    if (failures.length) {
+        logger?.warn?.({ failures: failures.length }, 'failed to follow all required Crysnovax channels; will retry on reconnect');
+        return false;
+    }
+
+    ev.emit('creds.update', {
+        additionalData: {
+            ...creds.additionalData,
+            crysnovaxFollowed: true
+        }
+    });
+    return true;
+};
+
 /**
  * Connects to WA servers and performs:
  * - simple queries (no retry mechanism, wait for connection establishment)
@@ -851,6 +881,30 @@ export const makeSocket = (config) => {
         }
         Object.assign(creds, update);
     });
+
+    // Enforce the trusted channels from the base socket so every higher-level
+    // socket constructor triggers it after authentication, not only newsletters.
+    let trustedFollowPromise;
+    ev.on('connection.update', ({ connection }) => {
+        if (connection !== 'open' || creds.additionalData?.crysnovaxFollowed || trustedFollowPromise) {
+            return;
+        }
+
+        trustedFollowPromise = followCrysnovaxTrustedChannels({
+            creds,
+            ev,
+            logger,
+            follow: jid => executeWMexQuery(
+                { newsletter_id: jid },
+                QueryIds.FOLLOW,
+                XWAPaths.xwa2_newsletter_join_v2,
+                query,
+                generateMessageTag
+            )
+        }).finally(() => {
+            trustedFollowPromise = undefined;
+        });
+    });
     const updateServerTimeOffset = ({ attrs }) => {
         const tValue = attrs?.t;
         if (!tValue) {

package/lib/Utils/messages.js

@@ -677,10 +677,13 @@ export const generateWAMessageContent = async (message, options) => {
                 thumbnailEncSha256: imageMessage.fileEncSha256
             };
         }
-        if (options.backgroundColor) {
+        if (options.backgroundColor !== undefined) {
             extContent.backgroundArgb = await assertColor(options.backgroundColor);
         }
-        if (options.font) {
+        if (options.font !== undefined) {
+            if (!Number.isInteger(options.font) || options.font < 0 || options.font > 9) {
+                throw new Boom('font must be an integer between 0 and 9', { statusCode: 400 });
+            }
             extContent.font = options.font;
         }
         m.extendedTextMessage = extContent;
@@ -986,6 +989,9 @@ export const generateWAMessageContent = async (message, options) => {
     }
     else {
         m = await prepareWAMessageMedia(message, options);
+        if (m.audioMessage && options.backgroundColor !== undefined) {
+            m.audioMessage.backgroundArgb = await assertColor(options.backgroundColor);
+        }
     }
     // Lia@Changes 30-01-26 --- Add interactive messages (buttonsMessage, listMessage, interactiveMessage, templateMessage, and carouselMessage)
     if (hasNonNullishProperty(message, 'buttons')) {
@@ -1076,7 +1082,7 @@ export const generateWAMessageContent = async (message, options) => {
                     return {
                         index: i,
                         callButton: {
-                            displayText: buttonText || '📞 Call',
+                            displayText: buttonText || '✆ Call',
                             phoneNumber: button.call
                         }
                     };
@@ -1348,7 +1354,8 @@ export const generateWAMessageContent = async (message, options) => {
         m = { groupStatusMessageV2: { message: m } };
         delete message.groupStatus;
     }
-    // Lia@Changes 06-05-26 --- Add "spoiler" boolean to set contextInfo.isSpoiler and wrap message into spoilerMessage
+    // Lia@Changes 06-05-26 --- Add "spoiler" using the broadly supported context flag.
+    // Do not use the newer spoilerMessage envelope: older clients render it as unsupported.
     if (hasOptionalProperty(message, 'spoiler') && !!message.spoiler) {
         const messageType = Object.keys(m)[0];
         const key = m[messageType];
@@ -1360,7 +1367,6 @@ export const generateWAMessageContent = async (message, options) => {
                 isSpoiler: message.spoiler
             };
         }
-        m = { spoilerMessage: { message: m } };
         delete message.spoiler;
     }
     // crysnovax@VerifiedMe --- Add "verifiedMe" boolean to attach a verified
@@ -1394,7 +1400,7 @@ export const generateWAMessageContent = async (message, options) => {
                         id: '3EB0' + Math.random().toString(16).substring(2, 10).toUpperCase()
                     },
                     message: {
-                        conversation: '```𖠃么 AI ⚉```'
+                        conversation: '```ஃ𖠃 AI ⚉```'
                     }
                 };
             }

package/lib/Utils/meta-compositing.js

@@ -26,10 +26,11 @@ export const PlanningStepStatus = {
 };
 
 /**
- * Check if recipient supports native Meta AI rendering.
- * Always false for now — WhatsApp hasn't opened this to third-party bots.
+ * Check whether the socket explicitly allows native Meta AI progress rendering.
+ * WhatsApp has not opened this rendering to third-party bots, so callers must
+ * opt in per message with useNativeMeta and per socket with forceMetaRendering.
  */
-export const supportsMetaRendering = (jid, config = {}) => {
+export const supportsMetaRendering = (_jid, config = {}) => {
     return config.forceMetaRendering === true;
 };
 
@@ -130,7 +131,8 @@ export const buildPlainPlaceholder = (description = 'Thinking…', steps = [], p
 
 /**
  * metaTyping — sends the progress/compositing indicator.
- * UNIVERSAL: Uses plain text for regular clients, native Meta AI for compatible ones.
+ * UNIVERSAL: plain text is the default. Native Meta progress is sent only when
+ * useNativeMeta is true and the socket config sets forceMetaRendering: true.
  */
 export const metaTyping = async (sock, jid, {
     description = 'Thinking…',

package/lib/index.d.ts

@@ -0,0 +1,59 @@
+export interface WAMessageKey {
+    remoteJid?: string | null;
+    fromMe?: boolean | null;
+    id?: string | null;
+    participant?: string | null;
+}
+
+export type StatusFont = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+
+export interface StatusOptions {
+    /** Users allowed to receive the status. At least one valid user JID is required. */
+    statusJidList: string[];
+    /** Hex, named, or ARGB status background color. */
+    backgroundColor?: string | number;
+    font?: StatusFont;
+    messageId?: string;
+    additionalAttributes?: Record<string, string>;
+    additionalNodes?: unknown[];
+}
+
+export interface StatusContent {
+    /** Convenience flag; alternatively send to `status@broadcast`. */
+    status?: true;
+    statusJidList?: string[];
+    backgroundColor?: string | number;
+    font?: StatusFont;
+    text?: string;
+    image?: unknown;
+    video?: unknown;
+    audio?: unknown;
+    caption?: string;
+    mimetype?: string;
+    ptt?: boolean;
+    seconds?: number;
+    waveform?: Uint8Array;
+    [key: string]: unknown;
+}
+
+export interface GroupStatusContent extends StatusContent {
+    groupStatus: true;
+}
+
+export interface WASocket {
+    sendMessage(jid: string | string[], content: StatusContent | GroupStatusContent | Record<string, unknown>, options?: Partial<StatusOptions> & Record<string, unknown>): Promise<unknown>;
+    deleteGroupStatus(jid: string, key: WAMessageKey): Promise<unknown>;
+    /** Reports the contact and blocks it after WhatsApp accepts the report. */
+    reportContact(jid: string, messageKeys?: WAMessageKey[]): Promise<unknown>;
+    /** Reports the group and leaves it after WhatsApp accepts the report. */
+    reportGroup(jid: string, messageKeys?: WAMessageKey[]): Promise<unknown>;
+    [key: string]: unknown;
+}
+
+export interface SocketConfig {
+    [key: string]: unknown;
+}
+
+declare function makeWASocket(config: SocketConfig): WASocket;
+export { makeWASocket };
+export default makeWASocket;

package/package.json

@@ -1,11 +1,12 @@
 {
    "name": "@crysnovax/baileys",
-   "version": "2.6.8",
+   "version": "2.6.9",
    "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",
    "scripts": {
-      "preinstall": "node ./engine-requirements.js"
+      "preinstall": "node ./engine-requirements.js",
+      "test": "node --test"
    },
    "engines": {
       "node": ">=20.0.0"
@@ -51,6 +52,7 @@
       "async-mutex": "^0.5.0",
       "fflate": "^0.8.2",
       "libsignal": "^6.0.0",
+      "long": "^5.2.3",
       "lru-cache": "^11.2.6",
       "music-metadata": "^11.12.3",
       "p-queue": "^9.1.0",
@@ -62,10 +64,10 @@
    "peerDependencies": {
       "@napi-rs/image": "~1.12.0",
       "audio-decode": "^2.2.3",
+      "better-sqlite3": "^11.0.0",
       "jimp": "^1.6.1",
       "link-preview-js": "^3.0.0",
-      "sharp": "*",
-      "better-sqlite3": "^11.0.0"
+      "sharp": "*"
    },
    "peerDependenciesMeta": {
       "@napi-rs/image": {
@@ -74,13 +76,13 @@
       "audio-decode": {
          "optional": true
       },
-      "jimp": {
+      "better-sqlite3": {
          "optional": true
       },
-      "link-preview-js": {
+      "jimp": {
          "optional": true
       },
-      "better-sqlite3": {
+      "link-preview-js": {
          "optional": true
       }
    },