aunubaileys 1.0.44 → 1.0.46

package/README.md

@@ -64,6 +64,16 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🆕 What's new in 1.0.46 / Baru di 1.0.46
+
+- 🩹 **The "Over 2000 messages into the future" flood now heals itself.** Session-layer decrypt failures — libsignal's aggregate "No matching sessions found for message" / "No session record" / "No sessions available", which includes the unfillable counter gap left by regressed session state (e.g. sessions restored from a backup while the sender kept sending; observed live in the Tenka deployment on 11 Nov 2026, on the same LID address as the old B-01 finding) — are now recognised from `messageStubParameters` and trigger an **immediate E2E session reset** instead of waiting for 3 failures: for DMs and groups alike (groups also drop the author's sender key), including the session record under its alternate PN↔LID address form, with the retry receipt carrying fresh keys. The old self-heal missed this flood because it waited 3 strikes, in groups only touched the sender key while the broken layer is the E2E session, and deletion could miss the aliased record. Other error classes (ordinary Bad MAC) keep the exact 1.0.14/1.0.17 3-strike behaviour. New exported classifier: `isUnrecoverableSessionError(text)`; the `messages.decrypt-failure` event gains an `errorClass` field (`'session'`/`'other'`) and `healed` now reflects a reset that actually happened on that message.
+
+### 🆕 What's new in 1.0.45 / Baru di 1.0.45
+
+- 📞 **VOIP call support (from plogme, original implementation)** — one combined release from an 8-package sweep (raiden-baileys, @neoxr/wb, @zervonex/baileys, @itsliaaa/starseal, alya-baileys, @ryuu-reinzz/baileys, @cogitator-ai/channels, plogme — all audited clean). New socket methods: `offerCall(jid, isVideo?)` and `groupCall(groupJid, participants, isVideo?)` build the `<offer>` with a per-device encrypted call-key envelope, `cancelGroupCall(groupJid, callId)`, and `acceptCall(callId, callFrom)` / `terminateCall(callId, callFrom, reason?)` join the existing `rejectCall`. Pure stanza builders are exported from `lib/Utils/call-utils.js` so the wire shapes are unit-testable. The stanza shapes follow the WhatsApp call protocol; the code is an original AunuBaileys implementation (plogme's license forbids copying its code). This is the signalling layer — two-way VOIP media is out of scope. plogme's voip-rekey decoder was **not** ported: the 6.7.24 proto has no `E2eRekeyPayload`.
+- 🌐 **HTML messages — EXPERIMENTAL (Aunu's call):** content `{ html, trustedSources }` adds an `FOAHtmlPrimitiveDemoDONOTUSE` section to the unified response (or use `prepareHtmlMessage(...)`), and `{ richHtml: { html, title, tabs, ... } }` / `prepareRichHtmlMessage(...)` builds an interactive screen as an embedded screen (`GenAIaeacdsnwHtmlPrimitive` inside `FOAIDNixelButtonSheets` tabs) — the surface interactive HTML+JS lives on. The library transports the payload intact; whether the receiving WhatsApp client renders/executes it depends on the client version and is not guaranteed.
+- 🏷️ **`addStickerExif(webpBuffer, { packId?, packname?, author?, emojis?, categories? })`** (the @itsliaaa/starseal idea): writes sticker EXIF metadata into a WebP buffer — an existing EXIF chunk is replaced, not stacked; non-WebP input is rejected.
+
 ### 🆕 What's new in 1.0.44 / Baru di 1.0.44
 
 - 🖼️ **A third image backend: `@napi-rs/image`** in `getImageProcessingLibrary`, between sharp and jimp (priority: sharp → @napi-rs/image → jimp). `extractImageThumb` and `generateProfilePicture` gain a napi branch (Transformer: metadata + resize + quality-50 JPEG, matching the existing branches), and the package now declares `@napi-rs/image ^1.12.0` as an optional peer dependency. Consumers without sharp get a fast native path instead of falling back to jimp. Follows @itsliaaa/baileys.

package/lib/Socket/messages-recv.d.ts

@@ -7,6 +7,8 @@ export declare const makeMessagesRecvSocket: (config: SocketConfig) => {
     sendMessageAck: ({ tag, attrs, content }: BinaryNode, errorCode?: number) => Promise<void>;
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
     rejectCall: (callId: string, callFrom: string) => Promise<void>;
+    acceptCall: (callId: string, callFrom: string) => Promise<void>;
+    terminateCall: (callId: string, callFrom: string, reason?: string) => Promise<void>;
     fetchMessageHistory: (count: number, oldestMsgKey: WAMessageKey, oldestMsgTimestamp: number | Long) => Promise<string>;
     requestPlaceholderResend: (messageKey: WAMessageKey) => Promise<string | undefined>;
     getPrivacyTokens: (jids: string[]) => Promise<any>;

package/lib/Socket/messages-recv.js

@@ -5,7 +5,7 @@ import Long from 'long';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT } from '../Defaults/index.js';
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
-import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, parseRetryReceiptSession, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
+import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, isUnrecoverableSessionError, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, buildCallControlStanza, parseRetryReceiptSession, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
 import { sentMessageCacheFor } from '../Utils/sent-message-cache.js';
 import { areJidsSameUser, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidStatusBroadcast, isJidUser, isLidUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
@@ -67,6 +67,28 @@ export const makeMessagesRecvSocket = (config) => {
         logger.debug({ recv: { tag, attrs }, sent: stanza.attrs }, 'sent ack');
         await sendNode(stanza);
     };
+    // AunuBaileys: terima panggilan masuk (node kontrol <accept>) — pasangan
+    // rejectCall bawaan; media VOIP-nya sendiri di luar cakupan protokol chat.
+    const acceptCall = async (callId, callFrom) => {
+        await query(buildCallControlStanza({
+            from: authState.creds.me.id,
+            to: callFrom,
+            action: 'accept',
+            callId,
+            callCreator: callFrom
+        }));
+    };
+    // AunuBaileys: akhiri panggilan yang sedang berjalan (<terminate>).
+    const terminateCall = async (callId, callFrom, reason = 'user-terminated') => {
+        await query(buildCallControlStanza({
+            from: authState.creds.me.id,
+            to: callFrom,
+            action: 'terminate',
+            callId,
+            callCreator: callFrom,
+            reason
+        }));
+    };
     const rejectCall = async (callId, callFrom) => {
         const stanza = {
             tag: 'call',
@@ -736,17 +758,47 @@ export const makeMessagesRecvSocket = (config) => {
                                         const addr = signalRepository.jidToSignalProtocolAddress(author);
                                         const failKey = isGroupMsg ? `sk:${msg.key.remoteJid}:${addr}` : addr;
                                         const fails = (decryptFailCounts.get(failKey) || 0) + 1;
-                                        if (fails >= DECRYPT_FAIL_SESSION_RESET_LIMIT) {
+                                        // AunuBaileys (1.0.46): kegagalan lapis sesi — record
+                                        // sesi tersimpan tidak dapat mendekripsi pesan ini
+                                        // sama sekali (termasuk jurang "Over 2000 messages
+                                        // into the future" akibat state sesi yang mundur).
+                                        // Jurang itu tidak bisa diisi ulang, jadi menunggu
+                                        // 3x hanya membanjiri log; dan di grup, menghapus
+                                        // sender key saja tidak menyentuh sesi E2E yang
+                                        // rusak. Kelas ini direset SEKETIKA.
+                                        const sessionLayerFailure = isUnrecoverableSessionError(msg?.messageStubParameters?.[0]);
+                                        let healed = false;
+                                        const resetE2ESession = async () => {
+                                            await signalRepository.deleteSession(author);
+                                            // sesi yang sama bisa tersimpan di bawah bentuk
+                                            // alamat alternatifnya (PN <-> LID)
+                                            const alt = sock.aunuLid?.getAltJid?.(author);
+                                            if (alt && alt !== author) {
+                                                await signalRepository.deleteSession(alt);
+                                            }
+                                        };
+                                        if (sessionLayerFailure) {
+                                            await resetE2ESession();
+                                            if (isGroupMsg) {
+                                                await signalRepository.deleteSenderKey(msg.key.remoteJid, author);
+                                            }
+                                            decryptFailCounts.delete(failKey);
+                                            forceIncludeKeys = true;
+                                            healed = true;
+                                            logger.warn({ author, addr, group: isGroupMsg ? msg.key.remoteJid : undefined }, 'aunu: reset E2E session after an unrecoverable session-layer decrypt failure (stored session cannot decrypt, e.g. regressed state); retry receipt carries fresh keys');
+                                        }
+                                        else if (fails >= DECRYPT_FAIL_SESSION_RESET_LIMIT) {
                                             if (isGroupMsg) {
                                                 await signalRepository.deleteSenderKey(msg.key.remoteJid, author);
                                                 logger.warn({ author, group: msg.key.remoteJid }, 'aunu: deleted stale sender-key record after repeated group decrypt failures; retry request asks the author to resend with a fresh distribution message');
                                             }
                                             else {
-                                                await signalRepository.deleteSession(author);
+                                                await resetE2ESession();
                                                 logger.warn({ author, addr }, 'aunu: deleted stale E2E session after repeated decrypt failures (Bad MAC self-heal); retry receipt carries fresh keys');
                                             }
                                             decryptFailCounts.delete(failKey);
                                             forceIncludeKeys = true;
+                                            healed = true;
                                         }
                                         else {
                                             decryptFailCounts.set(failKey, fails);
@@ -760,7 +812,8 @@ export const makeMessagesRecvSocket = (config) => {
                                             address: addr,
                                             isGroup: isGroupMsg,
                                             failures: fails,
-                                            healed: fails >= DECRYPT_FAIL_SESSION_RESET_LIMIT,
+                                            healed,
+                                            errorClass: sessionLayerFailure ? 'session' : 'other',
                                             messageId: node.attrs.id,
                                             timestamp: Date.now()
                                         });
@@ -1201,6 +1254,8 @@ export const makeMessagesRecvSocket = (config) => {
         sendMessageAck,
         sendRetryRequest,
         rejectCall,
+        acceptCall,
+        terminateCall,
         fetchMessageHistory,
         requestPlaceholderResend
     };

package/lib/Socket/messages-send.d.ts

@@ -23,6 +23,9 @@ export declare const makeMessagesSocket: (config: SocketConfig) => {
     getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<JidWithDevice[]>;
     updateMediaMessage: (message: proto.IWebMessageInfo) => Promise<proto.IWebMessageInfo>;
     sendMessage: (jid: string, content: AnyMessageContent, options?: MiscMessageGenerationOptions) => Promise<proto.WebMessageInfo | undefined>;
+    offerCall: (toJid: string, isVideo?: boolean) => Promise<{ id: string; to: string }>;
+    groupCall: (groupJid: string, participants?: string[], isVideo?: boolean) => Promise<{ id: string; to: string }>;
+    cancelGroupCall: (groupJid: string, callId: string) => Promise<{ id: string; to: string }>;
     newsletterCreate: (name: string, description?: string) => Promise<import("../Types/index.js").NewsletterMetadata>;
     newsletterUpdate: (jid: string, updates: import("../Types/index.js").NewsletterUpdate) => Promise<unknown>;
     newsletterSubscribers: (jid: string) => Promise<{

package/lib/Socket/messages-send.js

@@ -2,7 +2,7 @@ import NodeCache from '@cacheable/node-cache';
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { BIZ_BOT_SUPPORT_PAYLOAD, DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults/index.js';
-import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, delay, extractDeviceJids, generateMessageIDV2, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds, shouldIncludeBizBinaryNode } from '../Utils/index.js';
+import { aggregateMessageKeysNotFromMe, assertMediaContent, bindWaitForEvent, decryptMediaRetryData, encodeNewsletterMessage, encodeSignedDeviceIdentity, encodeWAMessage, encryptMediaRetryRequest, delay, extractDeviceJids, generateMessageIDV2, buildCallOfferContent, buildGroupCallCancelStanza, buildGroupCallStanza, createCallKey, newCallId, generateWAMessage, getStatusCodeForMediaRetry, getUrlFromDirectPath, getWAUploadToServer, normalizeMessageContent, parseAndInjectE2ESessions, unixTimestampSeconds, shouldIncludeBizBinaryNode } from '../Utils/index.js';
 import { sentMessageCacheFor } from '../Utils/sent-message-cache.js';
 import { getUrlInfo } from '../Utils/link-preview.js';
 import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinaryNode, isJidGroup, isJidNewsletter, isJidUser, isLidUser, jidDecode, jidEncode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
@@ -609,11 +609,92 @@ export const makeMessagesSocket = (config) => {
     };
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
+    // AunuBaileys: mulai panggilan suara/video 1:1 — susun <offer> dengan
+    // amplop callKey terenkripsi per perangkat tujuan (destination), sama
+    // seperti jalur fan-out relayMessage. Mengembalikan { id, to }.
+    const offerCall = async (toJid, isVideo = false) => {
+        const callId = newCallId();
+        const offerContent = buildCallOfferContent(isVideo);
+        const devices = (await getUSyncDevices([toJid], true, false)).map(({ user, device }) => jidEncode(user, 's.whatsapp.net', device));
+        await assertSessions(devices, true);
+        const { nodes: destinations, shouldIncludeDeviceIdentity } = await createParticipantNodes(devices, {
+            call: { callKey: createCallKey() }
+        }, { count: '0' });
+        offerContent.push({ tag: 'destination', attrs: {}, content: destinations });
+        if (shouldIncludeDeviceIdentity) {
+            offerContent.push({
+                tag: 'device-identity',
+                attrs: {},
+                content: encodeSignedDeviceIdentity(authState.creds.account, true)
+            });
+        }
+        const stanza = {
+            tag: 'call',
+            attrs: {
+                id: generateMessageIDV2(authState.creds.me?.id),
+                to: toJid
+            },
+            content: [
+                {
+                    tag: 'offer',
+                    attrs: {
+                        'call-id': callId,
+                        'call-creator': authState.creds.me.id
+                    },
+                    content: offerContent
+                }
+            ]
+        };
+        await query(stanza);
+        return { id: callId, to: toJid };
+    };
+    // AunuBaileys: mulai panggilan grup — <offer type="group"> ke JID grup,
+    // destination dienkripsi untuk perangkat para peserta yang di-ring.
+    const groupCall = async (groupJid, participants = [], isVideo = false) => {
+        const callId = newCallId();
+        const offerContent = buildCallOfferContent(isVideo);
+        const devices = (await getUSyncDevices(participants, true, false)).map(({ user, device }) => jidEncode(user, 's.whatsapp.net', device));
+        await assertSessions(devices, true);
+        const { nodes: destinations, shouldIncludeDeviceIdentity } = await createParticipantNodes(devices, {
+            call: { callKey: createCallKey() }
+        }, { count: '0' });
+        offerContent.push({ tag: 'destination', attrs: {}, content: destinations });
+        if (shouldIncludeDeviceIdentity) {
+            offerContent.push({
+                tag: 'device-identity',
+                attrs: {},
+                content: encodeSignedDeviceIdentity(authState.creds.account, true)
+            });
+        }
+        const stanza = buildGroupCallStanza({
+            id: generateMessageIDV2(authState.creds.me?.id),
+            to: groupJid,
+            callId,
+            callCreator: authState.creds.me.id,
+            offerContent
+        });
+        await query(stanza);
+        return { id: callId, to: groupJid };
+    };
+    // AunuBaileys: batalkan/akhiri panggilan grup yang dimulai groupCall.
+    const cancelGroupCall = async (groupJid, callId) => {
+        const stanza = buildGroupCallCancelStanza({
+            from: authState.creds.me.id,
+            to: groupJid,
+            callId,
+            callCreator: authState.creds.me.id
+        });
+        await query(stanza);
+        return { id: callId, to: groupJid };
+    };
     return {
         ...sock,
         getPrivacyTokens,
         assertSessions,
         relayMessage,
+        offerCall,
+        groupCall,
+        cancelGroupCall,
         sendReceipt,
         sendReceipts,
         readMessages,

package/lib/Types/Message.d.ts

@@ -269,6 +269,9 @@ export type AnyMessageContent = (AnyRegularMessageContent | {
     footerText?: string;
     disclaimerText?: string;
     noHeading?: boolean;
+    html?: string;
+    trustedSources?: string[];
+    richHtml?: { html?: string; title?: string; tabHeader?: string; url?: string; trustedSources?: string[]; tabs?: any[] };
 };
 export type GroupMetadataParticipants = Pick<GroupMetadata, 'participants'>;
 type MinimalRelayOptions = {

package/lib/Utils/call-utils.d.ts

@@ -0,0 +1,25 @@
+import type { BinaryNode } from '../WABinary/index.js';
+export declare const newCallId: () => string;
+export declare const createCallKey: () => Uint8Array;
+export declare const buildCallOfferContent: (isVideo?: boolean) => BinaryNode[];
+export declare const buildCallControlStanza: (opts: {
+    from: string;
+    to: string;
+    action: 'accept' | 'terminate' | 'reject';
+    callId: string;
+    callCreator: string;
+    reason?: string;
+}) => BinaryNode;
+export declare const buildGroupCallStanza: (opts: {
+    id: string;
+    to: string;
+    callId: string;
+    callCreator: string;
+    offerContent: BinaryNode[];
+}) => BinaryNode;
+export declare const buildGroupCallCancelStanza: (opts: {
+    from: string;
+    to: string;
+    callId: string;
+    callCreator: string;
+}) => BinaryNode;

package/lib/Utils/call-utils.js

@@ -0,0 +1,81 @@
+import { randomBytes } from 'crypto';
+// AunuBaileys: pembangun stanza panggilan (VOIP) — fungsi murni, tanpa state
+// socket, supaya bentuk wire-nya bisa diuji langsung. Bentuk stanza mengikuti
+// protokol panggilan WhatsApp (node <call> dengan anak offer/accept/reject/
+// terminate), implementasi orisinal AunuBaileys.
+/** ID panggilan baru: 32 karakter hex huruf besar. */
+export const newCallId = () => randomBytes(16).toString('hex').toUpperCase();
+/** Kunci media panggilan baru (32 byte) untuk amplop destination terenkripsi. */
+export const createCallKey = () => new Uint8Array(randomBytes(32));
+/**
+ * Isi node <offer> untuk panggilan 1:1 maupun grup: codec audio opus
+ * (16 kHz + 8 kHz), video vp8 opsional, net, capability, dan encopt.
+ * Node destination/device-identity ditambahkan pemanggil setelah sesi siap.
+ */
+export const buildCallOfferContent = (isVideo = false) => {
+    const content = [
+        { tag: 'audio', attrs: { enc: 'opus', rate: '16000' }, content: undefined },
+        { tag: 'audio', attrs: { enc: 'opus', rate: '8000' }, content: undefined }
+    ];
+    if (isVideo) {
+        content.push({
+            tag: 'video',
+            attrs: {
+                enc: 'vp8',
+                dec: 'vp8',
+                orientation: '0',
+                screen_width: '1920',
+                screen_height: '1080',
+                device_orientation: '0'
+            },
+            content: undefined
+        });
+    }
+    content.push({ tag: 'net', attrs: { medium: '3' }, content: undefined });
+    content.push({ tag: 'capability', attrs: { ver: '1' }, content: new Uint8Array([1, 4, 255, 131, 207, 4]) });
+    content.push({ tag: 'encopt', attrs: { keygen: '2' }, content: undefined });
+    return content;
+};
+/** Stanza <call> berisi satu node kontrol (accept / terminate / reject). */
+export const buildCallControlStanza = ({ from, to, action, callId, callCreator, reason }) => ({
+    tag: 'call',
+    attrs: { from, to },
+    content: [
+        {
+            tag: action,
+            attrs: {
+                'call-id': callId,
+                'call-creator': callCreator,
+                ...(reason ? { reason } : {}),
+                count: '0'
+            },
+            content: undefined
+        }
+    ]
+});
+/** Stanza <call><offer type="group" group-jid=..> untuk memulai panggilan grup. */
+export const buildGroupCallStanza = ({ id, to, callId, callCreator, offerContent }) => ({
+    tag: 'call',
+    attrs: { id, to },
+    content: [
+        {
+            tag: 'offer',
+            attrs: {
+                'call-id': callId,
+                'call-creator': callCreator,
+                type: 'group',
+                'group-jid': to
+            },
+            content: offerContent
+        }
+    ]
+});
+/** Stanza <call><terminate> untuk membatalkan/mengakhiri panggilan grup. */
+export const buildGroupCallCancelStanza = ({ from, to, callId, callCreator }) => buildCallControlStanza({
+    from,
+    to,
+    action: 'terminate',
+    callId,
+    callCreator,
+    reason: 'user-terminated'
+});

package/lib/Utils/decode-wa-message.d.ts

@@ -2,6 +2,7 @@ import type { SignalRepository, WAMessage } from '../Types/index.js';
 import { type BinaryNode } from '../WABinary/index.js';
 import type { ILogger } from './logger.js';
 export declare const NO_MESSAGE_FOUND_ERROR_TEXT = "Message absent from node";
+export declare const isUnrecoverableSessionError: (text: unknown) => boolean;
 export declare const MISSING_KEYS_ERROR_TEXT = "Key used already or never filled";
 export declare const NACK_REASONS: {
     ParsingError: number;

package/lib/Utils/decode-wa-message.js

@@ -216,4 +216,15 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
         }
     };
 };
+/**
+ * AunuBaileys: true when a decrypt failure text is libsignal's session-layer
+ * aggregate — the stored session record(s) could not decrypt the message at
+ * all ("No matching sessions found for message", "No session record",
+ * "No sessions available"). This class includes the unfillable counter gap
+ * ("Over 2000 messages into the future!") thrown when the stored session
+ * state has regressed behind the sender's ratchet, e.g. after a backup
+ * restore; such a session can never decrypt again and must be reset.
+ */
+export const isUnrecoverableSessionError = (text) => typeof text === 'string' &&
+    /no matching sessions found|no session record|no sessions available/i.test(text);
 //# sourceMappingURL=decode-wa-message.js.map

package/lib/Utils/index.js

@@ -3,6 +3,7 @@ export * from './decode-wa-message.js';
 export * from './messages.js';
 export * from './messages-media.js';
 export * from './rich-message-utils.js';
+export * from './call-utils.js';
 export * from './validate-connection.js';
 export * from './crypto.js';
 export * from './signal.js';

package/lib/Utils/messages-media.d.ts

@@ -110,4 +110,11 @@ export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
 export declare const getStatusCodeForMediaRetry: (code: number) => 200 | 412 | 404 | 418;
 export {};
 //# sourceMappingURL=messages-media.d.ts.map
+export declare const addStickerExif: (webpBuffer: Buffer, metadata?: {
+    packId?: string;
+    packname?: string;
+    author?: string;
+    emojis?: string[];
+    categories?: string[];
+}) => Buffer;
 export declare const getImageProcessingLibrary: () => Promise<Record<string, any>>;

package/lib/Utils/messages-media.js

@@ -683,4 +683,49 @@ const MEDIA_RETRY_STATUS_MAP = {
     [proto.MediaRetryNotification.ResultType.NOT_FOUND]: 404,
     [proto.MediaRetryNotification.ResultType.GENERAL_ERROR]: 418
 };
+/**
+ * AunuBaileys: tulis metadata EXIF stiker (nama pack, penerbit, emoji) ke
+ * buffer WebP — format chunk EXIF standar ekosistem WhatsApp (header TIFF
+ * mini + JSON metadata). Chunk EXIF lama diganti, bukan ditumpuk. Mengikuti
+ * gagasan @itsliaaa/starseal; implementasi orisinal di sini.
+ */
+export const addStickerExif = (webpBuffer, metadata = {}) => {
+    if (!Buffer.isBuffer(webpBuffer) || webpBuffer.length < 12 ||
+        webpBuffer.toString('ascii', 0, 4) !== 'RIFF' || webpBuffer.toString('ascii', 8, 12) !== 'WEBP') {
+        throw new Error('addStickerExif: input bukan buffer WebP (RIFF) yang valid');
+    }
+    const json = {
+        'sticker-pack-id': metadata.packId || 'aunubaileys',
+        'sticker-pack-name': metadata.packname || '',
+        'sticker-pack-publisher': metadata.author || '',
+        'emojis': Array.isArray(metadata.emojis) ? metadata.emojis : ['🖤'],
+        ...(metadata.categories ? { 'categories': metadata.categories } : {})
+    };
+    const jsonBytes = Buffer.from(JSON.stringify(json), 'utf8');
+    const header = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00]);
+    header.writeUInt32LE(jsonBytes.length, 14);
+    const exifPayload = Buffer.concat([header, jsonBytes]);
+    // pisahkan chunk-chunk RIFF yang ada (selain EXIF lama)
+    const chunks = [];
+    let offset = 12;
+    while (offset + 8 <= webpBuffer.length) {
+        const type = webpBuffer.toString('ascii', offset, offset + 4);
+        const size = webpBuffer.readUInt32LE(offset + 4);
+        const total = 8 + size + (size % 2);
+        if (type !== 'EXIF') {
+            chunks.push(webpBuffer.subarray(offset, offset + total));
+        }
+        offset += total;
+    }
+    const exifChunk = Buffer.alloc(8 + exifPayload.length + (exifPayload.length % 2));
+    exifChunk.write('EXIF', 0, 'ascii');
+    exifChunk.writeUInt32LE(exifPayload.length, 4);
+    exifPayload.copy(exifChunk, 8);
+    const body = Buffer.concat([Buffer.from('WEBP', 'ascii'), ...chunks, exifChunk]);
+    const out = Buffer.alloc(8 + body.length);
+    out.write('RIFF', 0, 'ascii');
+    out.writeUInt32LE(body.length, 4);
+    body.copy(out, 8);
+    return out;
+};
 //# sourceMappingURL=messages-media.js.map

package/lib/Utils/messages.js

@@ -462,7 +462,7 @@ export const generateWAMessageContent = async (message, options) => {
     var _a, _b;
     let m = {};
     // AunuBaileys: rich response — blok kode / tabel / tautan (dari @itsliaaa/baileys)
-    if ('code' in message || 'links' in message || 'table' in message || 'richResponse' in message) {
+    if ('code' in message || 'links' in message || 'table' in message || 'richResponse' in message || 'html' in message || 'richHtml' in message) {
         m = prepareRichResponseMessage(message);
     }
     else if ('text' in message) {

package/lib/Utils/rich-message-utils.d.ts

@@ -4,5 +4,9 @@ export declare const tokenizeCode: (code: string, language?: string) => {
     codeContent: string;
 }[];
 export declare const toUnified: (submessages: any[], uuid?: string) => any;
+export declare const buildFoaHtmlSection: (html: string, trustedSources?: string[]) => any;
+export declare const prepareHtmlMessage: (content: { html?: string; trustedSources?: string[] }) => any;
+export declare const buildRichHtmlScreen: (options: any) => any;
+export declare const prepareRichHtmlMessage: (options: any) => any;
 export declare const prepareRichResponseMessage: (content: any) => any;
 export declare const wrapToBotForwardedMessage: (richResponseMessage: proto.AIRichResponseMessage) => any;

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

@@ -99,7 +99,97 @@ export const toUnified = (submessages, uuid) => ({
         return submessage;
     })
 });
+// AunuBaileys: seksi layar HTML (primitive FOAHtmlPrimitiveDemoDONOTUSE milik
+// klien WhatsApp) untuk unified response — payload HTML mentah + daftar
+// sumber tepercaya opsional. EKSPERIMENTAL (keputusan Aunu 11 Nov 2026):
+// apakah klien WhatsApp penerima merender HTML/JS-nya bergantung versi
+// klien dan tidak dijamin library.
+export const buildFoaHtmlSection = (html, trustedSources = []) => ({
+    __typename: 'GenAIUnifiedResponseSection',
+    view_model: {
+        __typename: 'GenAISingleLayoutViewModel',
+        primitive: {
+            __typename: 'FOAHtmlPrimitiveDemoDONOTUSE',
+            trusted_sources: Array.isArray(trustedSources) ? trustedSources : [],
+            payload: String(html ?? '').trim()
+        }
+    }
+});
+// AunuBaileys: pesan HTML mandiri — rich response yang unified-nya hanya
+// berisi seksi HTML (submessages kosong, mengikuti bentuk sumbernya).
+export const prepareHtmlMessage = (content = {}) => prepareRichResponseMessage({
+    html: content.html,
+    trustedSources: content.trustedSources
+});
+// AunuBaileys: layar HTML interaktif sebagai embedded screen di unified
+// response — primitive GenAIaeacdsnwHtmlPrimitive di dalam tab
+// FOAIDNixelButtonSheets; permukaan mini-app tempat HTML+JS interaktif
+// (game dsb.) tinggal, berbeda dari seksi FOA pada pesan HTML biasa.
+// EKSPERIMENTAL (keputusan Aunu 11 Nov 2026): render bergantung klien.
+export const buildRichHtmlScreen = (options = {}) => {
+    const { html = '', trustedSources = [], url = '', title = 'Preview', tabHeader = 'HTML', tabs } = options;
+    const tabItems = Array.isArray(tabs) && tabs.length
+        ? tabs
+        : [{ id: 'tab_0', tab_header: tabHeader, html }];
+    const embeddedTabs = tabItems.map((tab, index) => ({
+        id: tab.id || `tab_${index}`,
+        tab_header: tab.tab_header || tab.title || `HTML ${index + 1}`,
+        sections: [{
+                __typename: 'GenAIUnifiedResponseSection',
+                view_model: {
+                    __typename: 'GenAISingleLayoutViewModel',
+                    primitive: {
+                        __typename: 'GenAIaeacdsnwHtmlPrimitive',
+                        payload: String(tab.html ?? tab.payload ?? html).trim(),
+                        url: tab.url || url,
+                        trusted_sources: tab.trustedSources || trustedSources
+                    }
+                }
+            }],
+        step_entries: []
+    }));
+    return {
+        title,
+        embeddedScreen: {
+            title,
+            content: [{
+                    __typename: 'FOAIDNixelButtonSheets',
+                    tabs: embeddedTabs
+                }]
+        }
+    };
+};
+// AunuBaileys: pesan layar HTML interaktif — unified membawa embedded_screens,
+// submessage-nya satu teks judul bergaya kutipan.
+export const prepareRichHtmlMessage = (options = {}) => {
+    const { title, embeddedScreen } = buildRichHtmlScreen(options);
+    const unified = {
+        response_id: randomUUID(),
+        sections: [{
+                view_model: {
+                    primitive: { text: `> ${title}`, __typename: 'GenAIMarkdownTextUXPrimitive' },
+                    __typename: 'GenAISingleLayoutViewModel'
+                }
+            }],
+        embedded_screens: [embeddedScreen]
+    };
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        messageType: proto.AIRichResponseMessage.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        submessages: [{ messageType: RichSubMessageType.TEXT, messageText: `> ${title}` }],
+        unifiedResponse: { data: TEXT_ENCODER.encode(JSON.stringify(unified)) },
+        contextInfo: {
+            isForwarded: true,
+            forwardingScore: 1,
+            forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+            forwardOrigin: 4
+        }
+    });
+    return wrapToBotForwardedMessage(richResponseMessage);
+};
 export const prepareRichResponseMessage = (content) => {
+    if (content.richHtml) {
+        return prepareRichHtmlMessage(content.richHtml);
+    }
     let { alignment, code, contentText, disclaimerText, footerText, headerText, imageText, inlineImage, inlineVideo, items, language, latex, links, noHeading, posts, products, suggested, richResponse, table, tapLinkUrl, title } = content;
     let submessages = [];
     if (Array.isArray(richResponse)) {
@@ -311,7 +401,14 @@ export const prepareRichResponseMessage = (content) => {
         }
     }
     const uuid = randomUUID();
+    const extraSections = [];
+    if (content.html) {
+        extraSections.push(buildFoaHtmlSection(content.html, content.trustedSources));
+    }
     const unified = toUnified(submessages, uuid);
+    if (extraSections.length) {
+        unified.sections.push(...extraSections);
+    }
     const richResponseMessage = proto.AIRichResponseMessage.create({
         submessages,
         messageType: proto.AIRichResponseMessage.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.44",
+  "version": "1.0.46",
   "description": "AunuBaileys \u2014 a WhatsApp Web API for bots that never sleep. Full upstream power with the beloved in-memory store restored and pairing that just works. Forged by AunuCore.",
   "keywords": [
     "whatsapp",