lyxe-baileys 1.0.2 → 1.1.0

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-  <img src="https://raw.githubusercontent.com/noxXza/data/refs/heads/main/lyxe-baileys.png" width="400" alt="Lyxe Baileys Banner" />
+  <img src="https://i.ibb.co.com/fz44Z9Nz/images.jpg" width="400" alt="Lyxe Baileys Banner" />
   <br><br>
 
   <h1>lyxe-baileys</h1>
@@ -113,6 +113,98 @@ Baru di sini? Ini seluruh library dalam satu pandangan. Tiap baris menaut ke bag
 
 ---
 
+## 🚀 Fitur Eksklusif Lyxe Baileys
+
+### 1. 🛡️ Smart Anti-Ban & Humanizer
+Hindari pemblokiran akun dengan jeda acak manusiawi dan simulasi presence:
+```javascript
+import { smartDelay } from 'lyxe-baileys'
+
+// Jeda acak (misal 1000 - 2500ms)
+await sock.smartDelay(1000, 2500)
+
+// Simulasi mengetik otomatis sebelum pesan terkirim
+await sock.simulateTyping(jid, 2000)
+
+// Atau langsung kirim dengan opsi simulateTyping
+await sock.sendMessage(jid, { text: 'Halo! Ada yang bisa dibantu?' }, { simulateTyping: true })
+```
+
+### 2. 👁️ View-Once & Anti-Delete Retriever
+Bongkar media pesan 1x lihat (foto/video/audio) atau pulihkan pesan yang ditarik:
+```javascript
+// Download pesan View Once secara instan
+const { buffer, mediaType, caption } = await sock.downloadViewOnce(m)
+console.log(`Media ${mediaType} berhasil diunduh! Ukuran: ${buffer.length} bytes`)
+
+// Tangkap pesan yang dihapus pengirim dari store
+const original = sock.extractRevokedMessage(store, revocationMsg)
+if (original) {
+    console.log('Pesan yang ditarik:', original.message)
+}
+```
+
+### 3. 📢 WhatsApp Status / Story Supercharger
+Otomatis baca story, beri reaksi emoji, buat status mention, atau unggah voice note ke story:
+```javascript
+// Otomatis tandai status sudah dibaca dengan jeda alami
+await sock.readStatus(statusMessage, 1500)
+
+// Beri reaksi emoji ke story kontak
+await sock.reactStatus(statusMessage, '❤️')
+
+// Buat status teks/media dengan mention kontak tertentu
+await sock.sendStatusMention('Halo semua!', ['628123456789@s.whatsapp.net'])
+
+// Unggah Voice Note (VN) ke Status WhatsApp
+await sock.sendVoiceStatus(audioBuffer, { backgroundColor: '#7F5AF0' })
+```
+
+### 4. 🎙️ Media & Audio Helpers
+Kirim Voice Note (PTT) asli dengan animasi waveform, stiker, dan media HD:
+```javascript
+// Kirim rekaman suara (Voice Note PTT) lengkap dengan waveform
+await sock.sendVoiceNote(jid, './suara.mp3', quoted)
+
+// Kirim stiker instan
+await sock.sendImageAsSticker(jid, stickerBuffer, quoted)
+
+// Kirim foto/video kualitas HD resmi
+await sock.sendHDMedia(jid, { image: { url: './foto.jpg' }, caption: 'Kualitas HD' })
+```
+
+### 5. 🤖 AI Streaming Message
+Tampilkan pesan bertahap dengan animasi ketik langsung seperti ChatGPT/Gemini di WhatsApp:
+```javascript
+// Mengalirkan teks bertahap (AsyncIterable, generator, array, atau string)
+await sock.streamMessage(jid, aiTextStream, {
+    throttleMs: 350,
+    initialPlaceholder: '⏳ Sedang merangkai jawaban...',
+    quoted: m
+})
+```
+
+### 6. 📱 Multi-Session Manager
+Kelola banyak nomor bot WhatsApp sekaligus dalam satu script:
+```javascript
+import makeWASocket, { LyxeSessionManager, useMultiFileAuthState } from 'lyxe-baileys'
+
+const manager = new LyxeSessionManager({
+    createSocketFn: makeWASocket
+})
+
+// Buat dan jalankan sesi bot 1
+const { state, saveCreds } = await useMultiFileAuthState('./session-bot1')
+const sock1 = await manager.createSession('bot-1', { auth: state })
+
+// Tangkap pesan dari semua sesi sekaligus
+manager.on('messages.upsert', ({ sessionId, upsert, sock }) => {
+    console.log(`Pesan masuk di ${sessionId}`)
+})
+```
+
+---
+
 ## 📚 Daftar Isi
 
 - [Ringkasan](#-ringkasan)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lyxe-baileys",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Custom WhatsApp Multi-Device library by lyxe (forked from luna-baileys by noxXza)",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/Lyxe/ai-stream.js

@@ -0,0 +1,72 @@
+import { delay } from '../Utils/generics.js';
+
+/**
+ * Mengirim pesan dengan efek streaming (seperti animasi mengetik AI ChatGPT/Gemini).
+ * Pesan dikirim sekali lalu di-edit bertahap seiring potongan teks baru tiba.
+ *
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target chat
+ * @param {AsyncIterable<string>|string[]|Iterable<string>} stream Iterable teks/chunk
+ * @param {object} [options={}] Opsi
+ * @param {number} [options.throttleMs=350] Interval minimum antar edit agar tidak terkena rate-limit WA
+ * @param {string} [options.initialPlaceholder='⏳ Sedang berpikir...'] Teks awal saat proses mulai
+ * @param {any} [options.quoted] Pesan rujukan (quoted message)
+ * @returns {Promise<any>} Objek pesan terakhir yang dikirim
+ */
+export const streamMessage = async (sock, jid, stream, options = {}) => {
+    const throttleMs = options.throttleMs || 350;
+    const placeholder = options.initialPlaceholder || '⏳ Sedang berpikir...';
+
+    // Kirim pesan pertama
+    const sent = await sock.sendMessage(jid, { text: placeholder }, { quoted: options.quoted });
+    if (!sent?.key) return sent;
+
+    let accumulatedText = '';
+    let lastEditTime = Date.now();
+
+    const doEdit = async (text) => {
+        try {
+            await sock.sendMessage(jid, {
+                text: text,
+                edit: sent.key
+            });
+            lastEditTime = Date.now();
+        } catch {
+            // Abaikan error transien saat streaming edit
+        }
+    };
+
+    if (stream && typeof stream[Symbol.asyncIterator] === 'function') {
+        for await (const chunk of stream) {
+            accumulatedText += chunk;
+            const now = Date.now();
+            if (now - lastEditTime >= throttleMs) {
+                await doEdit(accumulatedText);
+            }
+        }
+    } else if (stream && typeof stream[Symbol.iterator] === 'function') {
+        for (const chunk of stream) {
+            accumulatedText += chunk;
+            const now = Date.now();
+            if (now - lastEditTime >= throttleMs) {
+                await doEdit(accumulatedText);
+                await delay(throttleMs);
+            }
+        }
+    } else if (typeof stream === 'string') {
+        // Jika diberikan full string, simulasikan streaming dengan memecah per kata
+        const words = stream.split(' ');
+        for (let i = 0; i < words.length; i += 3) {
+            accumulatedText = words.slice(0, i + 3).join(' ');
+            await doEdit(accumulatedText);
+            await delay(throttleMs);
+        }
+    }
+
+    // Pastikan teks akhir terkirim utuh
+    if (accumulatedText && accumulatedText !== placeholder) {
+        await doEdit(accumulatedText);
+    }
+
+    return sent;
+};

package/src/Lyxe/humanizer.js

@@ -0,0 +1,45 @@
+import { delay } from '../Utils/generics.js';
+
+/**
+ * Jeda acak manusiawi (Smart Delay) untuk menghindari deteksi spam WhatsApp.
+ * @param {number} minMs Waktu minimum (ms), default 800
+ * @param {number} maxMs Waktu maksimum (ms), default 2000
+ */
+export const smartDelay = (minMs = 800, maxMs = 2000) => {
+    const duration = Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;
+    return delay(duration);
+};
+
+/**
+ * Simulasi mengetik manusiawi (Composing presence).
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target jid
+ * @param {number} [durationMs] Durasi dalam ms. Jika tidak diisi, otomatis 1500 - 3500ms.
+ */
+export const simulateTyping = async (sock, jid, durationMs) => {
+    const time = durationMs || (Math.floor(Math.random() * 2000) + 1500);
+    try {
+        await sock.sendPresenceUpdate('composing', jid);
+        await delay(time);
+        await sock.sendPresenceUpdate('paused', jid);
+    } catch {
+        // Abaikan kegagalan presence jika koneksi sedang transisi
+    }
+};
+
+/**
+ * Simulasi merekam audio manusiawi (Recording presence).
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target jid
+ * @param {number} [durationMs] Durasi dalam ms, default 2000 - 4000ms.
+ */
+export const simulateRecording = async (sock, jid, durationMs) => {
+    const time = durationMs || (Math.floor(Math.random() * 2000) + 2000);
+    try {
+        await sock.sendPresenceUpdate('recording', jid);
+        await delay(time);
+        await sock.sendPresenceUpdate('paused', jid);
+    } catch {
+        // Abaikan jika presence gagal
+    }
+};

package/src/Lyxe/index.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import type { proto } from '../WAProto/index.js';
+
+export interface ViewOnceDownloadResult {
+    buffer: Buffer;
+    mediaType: 'image' | 'video' | 'audio';
+    caption: string;
+    mimetype: string;
+    fileName: string;
+}
+
+export declare const smartDelay: (minMs?: number, maxMs?: number) => Promise<void>;
+export declare const simulateTyping: (sock: any, jid: string, durationMs?: number) => Promise<void>;
+export declare const simulateRecording: (sock: any, jid: string, durationMs?: number) => Promise<void>;
+
+export declare const downloadViewOnce: (message: any) => Promise<ViewOnceDownloadResult>;
+export declare const extractRevokedMessage: (store: any, revocationMsg: any) => any | null;
+
+export declare const readStatus: (sock: any, statusMessage: any, delayMs?: number) => Promise<any>;
+export declare const reactStatus: (sock: any, statusMessageOrKey: any, emoji?: string) => Promise<any>;
+export declare const sendStatusMention: (sock: any, content: string | object, targetJids?: string[] | string, options?: any) => Promise<any>;
+export declare const sendVoiceStatus: (sock: any, audio: Buffer | { url: string } | string, options?: any) => Promise<any>;
+
+export declare const streamMessage: (sock: any, jid: string, stream: AsyncIterable<string> | Iterable<string> | string, options?: { throttleMs?: number; initialPlaceholder?: string; quoted?: any }) => Promise<any>;
+
+export declare const sendVoiceNote: (sock: any, jid: string, audio: Buffer | { url: string } | string, quoted?: any, options?: any) => Promise<any>;
+export declare const sendImageAsSticker: (sock: any, jid: string, sticker: Buffer | { url: string } | string, quoted?: any, options?: any) => Promise<any>;
+export declare const sendHDMedia: (sock: any, jid: string, mediaContent: { image?: any; video?: any; caption?: string }, options?: any) => Promise<any>;
+
+export declare class LyxeSessionManager {
+    constructor(options?: { baseConfig?: any; createSocketFn?: any });
+    setSocketFactory(fn: (config: any) => any): void;
+    createSession(sessionId: string, customConfig?: any): Promise<any>;
+    getSession(sessionId: string): any | null;
+    hasSession(sessionId: string): boolean;
+    deleteSession(sessionId: string): Promise<boolean>;
+    listSessions(): Array<{ id: string; createdAt: Date; hasSocket: boolean }>;
+}
+
+export declare const bindLyxeHelpers: (sock: any, config?: any) => any;

package/src/Lyxe/index.js

@@ -0,0 +1,68 @@
+import { smartDelay, simulateTyping, simulateRecording } from './humanizer.js';
+import { downloadViewOnce, extractRevokedMessage } from './view-once.js';
+import { readStatus, reactStatus, sendStatusMention, sendVoiceStatus } from './status-tools.js';
+import { streamMessage } from './ai-stream.js';
+import { sendVoiceNote, sendImageAsSticker, sendHDMedia } from './media-tools.js';
+import { LyxeSessionManager } from './session-manager.js';
+
+export {
+    smartDelay,
+    simulateTyping,
+    simulateRecording,
+    downloadViewOnce,
+    extractRevokedMessage,
+    readStatus,
+    reactStatus,
+    sendStatusMention,
+    sendVoiceStatus,
+    streamMessage,
+    sendVoiceNote,
+    sendImageAsSticker,
+    sendHDMedia,
+    LyxeSessionManager
+};
+
+/**
+ * Menyuntikkan seluruh helper Lyxe ke dalam instance socket Baileys.
+ * @param {any} sock Socket Baileys
+ * @param {any} config Konfigurasi koneksi
+ */
+export const bindLyxeHelpers = (sock, config = {}) => {
+    // 1. Smart Anti-Ban & Humanizer
+    sock.smartDelay = (minMs, maxMs) => smartDelay(minMs, maxMs);
+    sock.simulateTyping = (jid, durationMs) => simulateTyping(sock, jid, durationMs);
+    sock.simulateRecording = (jid, durationMs) => simulateRecording(sock, jid, durationMs);
+
+    // 2. Anti-Delete & View Once
+    sock.downloadViewOnce = (message) => downloadViewOnce(message);
+    sock.extractRevokedMessage = (store, revocationMsg) => extractRevokedMessage(store, revocationMsg);
+
+    // 3. Status / Story Tools
+    sock.readStatus = (statusMessage, delayMs) => readStatus(sock, statusMessage, delayMs);
+    sock.reactStatus = (statusMessageOrKey, emoji) => reactStatus(sock, statusMessageOrKey, emoji);
+    sock.sendStatusMention = (content, targetJids, options) => sendStatusMention(sock, content, targetJids, options);
+    sock.sendVoiceStatus = (audio, options) => sendVoiceStatus(sock, audio, options);
+
+    // 4. Media & Audio Tools
+    sock.sendVoiceNote = (jid, audio, quoted, options) => sendVoiceNote(sock, jid, audio, quoted, options);
+    sock.sendImageAsSticker = (jid, sticker, quoted, options) => sendImageAsSticker(sock, jid, sticker, quoted, options);
+    sock.sendHDMedia = (jid, mediaContent, options) => sendHDMedia(sock, jid, mediaContent, options);
+
+    // 5. AI Streaming
+    sock.streamMessage = (jid, stream, options) => streamMessage(sock, jid, stream, options);
+
+    // Otomatis inject opsi simulateTyping di sendMessage jika diaktifkan
+    const originalSendMessage = sock.sendMessage.bind(sock);
+    sock.sendMessage = async (jid, content, options = {}) => {
+        if (options.simulateTyping) {
+            const textLen = (typeof content === 'string' ? content : content?.text || '').length;
+            const duration = typeof options.simulateTyping === 'number'
+                ? options.simulateTyping
+                : Math.min(Math.max(textLen * 35, 1200), 4000);
+            await sock.simulateTyping(jid, duration);
+        }
+        return originalSendMessage(jid, content, options);
+    };
+
+    return sock;
+};

package/src/Lyxe/media-tools.js

@@ -0,0 +1,67 @@
+import { getAudioWaveform } from '../Utils/messages-media.js';
+
+/**
+ * Mengirim pesan audio sebagai Voice Note (PTT) asli dengan animasi gelombang suara.
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target jid
+ * @param {Buffer|{ url: string }|string} audio Buffer audio atau URL file audio
+ * @param {any} [quoted] Pesan rujukan (opsional)
+ * @param {object} [options={}] Opsi tambahan
+ */
+export const sendVoiceNote = async (sock, jid, audio, quoted, options = {}) => {
+    const audioPayload = Buffer.isBuffer(audio) ? audio : (typeof audio === 'string' ? { url: audio } : audio);
+
+    let waveform = options.waveform;
+    if (!waveform && Buffer.isBuffer(audioPayload)) {
+        try {
+            waveform = await getAudioWaveform(audioPayload, sock.logger);
+        } catch {
+            // Fallback default waveform jika decoder tidak tersedia
+            waveform = new Uint8Array([0, 15, 30, 65, 80, 95, 100, 75, 45, 20, 10, 0]);
+        }
+    } else if (!waveform) {
+        waveform = new Uint8Array([0, 15, 30, 65, 80, 95, 100, 75, 45, 20, 10, 0]);
+    }
+
+    return await sock.sendMessage(jid, {
+        audio: audioPayload,
+        mimetype: options.mimetype || 'audio/ogg; codecs=opus',
+        ptt: true,
+        waveform: waveform,
+        ...options
+    }, { quoted });
+};
+
+/**
+ * Mengirim stiker WhatsApp dari media WebP atau buffer gambar/video.
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target jid
+ * @param {Buffer|{ url: string }|string} sticker Buffer sticker atau URL
+ * @param {any} [quoted] Pesan rujukan
+ * @param {object} [options={}] Opsi tambahan
+ */
+export const sendImageAsSticker = async (sock, jid, sticker, quoted, options = {}) => {
+    const stickerPayload = Buffer.isBuffer(sticker) ? sticker : (typeof sticker === 'string' ? { url: sticker } : sticker);
+
+    return await sock.sendMessage(jid, {
+        sticker: stickerPayload,
+        mimetype: 'image/webp',
+        ...options
+    }, { quoted });
+};
+
+/**
+ * Mengirim gambar atau video dengan opsi kualitas HD resmi.
+ * @param {any} sock Socket Baileys
+ * @param {string} jid Target jid
+ * @param {{ image?: any, video?: any, caption?: string }} mediaContent Konten media
+ * @param {object} [options={}] Opsi pengiriman
+ */
+export const sendHDMedia = async (sock, jid, mediaContent, options = {}) => {
+    return await sock.sendMessage(jid, {
+        ...mediaContent,
+        viewOnce: false
+    }, {
+        ...options
+    });
+};

package/src/Lyxe/session-manager.js

@@ -0,0 +1,111 @@
+import { EventEmitter } from 'events';
+
+/**
+ * Manajer sesi multi-nomor terpadu untuk Lyxe Baileys.
+ * Memudahkan menjalankan beberapa bot WhatsApp dalam satu proses.
+ */
+export class LyxeSessionManager extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.sessions = new Map();
+        this.baseConfig = options.baseConfig || {};
+        this.createSocketFn = options.createSocketFn || null;
+    }
+
+    /**
+     * Daftarkan fungsi pembuat socket jika belum disetel di constructor.
+     * @param {Function} fn Fungsi makeWASocket
+     */
+    setSocketFactory(fn) {
+        this.createSocketFn = fn;
+    }
+
+    /**
+     * Menambahkan atau menginisialisasi sesi baru.
+     * @param {string} sessionId ID unik untuk sesi (misal: 'bot-1', 'cs-admin')
+     * @param {object} [customConfig={}] Konfigurasi khusus untuk sesi ini
+     */
+    async createSession(sessionId, customConfig = {}) {
+        if (this.sessions.has(sessionId)) {
+            return this.sessions.get(sessionId);
+        }
+
+        if (typeof this.createSocketFn !== 'function') {
+            throw new Error('LyxeSessionManager: Socket factory belum disetel. Jalankan manager.setSocketFactory(makeWASocket)');
+        }
+
+        const mergedConfig = {
+            ...this.baseConfig,
+            ...customConfig
+        };
+
+        const sock = this.createSocketFn(mergedConfig);
+        sock.sessionId = sessionId;
+
+        // Forward event ke session manager
+        sock.ev.on('connection.update', (update) => {
+            this.emit('connection.update', { sessionId, update });
+        });
+
+        sock.ev.on('messages.upsert', (upsert) => {
+            this.emit('messages.upsert', { sessionId, upsert, sock });
+        });
+
+        this.sessions.set(sessionId, {
+            id: sessionId,
+            sock: sock,
+            config: mergedConfig,
+            createdAt: new Date()
+        });
+
+        this.emit('session.created', { sessionId, sock });
+        return sock;
+    }
+
+    /**
+     * Mengambil instance socket dari sesi yang sedang aktif.
+     * @param {string} sessionId
+     */
+    getSession(sessionId) {
+        const item = this.sessions.get(sessionId);
+        return item ? item.sock : null;
+    }
+
+    /**
+     * Memeriksa apakah sesi sedang terdaftar.
+     * @param {string} sessionId
+     */
+    hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+
+    /**
+     * Menghapus sesi dan menutup koneksinya.
+     * @param {string} sessionId
+     */
+    async deleteSession(sessionId) {
+        const item = this.sessions.get(sessionId);
+        if (!item) return false;
+
+        try {
+            item.sock?.end?.();
+        } catch {
+            // abaikan
+        }
+
+        this.sessions.delete(sessionId);
+        this.emit('session.deleted', { sessionId });
+        return true;
+    }
+
+    /**
+     * Mengambil daftar seluruh sesi yang aktif beserta statusnya.
+     */
+    listSessions() {
+        return Array.from(this.sessions.values()).map(item => ({
+            id: item.id,
+            createdAt: item.createdAt,
+            hasSocket: !!item.sock
+        }));
+    }
+}

package/src/Lyxe/status-tools.js

@@ -0,0 +1,75 @@
+import { delay } from '../Utils/generics.js';
+
+/**
+ * Membaca status/story WhatsApp dengan jeda alami (Auto Read Story).
+ * @param {any} sock Socket Baileys
+ * @param {any} statusMessage Objek pesan status atau key status
+ * @param {number} [delayMs=1500] Jeda sebelum menandai dibaca (ms)
+ */
+export const readStatus = async (sock, statusMessage, delayMs = 1500) => {
+    if (delayMs > 0) {
+        await delay(delayMs);
+    }
+    const key = statusMessage?.key || statusMessage;
+    if (!key) throw new Error('readStatus: key status tidak valid');
+    return await sock.readMessages([key]);
+};
+
+/**
+ * Memberi reaksi emoji ke status WhatsApp pengguna.
+ * @param {any} sock Socket Baileys
+ * @param {any} statusMessageOrKey Pesan status atau key status
+ * @param {string} [emoji='❤️'] Emoji reaksi
+ */
+export const reactStatus = async (sock, statusMessageOrKey, emoji = '❤️') => {
+    const key = statusMessageOrKey?.key || statusMessageOrKey;
+    if (!key) throw new Error('reactStatus: key status tidak valid');
+
+    const participant = key.participant || key.remoteJid;
+    return await sock.sendMessage('status@broadcast', {
+        react: {
+            text: emoji,
+            key: key
+        }
+    }, {
+        statusJidList: [participant]
+    });
+};
+
+/**
+ * Membuat status WhatsApp baru dengan men-tag/mention nomor tertentu.
+ * @param {any} sock Socket Baileys
+ * @param {string|object} content Teks status atau objek pesan media
+ * @param {string[]|string} targetJids Daftar JID kontak yang di-mention
+ * @param {object} [options={}] Opsi tambahan sendMessage
+ */
+export const sendStatusMention = async (sock, content, targetJids = [], options = {}) => {
+    const msg = typeof content === 'string' ? { text: content } : content;
+    const jidList = Array.isArray(targetJids) ? targetJids : [targetJids];
+
+    return await sock.sendMessage('status@broadcast', msg, {
+        statusJidList: jidList,
+        ...options
+    });
+};
+
+/**
+ * Mengirim status rekaman suara (Voice Note Status) ke status WhatsApp.
+ * @param {any} sock Socket Baileys
+ * @param {Buffer|{ url: string }} audio Buffer audio atau URL
+ * @param {object} [options={}] Opsi (backgroundColor, statusJidList, waveform)
+ */
+export const sendVoiceStatus = async (sock, audio, options = {}) => {
+    const audioPayload = Buffer.isBuffer(audio) ? audio : (typeof audio === 'string' ? { url: audio } : audio);
+
+    return await sock.sendMessage('status@broadcast', {
+        audio: audioPayload,
+        mimetype: 'audio/mp4',
+        ptt: true,
+        backgroundColor: options.backgroundColor || '#7F5AF0',
+        waveform: options.waveform || new Uint8Array([0, 10, 25, 45, 70, 90, 100, 80, 50, 30, 10, 0]),
+        ...options
+    }, {
+        statusJidList: options.statusJidList || []
+    });
+};

package/src/Lyxe/view-once.js

@@ -0,0 +1,82 @@
+import { downloadContentFromMessage, toBuffer } from '../Utils/messages-media.js';
+
+/**
+ * Mengunduh media dari pesan View Once (1x lihat) otomatis.
+ * Mendukung ViewOnce foto, video, dan audio.
+ * @param {any} message Objek pesan (baik WAMessage atau WAMessage.message)
+ * @returns {Promise<{ buffer: Buffer, mediaType: 'image'|'video'|'audio', caption: string, mimetype: string, fileName: string }>}
+ */
+export const downloadViewOnce = async (message) => {
+    const raw = message?.message || message;
+    if (!raw) {
+        throw new Error('downloadViewOnce: format pesan tidak valid');
+    }
+
+    const viewOnce = raw.viewOnceMessage?.message ||
+                     raw.viewOnceMessageV2?.message ||
+                     raw.viewOnceMessageV2Extension?.message ||
+                     raw;
+
+    let mediaType = null;
+    let mediaMsg = null;
+
+    if (viewOnce.imageMessage) {
+        mediaType = 'image';
+        mediaMsg = viewOnce.imageMessage;
+    } else if (viewOnce.videoMessage) {
+        mediaType = 'video';
+        mediaMsg = viewOnce.videoMessage;
+    } else if (viewOnce.audioMessage) {
+        mediaType = 'audio';
+        mediaMsg = viewOnce.audioMessage;
+    } else {
+        throw new Error('downloadViewOnce: media View Once tidak ditemukan di dalam pesan ini');
+    }
+
+    const stream = await downloadContentFromMessage(mediaMsg, mediaType);
+    const buffer = await toBuffer(stream);
+
+    return {
+        buffer,
+        mediaType,
+        caption: mediaMsg.caption || '',
+        mimetype: mediaMsg.mimetype || '',
+        fileName: mediaMsg.fileName || (mediaType === 'image' ? 'viewonce.jpg' : mediaType === 'video' ? 'viewonce.mp4' : 'viewonce.ogg')
+    };
+};
+
+/**
+ * Mengambil kembali pesan yang ditarik/dihapus (Revoked Message) dari memory store.
+ * @param {any} store In-Memory Store Baileys
+ * @param {any} revocationMsg Pesan pembatalan (ProtocolMessage REVOKE)
+ * @returns {any|null} Pesan asli sebelum ditarik, atau null jika tidak ditemukan
+ */
+export const extractRevokedMessage = (store, revocationMsg) => {
+    const raw = revocationMsg?.message || revocationMsg;
+    const protocolMsg = raw?.protocolMessage;
+    // Type 0 adalah REVOKE di WhatsApp protocol
+    if (!protocolMsg || protocolMsg.type !== 0) {
+        return null;
+    }
+
+    const key = protocolMsg.key;
+    if (!key) return null;
+
+    const chatId = key.remoteJid;
+    const msgId = key.id;
+
+    if (store && typeof store.loadMessage === 'function') {
+        const found = store.loadMessage(chatId, msgId);
+        if (found) return found;
+    }
+
+    if (store && store.messages && store.messages[chatId]) {
+        const list = store.messages[chatId].array || store.messages[chatId];
+        if (Array.isArray(list)) {
+            const found = list.find(x => x.key?.id === msgId);
+            if (found) return found;
+        }
+    }
+
+    return null;
+};

package/src/Socket/index.js

@@ -1,7 +1,8 @@
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
 import { prepareModernMessageContent } from '../Utils/modern-messages.js';
 import { makeNewsletterStatusFetcher, makeNewsletterStatusUpdatesFetcher, makeNewsletterStatusReactionSender, makeNewsletterStatusRevokeSender, makeNewsletterStatusSender } from '../Utils/newsletter-status.js';
-import { bindVoiceRecognition } from '../Utils/voice-recognition.js';
+import { bindVoiceRecognition } from '../Utils/voice-recognition.js';
+import { bindLyxeHelpers } from '../Lyxe/index.js';
 import { makeCommunitiesSocket } from './communities.js';
 import { makeEmailCoordinator } from './email.js';
 import { makeMobileCoordinator } from './mobile.js';
@@ -22,7 +23,8 @@ const makeWASocket = (config) => {
     sock.sendNewsletterStatusReaction = makeNewsletterStatusReactionSender(sock);
     sock.revokeNewsletterStatus = makeNewsletterStatusRevokeSender(sock);
     sock.getNewsletterStatuses = makeNewsletterStatusFetcher(sock);
-    sock.getNewsletterStatusUpdates = makeNewsletterStatusUpdatesFetcher(sock);
+    sock.getNewsletterStatusUpdates = makeNewsletterStatusUpdatesFetcher(sock);
+    bindLyxeHelpers(sock, newConfig);
     if (newConfig.AnchorGuard) {
         import('@rexxhayanasi/elaina-anchorguard')
             .then(({ createAntiBugGuard }) => {

package/src/index.d.ts

@@ -10,7 +10,8 @@ export * from "./MessageBuilder/index.js";
 export * from "./MessageBuilder/extras.js";
 export * from "./MessageBuilder/metaai.js";
 export * from "./MessageBuilder/bot-signature.js";
-export * from "./Voip/index.js";
+export * from "./Voip/index.js";
+export * from "./Lyxe/index.js";
 import baseMakeWASocket from './Socket/index.js';
 import type { NewsletterStatusFetchOptions, NewsletterStatusList, NewsletterStatusSendOptions, NewsletterStatusSendResult, NewsletterStatusStanzaResult, NewsletterStatusUpdatesFetchOptions } from './Utils/newsletter-status.js';
 type BaseWASocket = ReturnType<typeof baseMakeWASocket>;
@@ -19,7 +20,20 @@ export type WASocket = BaseWASocket & {
     sendNewsletterStatusReaction: (jid: string, parentServerId: string | number, reaction: string, options?: Pick<NewsletterStatusSendOptions, 'messageId' | 'ackTimeoutMs'>) => Promise<NewsletterStatusStanzaResult>;
     revokeNewsletterStatus: (jid: string, statusId: string, options?: Pick<NewsletterStatusSendOptions, 'ackTimeoutMs'>) => Promise<NewsletterStatusStanzaResult>;
     getNewsletterStatuses: (jid: string, options?: NewsletterStatusFetchOptions) => Promise<NewsletterStatusList>;
-    getNewsletterStatusUpdates: (jid: string, options?: NewsletterStatusUpdatesFetchOptions) => Promise<NewsletterStatusList>;
+    getNewsletterStatusUpdates: (jid: string, options?: NewsletterStatusUpdatesFetchOptions) => Promise<NewsletterStatusList>;
+    smartDelay: (minMs?: number, maxMs?: number) => Promise<void>;
+    simulateTyping: (jid: string, durationMs?: number) => Promise<void>;
+    simulateRecording: (jid: string, durationMs?: number) => Promise<void>;
+    downloadViewOnce: (message: any) => Promise<import('./Lyxe/index.js').ViewOnceDownloadResult>;
+    extractRevokedMessage: (store: any, revocationMsg: any) => any | null;
+    readStatus: (statusMessage: any, delayMs?: number) => Promise<any>;
+    reactStatus: (statusMessageOrKey: any, emoji?: string) => Promise<any>;
+    sendStatusMention: (content: string | object, targetJids?: string[] | string, options?: any) => Promise<any>;
+    sendVoiceStatus: (audio: Buffer | { url: string } | string, options?: any) => Promise<any>;
+    sendVoiceNote: (jid: string, audio: Buffer | { url: string } | string, quoted?: any, options?: any) => Promise<any>;
+    sendImageAsSticker: (jid: string, sticker: Buffer | { url: string } | string, quoted?: any, options?: any) => Promise<any>;
+    sendHDMedia: (jid: string, mediaContent: { image?: any; video?: any; caption?: string }, options?: any) => Promise<any>;
+    streamMessage: (jid: string, stream: AsyncIterable<string> | Iterable<string> | string, options?: { throttleMs?: number; initialPlaceholder?: string; quoted?: any }) => Promise<any>;
 };
 export declare const makeWASocket: (config: Parameters<typeof baseMakeWASocket>[0]) => WASocket;
 export default makeWASocket;

package/src/index.js

@@ -18,7 +18,8 @@ export * from './MessageBuilder/index.js';
 export * from './MessageBuilder/extras.js';
 export * from './MessageBuilder/metaai.js';
 export * from './MessageBuilder/bot-signature.js';
-export * from './Voip/index.js';
+export * from './Voip/index.js';
+export * from './Lyxe/index.js';
 
 const builderMembers = [
     ...Object.entries(messageBuilderExtras),