aunubaileys 1.0.45 → 1.0.47

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.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.
+
 ### 🆕 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`.

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, 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, 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';
@@ -758,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);
@@ -782,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()
                                         });

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

@@ -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

@@ -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.45",
+  "version": "1.0.47",
   "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",