@kangwifi-pro/waliwa 1.0.0

package/dist/socket/wa-socket.js

@@ -0,0 +1,1094 @@
+"use strict";
+/**
+ * Waliwa - Main WASocket interface
+ * Entry point untuk WhatsApp bot - gabungin semua components (WebSocket, Auth, Messages, Groups, Calls)
+ *
+ * API Baileys-style dengan RAM optimization:
+ * - Lazy initialization
+ * - Buffer pooling
+ * - Debounced writes
+ * - Event-driven (no polling overhead)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WASocketImpl = void 0;
+exports.makeWASocket = makeWASocket;
+const ws_socket_js_1 = require("../socket/ws-socket.js");
+const binary_js_1 = require("../core/binary.js");
+const emitter_js_1 = require("../events/emitter.js");
+const send_js_1 = require("../messages/send.js");
+const media_js_1 = require("../messages/media.js");
+const management_js_1 = require("../groups/management.js");
+const handler_js_1 = require("../calls/handler.js");
+const auth_state_js_1 = require("../auth/auth-state.js");
+const qr_code_js_1 = require("../auth/qr-code.js");
+const pairing_code_js_1 = require("../auth/pairing-code.js");
+const jid_js_1 = require("../utils/jid.js");
+const logger_js_1 = require("../utils/logger.js");
+const retry_js_1 = require("../utils/retry.js");
+// SKDM imports
+const index_js_1 = require("../skdm/index.js");
+// Fixes imports
+const index_js_2 = require("../fixes/index.js");
+// Features imports
+const index_js_3 = require("../features/index.js");
+// Recovery imports
+const index_js_4 = require("../recovery/index.js");
+// ============== WASocket Implementation ==============
+class WASocketImpl {
+    ev;
+    authState;
+    user;
+    logger;
+    ws = null;
+    config;
+    messageSender;
+    messageReceiver;
+    mediaUploader;
+    mediaDownloader;
+    groupManager = null;
+    callHandler = null;
+    pendingTracker;
+    iqHandlers = new Map();
+    qrRefreshManager = null;
+    rateLimiter;
+    connectionState = 'close';
+    // SKDM
+    skdm = null;
+    // Fixes
+    heartbeat = null;
+    idempotencyCache;
+    groupEventCoalescer = null;
+    historySyncManager;
+    decryptionRetryQueue = null;
+    messageQueue;
+    chunkedUploader;
+    reconnector = null;
+    // Features
+    healthMonitor;
+    webhookManager;
+    circuitBreaker;
+    rateLimitTracker;
+    messagePersistence;
+    // Recovery (Multi-Branch SKDM Recovery)
+    recoveryManager;
+    // Auto-recovery timer
+    reconnectTimer = null;
+    reconnectAttempts = 0;
+    constructor(config = {}, authState) {
+        this.ev = new emitter_js_1.WAEventEmitter();
+        this.authState = authState;
+        this.logger = config.logger ?? logger_js_1.defaultLogger;
+        // Default config
+        this.config = {
+            authState,
+            logger: this.logger,
+            printQRInTerminal: config.printQRInTerminal ?? false,
+            mobile: config.mobile ?? false,
+            phoneNumber: config.phoneNumber,
+            browser: config.browser ?? ['Waliwa', 'WA', '1.0.0'],
+            reconnectInterval: config.reconnectInterval ?? 2000,
+            maxReconnectAttempts: config.maxReconnectAttempts ?? 10,
+            syncFullHistory: config.syncFullHistory ?? false,
+            maxMsgRetryCount: config.maxMsgRetryCount ?? 5,
+            wsURL: config.wsURL ?? 'wss://web.whatsapp.com/ws/chat',
+            connectTimeoutMs: config.connectTimeoutMs ?? 20000,
+            keepAliveIntervalMs: config.keepAliveIntervalMs ?? 20000,
+            ramOptimizationLevel: config.ramOptimizationLevel ?? 2,
+            markOnlineOnConnect: config.markOnlineOnConnect ?? true,
+            fetchAgent: config.fetchAgent
+        };
+        this.pendingTracker = new send_js_1.PendingMessageTracker();
+        this.messageSender = new send_js_1.MessageSender({
+            send: (data) => this.send(data),
+            logger: this.logger,
+            tracker: this.pendingTracker
+        });
+        this.messageReceiver = new send_js_1.MessageReceiver({
+            logger: this.logger,
+            onMessage: (messages, type) => {
+                this.ev.emit('message.upsert', { messages, type });
+            },
+            onStatusUpdate: (key, status) => {
+                this.ev.emit('message.update', {
+                    messages: [{ key, status }],
+                    keys: [key]
+                });
+            }
+        });
+        this.mediaUploader = new media_js_1.MediaUploader({
+            logger: this.logger,
+            httpAgent: this.config.fetchAgent
+        });
+        this.mediaDownloader = new media_js_1.MediaDownloader({
+            logger: this.logger,
+            httpAgent: this.config.fetchAgent
+        });
+        // Rate limiter: 20 messages/sec
+        this.rateLimiter = new retry_js_1.RateLimiter(20);
+        // Initialize fixes (Baileys issues)
+        this.idempotencyCache = new index_js_2.IdempotencyCache(10000, 24 * 60 * 60 * 1000, this.logger);
+        this.historySyncManager = new index_js_2.HistorySyncManager(this.logger);
+        this.messageQueue = new index_js_2.MessageQueue(10, this.logger);
+        this.chunkedUploader = new index_js_2.ChunkedMediaUploader({ logger: this.logger });
+        // Initialize features
+        this.healthMonitor = new index_js_3.HealthMonitor({ logger: this.logger });
+        this.webhookManager = new index_js_3.WebhookManager({ logger: this.logger });
+        this.circuitBreaker = new index_js_3.CircuitBreaker({ logger: this.logger });
+        this.rateLimitTracker = new index_js_3.RateLimitTracker({ logger: this.logger });
+        this.messagePersistence = new index_js_3.MessagePersistence({ logger: this.logger });
+        // Initialize SKDM (Store Key Data Manager)
+        this.skdm = new index_js_1.SKDM(this.authState.creds, this.authState.keys, {
+            storageFolder: './auth',
+            logger: this.logger,
+            ...config
+        });
+        // Initialize Multi-Branch SKDM Recovery system
+        const recoveryConfig = config.recovery ?? {};
+        this.recoveryManager = new index_js_4.RecoveryManager({
+            enabled: recoveryConfig.enabled ?? true,
+            maxAttemptsPerBranch: recoveryConfig.maxAttemptsPerBranch ?? 3,
+            maxTotalAttempts: recoveryConfig.maxTotalAttempts ?? 20,
+            initialDelayMs: recoveryConfig.initialDelayMs ?? 1000,
+            maxDelayMs: recoveryConfig.maxDelayMs ?? 60000,
+            rateLimitedDelayMs: recoveryConfig.rateLimitedDelayMs ?? 300000,
+            logger: this.logger
+        });
+        // Bind recovery action handlers ke WASocket internals
+        this.setupRecoveryHandlers();
+        // Listen ke recovery events untuk forwarding ke main event emitter
+        this.recoveryManager.on('recovery:start', (info) => {
+            this.logger.info(`Recovery started: ${info.reason}`);
+            this.ev.emit('connection.update', {
+                connection: 'connecting',
+                lastDisconnect: { error: undefined, output: { code: info.code, reason: info.message } }
+            });
+        });
+        this.recoveryManager.on('recovery:success', (info) => {
+            this.logger.info(`Recovery succeeded: ${info.reason} (${info.totalAttempts} attempts)`);
+            this.healthMonitor.recordReconnect();
+        });
+        this.recoveryManager.on('recovery:failed', (info) => {
+            this.logger.error(`Recovery failed: ${info.reason} (fatal: ${info.fatal})`);
+            if (info.fatal) {
+                this.ev.emit('connection.update', {
+                    connection: 'close',
+                    lastDisconnect: {
+                        error: new Error(`Fatal disconnect: ${info.reason}`),
+                        output: { code: 0, reason: info.reason }
+                    }
+                });
+            }
+        });
+    }
+    /**
+     * Setup recovery handlers - bind ke internal WASocket methods
+     */
+    setupRecoveryHandlers() {
+        // Connect action
+        this.recoveryManager.connect = async () => {
+            try {
+                if (this.ws) {
+                    this.ws.close(4000, 'reconnect');
+                    this.ws = null;
+                }
+                await this.connect();
+                return this.connectionState === 'open';
+            }
+            catch (err) {
+                this.logger.error(`Recovery connect failed: ${err.message}`);
+                return false;
+            }
+        };
+        // Stream reconnect (resume from stream state)
+        this.recoveryManager.streamReconnect = async () => {
+            try {
+                this.logger.info('Attempting stream reconnect (resume session)...');
+                // Reconnect tapi keep session state
+                if (this.ws) {
+                    this.ws.close(4000, 'stream_reconnect');
+                    this.ws = null;
+                }
+                // Quick reconnect dengan credentials yang sudah ada
+                await this.connect();
+                return this.connectionState === 'open';
+            }
+            catch (err) {
+                this.logger.error(`Stream reconnect failed: ${err.message}`);
+                return false;
+            }
+        };
+        // Key refresh via SKDM
+        this.recoveryManager.refreshKeys = async () => {
+            try {
+                this.logger.info('Refreshing Signal keys via SKDM...');
+                if (this.skdm) {
+                    await this.skdm.preKeyManager.regeneratePreKeys();
+                    this.skdm.markKeysDirty();
+                    this.skdm.markCredsDirty();
+                    await this.skdm.flush();
+                }
+            }
+            catch (err) {
+                this.logger.error(`Key refresh failed: ${err.message}`);
+            }
+        };
+        // Pre-key fetch
+        this.recoveryManager.fetchPreKeys = async () => {
+            try {
+                this.logger.info('Fetching pre-keys...');
+                if (this.skdm) {
+                    await this.skdm.preKeyManager.regeneratePreKeys();
+                    // Force upload ke server (will happen on next connect)
+                }
+            }
+            catch (err) {
+                this.logger.error(`Pre-key fetch failed: ${err.message}`);
+            }
+        };
+        // Full re-auth (new QR)
+        this.recoveryManager.startFullReauth = async () => {
+            try {
+                this.logger.info('Starting full re-authentication...');
+                // Clear existing creds untuk force new QR
+                if (this.skdm) {
+                    // Keep noiseKey, tapi reset registration state
+                    this.authState.creds.registered = false;
+                    this.authState.creds.serverToken = undefined;
+                    this.authState.creds.clientToken = undefined;
+                    this.skdm.markCredsDirty();
+                    await this.skdm.flush();
+                }
+                // Next connect akan trigger QR auth
+            }
+            catch (err) {
+                this.logger.error(`Full re-auth setup failed: ${err.message}`);
+            }
+        };
+        // Update app version
+        this.recoveryManager.updateAppVersion = async () => {
+            try {
+                this.logger.info('Updating app/browser version...');
+                // Bump version untuk bypass version-restricted endpoints
+                const versions = ['1.0.0', '1.1.0', '1.2.0', '2.0.0'];
+                const currentVersion = this.config.browser[2];
+                const currentIdx = versions.indexOf(currentVersion);
+                const newVersion = versions[Math.min(currentIdx + 1, versions.length - 1)] ?? '2.0.0';
+                this.config.browser = [this.config.browser[0], this.config.browser[1], newVersion];
+                this.logger.info(`App version updated to ${newVersion}`);
+            }
+            catch (err) {
+                this.logger.error(`Update app version failed: ${err.message}`);
+            }
+        };
+    }
+    // ============== Connection ==============
+    /**
+     * Start connection ke WhatsApp server
+     */
+    async connect() {
+        if (this.connectionState === 'open' || this.connectionState === 'connecting') {
+            return;
+        }
+        this.connectionState = 'connecting';
+        this.ev.emit('connection.update', { connection: 'connecting' });
+        try {
+            // Create WebSocket
+            this.ws = new ws_socket_js_1.WAWebSocket({
+                url: this.config.wsURL,
+                logger: this.logger,
+                browser: this.config.browser,
+                connectTimeoutMs: this.config.connectTimeoutMs,
+                keepAliveIntervalMs: this.config.keepAliveIntervalMs,
+                noiseKey: this.authState.creds.noiseKey,
+                ramLevel: this.config.ramOptimizationLevel
+            });
+            // Listen for messages
+            this.ws.on('message', (data) => this.handleIncomingData(data));
+            this.ws.on('close', (code, reason) => this.handleDisconnect(code, reason));
+            this.ws.on('error', (err) => {
+                this.logger.error(`Socket error: ${err.message}`);
+                this.ev.emit('connection.update', {
+                    connection: 'close',
+                    lastDisconnect: { error: err, output: { code: 0, reason: err.message } }
+                });
+            });
+            await this.ws.connect();
+            this.connectionState = 'open';
+            this.logger.info('WhatsApp connection established');
+            // Initialize group manager & call handler
+            this.groupManager = new management_js_1.GroupManager({
+                send: (data) => this.send(data),
+                logger: this.logger,
+                registerIqHandler: (id, handler) => {
+                    this.iqHandlers.set(id, handler);
+                }
+            });
+            this.callHandler = new handler_js_1.CallHandler({
+                send: (data) => this.send(data),
+                logger: this.logger,
+                onCall: (event) => this.ev.emit('calls', event),
+                autoReject: false
+            });
+            // Start auth flow
+            if (!this.authState.creds.registered) {
+                if (this.config.mobile && this.config.phoneNumber) {
+                    await this.requestPairingCode(this.config.phoneNumber);
+                }
+                else {
+                    await this.startQRAuth();
+                }
+            }
+            else {
+                // Already registered - send login
+                await this.sendLogin();
+            }
+            // Initialize SKDM dan start background jobs
+            await this.skdm?.initialize();
+            // Start heartbeat (Baileys fix #4: connection hang)
+            this.heartbeat = new index_js_2.ConnectionHeartbeat({
+                sendPing: async () => {
+                    // Send WA ping frame
+                    const { encodeBinaryNode } = await import('../core/binary.js');
+                    const pingNode = {
+                        tag: 'iq',
+                        attrs: { type: 'get', id: `ping-${Date.now()}` },
+                        content: [{ tag: 'ping', attrs: {} }]
+                    };
+                    this.send(encodeBinaryNode(pingNode));
+                },
+                onDead: () => {
+                    this.logger.error('Connection detected as dead, triggering reconnect');
+                    this.handleDisconnect(4101, 'heartbeat dead');
+                },
+                logger: this.logger,
+                pingIntervalMs: this.config.keepAliveIntervalMs,
+                pongTimeoutMs: 10000,
+                maxMissedPongs: 3
+            });
+            this.heartbeat.start();
+            // Start group event coalescer (Baileys fix #7: group events missing)
+            this.groupEventCoalescer = new index_js_2.GroupEventCoalescer((events) => {
+                for (const event of events) {
+                    this.ev.emit('group-participants.update', event);
+                }
+            }, 100, this.logger);
+            // Start health monitor
+            this.healthMonitor.start(60000);
+            this.healthMonitor.recordPing();
+            // Send pending messages dari persistence (recover after restart)
+            const pendingMessages = this.messagePersistence.getPending();
+            if (pendingMessages.length > 0) {
+                this.logger.info(`Recovering ${pendingMessages.length} pending messages from persistence`);
+                for (const msg of pendingMessages) {
+                    // Re-queue untuk send
+                    this.sendMessage(msg.recipientJid, msg.content).catch(err => {
+                        this.logger.error(`Failed to recover message ${msg.id}: ${err.message}`);
+                    });
+                }
+            }
+            this.ev.emit('connection.update', { connection: 'open' });
+        }
+        catch (err) {
+            this.connectionState = 'close';
+            this.logger.error(`Connect failed: ${err.message}`);
+            this.ev.emit('connection.update', {
+                connection: 'close',
+                lastDisconnect: { error: err, output: { code: 0, reason: err.message } }
+            });
+            throw err;
+        }
+    }
+    /**
+     * Handle incoming data dari WebSocket
+     */
+    handleIncomingData(data) {
+        try {
+            const node = (0, binary_js_1.decodeBinaryNode)(data);
+            if (!node)
+                return;
+            // Record activity for heartbeat (Baileys fix #4)
+            this.heartbeat?.receivedPong();
+            this.healthMonitor.recordPing();
+            this.healthMonitor.recordReceive();
+            // Trigger webhook untuk incoming node (Features: webhook system)
+            this.webhookManager.trigger('node.received', { tag: node.tag, attrs: node.attrs });
+            // Check if it's an IQ response
+            if (node.tag === 'iq' && node.attrs?.id) {
+                // Check if it's a pong response
+                if (node.attrs.id?.startsWith('ping-')) {
+                    this.heartbeat?.receivedPong();
+                    return;
+                }
+                const handler = this.iqHandlers.get(node.attrs.id);
+                if (handler) {
+                    this.iqHandlers.delete(node.attrs.id);
+                    handler(node);
+                    return;
+                }
+            }
+            // Handle by tag
+            switch (node.tag) {
+                case 'message': {
+                    // Baileys fix #6: duplicate messages - check idempotency
+                    const messageId = node.attrs?.id;
+                    if (messageId && this.idempotencyCache.isDuplicate(messageId)) {
+                        this.logger.debug(`Skipping duplicate message: ${messageId}`);
+                        return;
+                    }
+                    this.messageReceiver.handleNode(node);
+                    break;
+                }
+                case 'receipt':
+                case 'status':
+                case 'ack':
+                    this.messageReceiver.handleNode(node);
+                    break;
+                case 'call':
+                    this.callHandler?.handleCallNode(node);
+                    break;
+                case 'chat':
+                    this.handleChatNode(node);
+                    break;
+                case 'presence':
+                    this.handlePresenceNode(node);
+                    break;
+                case 'notification':
+                    this.handleNotificationNode(node);
+                    break;
+                case 'success':
+                    this.logger.info('Authentication successful');
+                    if (node.attrs?.user) {
+                        this.user = { id: node.attrs.user, name: node.attrs.pushname };
+                        this.authState.creds.me = node.attrs.user;
+                        this.authState.creds.registered = true;
+                        this.skdm?.markCredsDirty();
+                    }
+                    this.ev.emit('creds.update', this.authState.creds);
+                    this.webhookManager.trigger('auth.success', { user: this.user });
+                    break;
+                case 'failure':
+                    this.logger.error('Authentication failed');
+                    this.ev.emit('connection.update', {
+                        connection: 'close',
+                        lastDisconnect: { error: new Error('Auth failed'), output: node.attrs }
+                    });
+                    this.webhookManager.trigger('auth.failure', { attrs: node.attrs });
+                    break;
+                default:
+                    this.logger.trace(`Unhandled top-level node: ${node.tag}`);
+            }
+        }
+        catch (err) {
+            this.logger.error(`Failed to process incoming data: ${err.message}`);
+        }
+    }
+    handleChatNode(node) {
+        const attrs = node.attrs || {};
+        // Chat presence: typing, recording
+        const from = attrs.from;
+        if (attrs.type === 'composing' || attrs.type === 'recording' || attrs.type === 'paused') {
+            this.ev.emit('presence.update', {
+                jid: from,
+                presence: attrs.type
+            });
+        }
+    }
+    handlePresenceNode(node) {
+        const attrs = node.attrs || {};
+        const from = attrs.from;
+        const type = attrs.type;
+        if (from && type) {
+            this.ev.emit('presence.update', {
+                jid: from,
+                presence: type,
+                t: attrs.t ? parseInt(attrs.t, 10) : undefined
+            });
+        }
+    }
+    handleNotificationNode(node) {
+        const attrs = node.attrs || {};
+        const type = attrs.type;
+        if (Array.isArray(node.content)) {
+            for (const child of node.content) {
+                if (typeof child !== 'object' || !child.tag)
+                    continue;
+                switch (child.tag) {
+                    case 'add':
+                    case 'remove':
+                    case 'promote':
+                    case 'demote':
+                        // Group participant update
+                        const participants = Array.isArray(child.content)
+                            ? child.content.filter(c => c?.tag === 'participant').map(c => c.attrs?.jid).filter(Boolean)
+                            : [];
+                        this.ev.emit('group-participants.update', {
+                            id: attrs.from,
+                            participants,
+                            action: child.tag,
+                            author: attrs.participant,
+                            timestamp: Date.now()
+                        });
+                        break;
+                    case 'subject':
+                        // Group subject updated
+                        this.ev.emit('groups.update', [{
+                                id: attrs.from,
+                                subject: child.attrs?.subject
+                            }]);
+                        break;
+                }
+            }
+        }
+    }
+    handleDisconnect(code, reason) {
+        this.connectionState = 'close';
+        this.pendingTracker.rejectAll(new Error(`Connection closed: ${code}`));
+        // Cleanup heartbeat
+        this.heartbeat?.stop();
+        this.heartbeat = null;
+        // Emit connection update
+        this.ev.emit('connection.update', {
+            connection: 'close',
+            lastDisconnect: {
+                error: undefined,
+                output: { code, reason }
+            }
+        });
+        // Skip recovery untuk intentional close (1000, 1001)
+        if (code === 1000 || code === 1001) {
+            this.logger.info('Intentional close, skipping recovery');
+            return;
+        }
+        // Skip jika recovery sudah in progress atau disabled
+        if (this.recoveryManager.isCurrentlyRecovering()) {
+            this.logger.warn('Recovery already in progress');
+            return;
+        }
+        // Map code ke DisconnectReason dan trigger multi-branch recovery
+        const disconnectReason = (0, index_js_4.mapCodeToReason)(code, reason);
+        this.logger.info(`Disconnect detected: ${disconnectReason} (code=${code}, reason=${reason})`);
+        // Trigger async recovery (non-blocking)
+        this.recoveryManager.recover(disconnectReason, code, reason).catch(err => {
+            this.logger.error(`Recovery manager error: ${err.message}`);
+        });
+    }
+    // ============== Auth ==============
+    /**
+     * Start QR-based authentication
+     */
+    async startQRAuth() {
+        const qrData = (0, qr_code_js_1.generateQRCodeData)({
+            creds: this.authState.creds,
+            logger: this.logger,
+            printInTerminal: this.config.printQRInTerminal
+        });
+        this.ev.emit('qr.update', qrData);
+        this.ev.emit('connection.update', {
+            connection: 'connecting',
+            qr: qrData.qrString
+        });
+        // Setup refresh manager
+        this.qrRefreshManager = new qr_code_js_1.QRRefreshManager((qr) => {
+            const newQr = (0, qr_code_js_1.generateQRCodeData)({
+                creds: this.authState.creds,
+                logger: this.logger,
+                printInTerminal: this.config.printQRInTerminal
+            });
+            this.ev.emit('qr.update', newQr);
+            this.ev.emit('connection.update', {
+                connection: 'connecting',
+                qr: newQr.qrString
+            });
+        }, () => {
+            this.logger.warn('QR code timed out');
+            this.ev.emit('connection.update', {
+                connection: 'close',
+                lastDisconnect: {
+                    error: new Error('QR timeout'),
+                    output: { code: 0, reason: 'QR timeout' }
+                }
+            });
+        });
+        this.qrRefreshManager.start(qrData);
+    }
+    /**
+     * Send login message untuk existing session
+     */
+    async sendLogin() {
+        // Build login node dengan stored credentials
+        const loginNode = {
+            tag: 'iq',
+            attrs: {
+                type: 'set',
+                to: 's.whatsapp.net',
+                id: `login-${Date.now()}`
+            },
+            content: [
+                {
+                    tag: 'login',
+                    attrs: {
+                        user: this.authState.creds.me?.toString() ?? '',
+                        serverToken: this.authState.creds.serverToken ?? '',
+                        clientToken: this.authState.creds.clientToken ?? ''
+                    }
+                }
+            ]
+        };
+        this.send((0, binary_js_1.encodeBinaryNode)(loginNode));
+    }
+    // ============== Internal Send ==============
+    async send(data) {
+        if (!this.ws || !this.ws.isConnected()) {
+            throw new Error('Cannot send: WebSocket not connected');
+        }
+        await this.rateLimiter.acquire();
+        this.ws.send(data);
+    }
+    // ============== Public API Methods ==============
+    async logout() {
+        if (this.authState instanceof auth_state_js_1.FileAuthState) {
+            await this.authState.clear();
+        }
+        await this.end(true);
+    }
+    async refreshQR() {
+        const qrData = (0, qr_code_js_1.generateQRCodeData)({
+            creds: this.authState.creds,
+            logger: this.logger,
+            printInTerminal: this.config.printQRInTerminal
+        });
+        this.ev.emit('qr.update', qrData);
+        return qrData;
+    }
+    async requestPairingCode(phoneNumber) {
+        const cleanPhone = (0, pairing_code_js_1.normalizePhoneNumber)(phoneNumber);
+        const result = (0, pairing_code_js_1.generatePairingCode)(cleanPhone, this.authState.creds, this.logger);
+        this.ev.emit('pairing-code.update', result);
+        return result;
+    }
+    async sendMessage(jid, content, opts = {}) {
+        const recipientJid = (0, jid_js_1.jidToString)(jid);
+        // Circuit breaker check (Features: circuit breaker)
+        if (!this.circuitBreaker.canSend(recipientJid)) {
+            const state = this.circuitBreaker.getState(recipientJid);
+            throw new Error(`Circuit breaker is ${state} for ${recipientJid} - too many failures`);
+        }
+        // Rate limit check (Features: rate limit tracker)
+        if (!this.rateLimitTracker.canSend(recipientJid)) {
+            const quota = this.rateLimitTracker.getRemainingQuota(recipientJid);
+            throw new Error(`Rate limit exceeded for ${recipientJid} (remaining: sec=${quota.second}, min=${quota.minute}, hr=${quota.hour})`);
+        }
+        // Persist message untuk survive restart (Features: message persistence)
+        const messageId = opts.messageId ?? `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        this.messagePersistence.save({
+            id: messageId,
+            recipientJid,
+            content,
+            status: 'pending',
+            attempts: 0,
+            createdAt: Date.now(),
+            updatedAt: Date.now()
+        });
+        // Use message queue untuk serialize sends per recipient (Baileys fix #8: race condition)
+        const startTime = Date.now();
+        try {
+            const result = await this.messageQueue.enqueue(recipientJid, () => this.messageSender.sendMessage(jid, content, { ...opts, messageId }));
+            // Update persistence
+            this.messagePersistence.update(messageId, {
+                status: 'sent',
+                attempts: 1
+            });
+            // Record success
+            this.circuitBreaker.recordSuccess(recipientJid);
+            this.healthMonitor.recordSend(Date.now() - startTime, true);
+            // Trigger webhook
+            this.webhookManager.trigger('message.sent', { jid: recipientJid, messageId });
+            return result;
+        }
+        catch (err) {
+            this.messagePersistence.update(messageId, {
+                status: 'failed',
+                lastError: err.message,
+                attempts: 1
+            });
+            this.circuitBreaker.recordFailure(recipientJid);
+            this.healthMonitor.recordSend(0, false);
+            // Trigger webhook untuk failure
+            this.webhookManager.trigger('message.failed', { jid: recipientJid, messageId, error: err.message });
+            throw err;
+        }
+    }
+    async forwardMessage(to, message) {
+        return this.messageSender.forwardMessage(to, message);
+    }
+    async deleteMessage(jid, key, opts = {}) {
+        return this.messageSender.deleteMessage(jid, key, opts);
+    }
+    async reactToMessage(jid, key, emoji) {
+        return this.messageSender.reactToMessage(jid, key, emoji);
+    }
+    async sendReadReceipt(jid, messageIds, participant) {
+        const node = (0, send_js_1.buildReadReceiptNode)(jid, messageIds, participant);
+        await this.send((0, binary_js_1.encodeBinaryNode)(node));
+    }
+    async sendPresenceUpdate(jid, presence) {
+        const node = (0, send_js_1.buildChatPresenceNode)(jid, presence);
+        await this.send((0, binary_js_1.encodeBinaryNode)(node));
+    }
+    async updatePresence(presence) {
+        const node = {
+            tag: 'presence',
+            attrs: { type: presence }
+        };
+        await this.send((0, binary_js_1.encodeBinaryNode)(node));
+    }
+    async uploadMedia(media, mediaType, mimetype, fileName) {
+        return this.mediaUploader.upload(media, mediaType, mimetype, fileName);
+    }
+    async downloadMedia(url, mediaKey, mediaType, mimetype, fileName) {
+        return this.mediaDownloader.download(url, mediaKey, mediaType, mimetype, fileName);
+    }
+    // ============== Group Methods ==============
+    async groupCreate(opts) {
+        if (!this.groupManager)
+            throw new Error('Group manager not initialized');
+        return this.groupManager.createGroup(opts);
+    }
+    async groupMetadata(jid) {
+        if (!this.groupManager)
+            throw new Error('Group manager not initialized');
+        return this.groupManager.getGroupMetadata(jid);
+    }
+    async groupUpdateSubject(jid, subject) {
+        if (!this.groupManager)
+            throw new Error('Group manager not initialized');
+        return this.groupManager.updateGroupSubject(jid, subject);
+    }
+    async groupUpdateDescription(jid, desc) {
+        if (!this.groupManager)
+            throw new Error('Group manager not initialized');
+        return this.groupManager.updateGroupDescription(jid, desc);
+    }
+    async groupParticipantsUpdate(jid, participants, action) {
+        if (!this.groupManager)
+            throw new Error('Group manager not initialized');
+        switch (action) {
+            case 'add':
+                return this.groupManager.addParticipants(jid, participants);
+            case 'remove':
+                return this.groupManager.removeParticipants(jid, participants);
+            case 'promote':
+                return this.groupManager.promoteParticipants(jid, participants);
+            case 'demote':
+                return this.groupManager.demoteParticipants(jid, participants);
+        }
+    }
+    async groupLeave(jid) {
+        if (!this.groupManager)
+            throw new Error('Group manager not initialized');
+        return this.groupManager.leaveGroup(jid);
+    }
+    async groupInviteCode(jid) {
+        if (!this.groupManager)
+            throw new Error('Group manager not initialized');
+        return this.groupManager.getInviteCode(jid);
+    }
+    async groupRevokeInvite(jid) {
+        if (!this.groupManager)
+            throw new Error('Group manager not initialized');
+        return this.groupManager.revokeInviteCode(jid);
+    }
+    async groupJoinViaCode(code) {
+        if (!this.groupManager)
+            throw new Error('Group manager not initialized');
+        return this.groupManager.joinGroupViaCode(code);
+    }
+    async groupSettingUpdate(jid, setting, value) {
+        if (!this.groupManager)
+            throw new Error('Group manager not initialized');
+        if (setting === 'restrict') {
+            return this.groupManager.setGroupRestrict(jid, value);
+        }
+        else {
+            return this.groupManager.setGroupAnnounce(jid, value);
+        }
+    }
+    // ============== Call Methods ==============
+    async rejectCall(callId, from) {
+        if (!this.callHandler)
+            throw new Error('Call handler not initialized');
+        return this.callHandler.rejectCall(callId, from);
+    }
+    // ============== Chat Methods ==============
+    async chatModify(modification, jid) {
+        const node = {
+            tag: 'iq',
+            attrs: {
+                type: 'set',
+                to: (0, jid_js_1.jidToString)(jid),
+                id: `chatmod-${Date.now()}`
+            },
+            content: [modification]
+        };
+        await this.send((0, binary_js_1.encodeBinaryNode)(node));
+    }
+    async readChat(jid) {
+        const node = {
+            tag: 'iq',
+            attrs: {
+                type: 'set',
+                to: (0, jid_js_1.jidToString)(jid),
+                id: `readchat-${Date.now()}`
+            },
+            content: [{
+                    tag: 'markChatAsRead',
+                    attrs: {}
+                }]
+        };
+        await this.send((0, binary_js_1.encodeBinaryNode)(node));
+    }
+    async archiveChat(jid, archive) {
+        const action = archive ? 'archive' : 'unarchive';
+        const node = {
+            tag: 'iq',
+            attrs: {
+                type: 'set',
+                to: (0, jid_js_1.jidToString)(jid),
+                id: `archive-${Date.now()}`
+            },
+            content: [{
+                    tag: 'chat',
+                    attrs: { action }
+                }]
+        };
+        await this.send((0, binary_js_1.encodeBinaryNode)(node));
+    }
+    async muteChat(jid, durationMs) {
+        const node = {
+            tag: 'iq',
+            attrs: {
+                type: 'set',
+                to: (0, jid_js_1.jidToString)(jid),
+                id: `mute-${Date.now()}`
+            },
+            content: [{
+                    tag: 'mute',
+                    attrs: {
+                        action: 'mute',
+                        muteDuration: Math.floor(durationMs / 1000).toString()
+                    }
+                }]
+        };
+        await this.send((0, binary_js_1.encodeBinaryNode)(node));
+    }
+    async pinChat(jid, durationMs) {
+        const node = {
+            tag: 'iq',
+            attrs: {
+                type: 'set',
+                to: (0, jid_js_1.jidToString)(jid),
+                id: `pin-${Date.now()}`
+            },
+            content: [{
+                    tag: 'pin',
+                    attrs: {
+                        type: 'pinV2',
+                        pinDuration: Math.floor(durationMs / 1000).toString()
+                    }
+                }]
+        };
+        await this.send((0, binary_js_1.encodeBinaryNode)(node));
+    }
+    async deleteChat(jid) {
+        const node = {
+            tag: 'iq',
+            attrs: {
+                type: 'set',
+                to: (0, jid_js_1.jidToString)(jid),
+                id: `delchat-${Date.now()}`
+            },
+            content: [{
+                    tag: 'chat',
+                    attrs: { action: 'clear' }
+                }]
+        };
+        await this.send((0, binary_js_1.encodeBinaryNode)(node));
+    }
+    async presenceSubscribe(jids) {
+        const node = {
+            tag: 'iq',
+            attrs: {
+                type: 'set',
+                to: 's.whatsapp.net',
+                id: `presence-sub-${Date.now()}`
+            },
+            content: jids.map(j => ({
+                tag: 'user',
+                attrs: { jid: (0, jid_js_1.jidToString)(j) }
+            }))
+        };
+        await this.send((0, binary_js_1.encodeBinaryNode)(node));
+    }
+    // ============== Connection Management ==============
+    async end(newConnection = false) {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.qrRefreshManager) {
+            this.qrRefreshManager.stop();
+            this.qrRefreshManager = null;
+        }
+        // Cancel ongoing recovery
+        this.recoveryManager?.cancel();
+        // Cleanup fixes
+        this.heartbeat?.stop();
+        this.heartbeat = null;
+        this.idempotencyCache.destroy();
+        this.groupEventCoalescer?.destroy();
+        this.groupEventCoalescer = null;
+        this.decryptionRetryQueue?.destroy();
+        this.decryptionRetryQueue = null;
+        this.messageQueue.clearAll();
+        // Cleanup features
+        this.healthMonitor.stop();
+        this.webhookManager.destroy();
+        // Cleanup SKDM
+        await this.skdm?.destroy();
+        this.pendingTracker.rejectAll(new Error('Connection ended'));
+        this.rateLimiter.destroy();
+        if (this.ws) {
+            this.ws.close(1000, 'normal');
+            this.ws = null;
+        }
+        this.connectionState = 'close';
+        this.ev.emit('connection.update', { connection: 'close' });
+    }
+    // ============== Public Accessors untuk SKDM & Features ==============
+    /**
+     * Get SKDM (Store Key Data Manager) instance
+     */
+    getSKDM() {
+        return this.skdm;
+    }
+    /**
+     * Get health status
+     */
+    getHealth() {
+        return this.healthMonitor.getHealth();
+    }
+    /**
+     * Get SKDM stats (pre-keys, sessions, identities)
+     */
+    getSKDMStats() {
+        return this.skdm?.getStats();
+    }
+    /**
+     * Get system stats (queue size, circuit breakers, rate limits)
+     */
+    getSystemStats() {
+        return {
+            messageQueue: this.messageQueue.getStats(),
+            circuitBreakers: this.circuitBreaker.getOpenCircuits(),
+            rateLimits: this.rateLimitTracker.getStats(),
+            webhooks: this.webhookManager.getStats(),
+            messagePersistence: {
+                total: this.messagePersistence.size(),
+                pending: this.messagePersistence.getPending().length,
+                failed: this.messagePersistence.getFailed().length
+            },
+            idempotency: this.idempotencyCache.getStats(),
+            historySync: this.historySyncManager.getStats(),
+            health: this.healthMonitor.getHealth(),
+            recovery: this.recoveryManager.getStats()
+        };
+    }
+    /**
+     * Get recovery stats - shows recovery success/failure rate per disconnect reason
+     */
+    getRecoveryStats() {
+        return this.recoveryManager.getStats();
+    }
+    /**
+     * Get current recovery context (jika lagi recovering)
+     */
+    getCurrentRecovery() {
+        return this.recoveryManager.getCurrentContext();
+    }
+    /**
+     * Check apakah lagi dalam proses recovery
+     */
+    isRecovering() {
+        return this.recoveryManager.isCurrentlyRecovering();
+    }
+    /**
+     * Manually trigger recovery untuk a reason (untuk testing)
+     */
+    async triggerRecovery(reason, code, message) {
+        return this.recoveryManager.recover(reason, code, message);
+    }
+    /**
+     * Register webhook
+     */
+    registerWebhook(config) {
+        this.webhookManager.register(config);
+    }
+    /**
+     * Retry failed messages dari persistence
+     */
+    async retryFailedMessages() {
+        const failed = this.messagePersistence.getFailed();
+        this.logger.info(`Retrying ${failed.length} failed messages`);
+        for (const msg of failed) {
+            this.messagePersistence.update(msg.id, { status: 'pending' });
+            try {
+                await this.sendMessage(msg.recipientJid, msg.content);
+            }
+            catch (err) {
+                this.logger.error(`Retry failed for ${msg.id}: ${err.message}`);
+            }
+        }
+    }
+    /**
+     * Reset circuit breaker untuk a recipient
+     */
+    resetCircuitBreaker(recipientJid) {
+        this.circuitBreaker.reset(recipientJid);
+    }
+    getConnectionState() {
+        return this.connectionState;
+    }
+}
+exports.WASocketImpl = WASocketImpl;
+// ============== Factory Function ==============
+/**
+ * Create WhatsApp socket - main entry point
+ * Mirip Baileys' makeWASocket()
+ *
+ * @example
+ * ```ts
+ * import { makeWASocket, useFileAuthState } from 'waliwa';
+ *
+ * const { state } = await useFileAuthState('./auth');
+ * const sock = makeWASocket({ authState: state, printQRInTerminal: true });
+ * await sock.connect();
+ *
+ * sock.ev.on('message.upsert', async ({ messages }) => {
+ *   for (const msg of messages) {
+ *     console.log('Got message:', msg);
+ *   }
+ * });
+ * ```
+ */
+function makeWASocket(config) {
+    if (!config.authState) {
+        throw new Error('authState is required in config');
+    }
+    const socket = new WASocketImpl(config, config.authState);
+    // Auto-connect
+    socket.connect().catch(err => {
+        config.logger?.error?.(`Initial connect failed: ${err.message}`);
+    });
+    return socket;
+}
+//# sourceMappingURL=wa-socket.js.map