aunubaileys 1.0.46 → 1.0.47

package/README.md

@@ -64,6 +64,10 @@ 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.

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/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/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.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",