aunubaileys 1.0.46 → 1.0.48

package/README.md

@@ -64,6 +64,14 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🆕 What's new in 1.0.48 / Baru di 1.0.48
+
+- 🩹 **Group Bad MAC now heals both layers.** The "Bad MAC" error (from Tenka's live log on 11 Nov 2026, the same LID address as the B-01 finding and the 1.0.46 flood) is thrown by `SessionCipher` — the whisper/E2E session layer — and in groups it can equally come from the sender-key layer. The old strike-limit path (1.0.14) for groups deleted only the sender key, so a rotten E2E session of the author was never touched and the failures repeated forever: the same wrong-layer class that 1.0.46 closed for session failures, now closed on the strike path. At the 3-failure limit, groups now reset the author's E2E session (including the alternate PN↔LID address record) AND drop the sender key, with the retry receipt carrying fresh keys. DM behaviour and the 3-strike threshold are unchanged. The `messages.decrypt-failure` event now distinguishes `errorClass: 'bad-mac'` from `'session'`/`'other'` (new exported predicate: `isBadMacError(text)`).
+
+### 🧪 What's new in 1.0.47 / Baru di 1.0.47 — EXPERIMENTAL
+
+- 🧪 **Five experimental features that exist only in AunuBaileys**, in a single version. All are attached automatically to the socket returned by `makeWASocket` and are explicitly experimental — semantics may change in any release: (1) **Invisible text watermark** — `sock.aunuWatermark(text, tag)` hides a short tag (bot name, campaign, build) inside message text as zero-width characters for leak tracing and fingerprinting; the visible text is unchanged; companions `aunuReadWatermark(text)` and `aunuStripWatermark(text)`, plus root utils `encodeWatermark`/`appendWatermark`/`extractWatermark`/`stripWatermark`. (2) **Human send** — `sock.aunuHumanSend(jid, content)`: shows "composing" for a plausible typing duration derived from the text length (util `computeTypingDuration`, clamped 700–8000 ms, ±20% jitter), then sends. (3) **Scheduled send** — `sock.aunuSchedule(jid, content, when)` (ms delay or Date) with `aunuCancelScheduled(id)` and `aunuListScheduled()`; in-memory, lost on restart. (4) **Self-destruct** — `sock.aunuSelfDestruct(jid, content, seconds)`: sends, then revokes the message for everyone after N seconds; `aunuCancelSelfDestruct(messageId)` cancels. (5) **Connection doctor** — `sock.aunuDoctor()`: one structured health snapshot (bundled WA version, registration state, open transport, known LID pair count, pending experimental timers).
+
 ### 🆕 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.

package/lib/Socket/aunu-experimental.d.ts

@@ -0,0 +1,32 @@
+import type { AnyMessageContent, MiscMessageGenerationOptions, WAMessage } from '../Types/index.js';
+import type { TypingDurationOptions } from '../Utils/aunu-experimental.js';
+/** EXPERIMENTAL — AunuBaileys-only socket features. Semantics may change in any release. */
+export interface AunuDoctorReport {
+    experimental: true;
+    bundledWaVersion: string | null;
+    registered: boolean;
+    me: string | null;
+    wsOpen: boolean;
+    lidPairsKnown: number | null;
+    scheduledPending: number;
+    selfDestructPending: number;
+    generatedAt: string;
+}
+export interface AunuScheduledSend {
+    id: string;
+    at: number;
+    cancel: () => boolean;
+}
+export interface AunuExperimentalAPI {
+    aunuWatermark: (text: string, tag: string) => string;
+    aunuReadWatermark: (text: string) => string | null;
+    aunuStripWatermark: (text: string) => string;
+    aunuHumanSend: (jid: string, content: AnyMessageContent, options?: MiscMessageGenerationOptions & TypingDurationOptions) => Promise<WAMessage | undefined>;
+    aunuSchedule: (jid: string, content: AnyMessageContent, when: number | Date, options?: MiscMessageGenerationOptions) => AunuScheduledSend;
+    aunuCancelScheduled: (id: string) => boolean;
+    aunuListScheduled: () => { id: string; jid: string; at: number }[];
+    aunuSelfDestruct: (jid: string, content: AnyMessageContent, seconds: number, options?: MiscMessageGenerationOptions) => Promise<WAMessage | undefined>;
+    aunuCancelSelfDestruct: (messageId: string) => boolean;
+    aunuDoctor: () => AunuDoctorReport;
+}
+export declare const attachAunuExperimental: <T>(sock: T) => T & AunuExperimentalAPI;

package/lib/Socket/aunu-experimental.js

@@ -0,0 +1,104 @@
+import baileysVersion from '../Defaults/baileys-version.json' with { type: 'json' };
+import { appendWatermark, computeTypingDuration, extractWatermark, stripWatermark } from '../Utils/aunu-experimental.js';
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * AunuBaileys EXPERIMENTAL socket features — these exist only in
+ * AunuBaileys and may change or disappear in any release:
+ *
+ * 1. Invisible text watermark — `aunuWatermark` / `aunuReadWatermark` /
+ *    `aunuStripWatermark`: hide a short tag (bot name, campaign, build)
+ *    inside message text as zero-width characters for leak tracing and
+ *    fingerprinting; the visible text is unchanged.
+ * 2. Humanised send — `aunuHumanSend`: shows "composing" for a plausible
+ *    typing duration derived from the text length, then sends.
+ * 3. Scheduled send — `aunuSchedule` / `aunuCancelScheduled` /
+ *    `aunuListScheduled`: in-memory delayed sends (lost on restart).
+ * 4. Self-destructing send — `aunuSelfDestruct` /
+ *    `aunuCancelSelfDestruct`: sends, then revokes the message for
+ *    everyone after N seconds.
+ * 5. Connection doctor — `aunuDoctor`: one structured health snapshot
+ *    (registration, transport, bundled WA version, known LID pairs,
+ *    pending experimental timers).
+ */
+export const attachAunuExperimental = (sock) => {
+    const scheduled = new Map();
+    const destructs = new Map();
+    let seq = 0;
+    sock.aunuWatermark = (text, tag) => appendWatermark(text, tag);
+    sock.aunuReadWatermark = (text) => extractWatermark(text);
+    sock.aunuStripWatermark = (text) => stripWatermark(text);
+    sock.aunuHumanSend = async (jid, content, options = {}) => {
+        if (content && typeof content.text === 'string' && typeof sock.sendPresenceUpdate === 'function') {
+            try {
+                await sock.sendPresenceUpdate('composing', jid);
+            }
+            catch {
+                // presence is best-effort; the send itself must not fail over it
+            }
+            await delay(computeTypingDuration(content.text, options));
+            try {
+                await sock.sendPresenceUpdate('paused', jid);
+            }
+            catch {
+                // best-effort, as above
+            }
+        }
+        return sock.sendMessage(jid, content, options);
+    };
+    sock.aunuSchedule = (jid, content, when, options = {}) => {
+        const at = when instanceof Date ? when.getTime() : Date.now() + Math.max(0, Number(when) || 0);
+        const id = `aunu-sched-${++seq}`;
+        const timer = setTimeout(() => {
+            scheduled.delete(id);
+            Promise.resolve(sock.sendMessage(jid, content, options)).catch(() => { });
+        }, Math.max(0, at - Date.now()));
+        timer.unref?.();
+        scheduled.set(id, { jid, at, timer });
+        return { id, at, cancel: () => sock.aunuCancelScheduled(id) };
+    };
+    sock.aunuCancelScheduled = (id) => {
+        const entry = scheduled.get(id);
+        if (!entry) {
+            return false;
+        }
+        clearTimeout(entry.timer);
+        scheduled.delete(id);
+        return true;
+    };
+    sock.aunuListScheduled = () => [...scheduled.entries()].map(([id, entry]) => ({ id, jid: entry.jid, at: entry.at }));
+    sock.aunuSelfDestruct = async (jid, content, seconds, options = {}) => {
+        const sent = await sock.sendMessage(jid, content, options);
+        const key = sent?.key;
+        if (key?.id) {
+            const timer = setTimeout(() => {
+                destructs.delete(key.id);
+                Promise.resolve(sock.sendMessage(jid, { delete: key })).catch(() => { });
+            }, Math.max(0.05, Number(seconds) || 0) * 1000);
+            timer.unref?.();
+            destructs.set(key.id, timer);
+        }
+        return sent;
+    };
+    sock.aunuCancelSelfDestruct = (messageId) => {
+        const timer = destructs.get(messageId);
+        if (!timer) {
+            return false;
+        }
+        clearTimeout(timer);
+        destructs.delete(messageId);
+        return true;
+    };
+    sock.aunuDoctor = () => ({
+        experimental: true,
+        bundledWaVersion: Array.isArray(baileysVersion.version) ? baileysVersion.version.join('.') : null,
+        registered: !!sock.authState?.creds?.registered,
+        me: sock.user?.id ?? null,
+        wsOpen: !!sock.ws?.isOpen,
+        lidPairsKnown: typeof sock.aunuLid?.size === 'number' ? sock.aunuLid.size : null,
+        scheduledPending: scheduled.size,
+        selfDestructPending: destructs.size,
+        generatedAt: new Date().toISOString(),
+    });
+    return sock;
+};
+//# sourceMappingURL=aunu-experimental.js.map

package/lib/Socket/index.js

@@ -1,5 +1,6 @@
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
 import { makeCommunitiesSocket } from './communities.js';
+import { attachAunuExperimental } from './aunu-experimental.js';
 import { AunuHandler } from '../Utils/aunu-handler.js';
 import { makeLIDStore } from '../Utils/lid-store.js';
 // export the last socket layer
@@ -14,6 +15,7 @@ const makeWASocket = (config) => {
         newConfig.shouldSyncHistoryMessage = () => !!newConfig.syncFullHistory;
     }
     const sock = makeCommunitiesSocket(newConfig);
+    attachAunuExperimental(sock);
     sock.aunuHandler = new AunuHandler(sock);
     if (!sock.aunuLid) {
         sock.aunuLid = makeLIDStore();

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, isUnrecoverableSessionError, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, buildCallControlStanza, 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, isBadMacError, 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';
@@ -789,8 +789,15 @@ export const makeMessagesRecvSocket = (config) => {
                                         }
                                         else if (fails >= DECRYPT_FAIL_SESSION_RESET_LIMIT) {
                                             if (isGroupMsg) {
+                                                // AunuBaileys (1.0.48): Bad MAC adalah error
+                                                // lapis whisper/sesi E2E (SessionCipher), dan
+                                                // di grup ia juga bisa datang dari lapis
+                                                // sender key — menghapus sender key SAJA
+                                                // (perilaku 1.0.14) tidak menyentuh sesi E2E
+                                                // penulis yang busuk. Bersihkan keduanya.
+                                                await resetE2ESession();
                                                 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');
+                                                logger.warn({ author, group: msg.key.remoteJid }, 'aunu: reset E2E session and deleted stale sender-key record after repeated group decrypt failures; retry receipt carries fresh keys');
                                             }
                                             else {
                                                 await resetE2ESession();
@@ -813,7 +820,7 @@ export const makeMessagesRecvSocket = (config) => {
                                             isGroup: isGroupMsg,
                                             failures: fails,
                                             healed,
-                                            errorClass: sessionLayerFailure ? 'session' : 'other',
+                                            errorClass: sessionLayerFailure ? 'session' : (isBadMacError(msg?.messageStubParameters?.[0]) ? 'bad-mac' : 'other'),
                                             messageId: node.attrs.id,
                                             timestamp: Date.now()
                                         });

package/lib/Utils/aunu-experimental.d.ts

@@ -0,0 +1,16 @@
+/** EXPERIMENTAL — see aunu-experimental.js. Semantics may change in any release. */
+export declare const encodeWatermark: (payload: string) => string;
+export declare const appendWatermark: (text: string, payload: string) => string;
+export declare const extractWatermark: (text: string) => string | null;
+export declare const stripWatermark: (text: string) => string;
+export interface TypingDurationOptions {
+    /** Characters per second while "typing". Default 5. */
+    cps?: number;
+    /** Lower clamp in ms. Default 700. */
+    minMs?: number;
+    /** Upper clamp in ms. Default 8000. */
+    maxMs?: number;
+    /** Set false for a deterministic duration. Default true (±20%). */
+    jitter?: boolean;
+}
+export declare const computeTypingDuration: (text: string, options?: TypingDurationOptions) => number;

package/lib/Utils/aunu-experimental.js

@@ -0,0 +1,99 @@
+/**
+ * AunuBaileys EXPERIMENTAL utilities — features that exist only in
+ * AunuBaileys. Everything in this module is experimental: semantics may
+ * change in any release. See lib/Socket/aunu-experimental.js for the
+ * socket-level API built on top of these helpers.
+ */
+// Zero-width alphabet for the invisible text watermark. A payload is stored
+// as UTF-8 bytes, each byte as 8 bits (MSB first), wrapped in markers so it
+// can be found and removed again without touching visible text.
+const WM_BIT0 = '\u200B'; // ZERO WIDTH SPACE (bit 0)
+const WM_BIT1 = '\u200C'; // ZERO WIDTH NON-JOINER (bit 1)
+const WM_START = '\u200D'; // ZERO WIDTH JOINER (span start)
+const WM_END = '\u2060'; // WORD JOINER (span end)
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+/**
+ * Encode a short string as an invisible zero-width sequence. Returns an
+ * empty string for an empty payload.
+ */
+export const encodeWatermark = (payload) => {
+    if (!payload) {
+        return '';
+    }
+    const bytes = textEncoder.encode(String(payload));
+    let bits = '';
+    for (const byte of bytes) {
+        bits += byte.toString(2).padStart(8, '0');
+    }
+    return WM_START + [...bits].map((b) => (b === '1' ? WM_BIT1 : WM_BIT0)).join('') + WM_END;
+};
+/** Append an invisible watermark carrying `payload` to `text`. */
+export const appendWatermark = (text, payload) => String(text ?? '') + encodeWatermark(payload);
+/**
+ * Read back the payload hidden in `text` by encodeWatermark/appendWatermark.
+ * Returns null when there is no well-formed watermark.
+ */
+export const extractWatermark = (text) => {
+    if (typeof text !== 'string') {
+        return null;
+    }
+    const start = text.indexOf(WM_START);
+    if (start < 0) {
+        return null;
+    }
+    const end = text.indexOf(WM_END, start + 1);
+    if (end < 0) {
+        return null;
+    }
+    let bits = '';
+    for (const ch of text.slice(start + 1, end)) {
+        if (ch === WM_BIT0) {
+            bits += '0';
+        }
+        else if (ch === WM_BIT1) {
+            bits += '1';
+        }
+        else {
+            return null;
+        }
+    }
+    if (bits.length === 0 || bits.length % 8 !== 0) {
+        return null;
+    }
+    const bytes = new Uint8Array(bits.length / 8);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(bits.slice(i * 8, i * 8 + 8), 2);
+    }
+    try {
+        return textDecoder.decode(bytes);
+    }
+    catch {
+        return null;
+    }
+};
+/** Remove every watermark span from `text`, leaving the visible text intact. */
+export const stripWatermark = (text) => {
+    if (typeof text !== 'string') {
+        return text;
+    }
+    return text.replace(/\u200D[\u200B\u200C]*\u2060/g, '');
+};
+/**
+ * How long a human would plausibly spend typing `text`, in milliseconds —
+ * used by the experimental humanised send. Roughly `chars / cps`, clamped
+ * to [minMs, maxMs], with up to ±20% jitter unless disabled.
+ */
+export const computeTypingDuration = (text, options = {}) => {
+    const cps = options.cps && options.cps > 0 ? options.cps : 5;
+    const minMs = options.minMs ?? 700;
+    const maxMs = options.maxMs ?? 8000;
+    const base = Math.round(((typeof text === 'string' ? text.length : 0) / cps) * 1000);
+    const clamped = Math.min(maxMs, Math.max(minMs, base));
+    if (options.jitter === false) {
+        return clamped;
+    }
+    const jittered = Math.round(clamped * (0.8 + Math.random() * 0.4));
+    return Math.min(maxMs, Math.max(minMs, jittered));
+};
+//# sourceMappingURL=aunu-experimental.js.map

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

@@ -3,6 +3,7 @@ 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 isBadMacError: (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

@@ -227,4 +227,11 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
  */
 export const isUnrecoverableSessionError = (text) => typeof text === 'string' &&
     /no matching sessions found|no session record|no sessions available/i.test(text);
+/**
+ * AunuBaileys: true when a decrypt failure text is a MAC verification
+ * failure ("Bad MAC") — the stored session/sender-key state and the
+ * sender's state disagree about the message authentication code, the
+ * classic symptom of a desynchronised ratchet on either side.
+ */
+export const isBadMacError = (text) => typeof text === 'string' && /bad mac/i.test(text);
 //# sourceMappingURL=decode-wa-message.js.map

package/lib/Utils/index.js

@@ -1,5 +1,6 @@
 export * from './generics.js';
 export * from './decode-wa-message.js';
+export * from './aunu-experimental.js';
 export * from './messages.js';
 export * from './messages-media.js';
 export * from './rich-message-utils.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "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",