@prototypevip/baileys 0.0.8 → 0.1.0

package/lib/AntiBan/wrapper.js

@@ -0,0 +1,456 @@
+/**
+ * Socket Wrapper — Drop-in replacement that wraps sendMessage with anti-ban protection
+ *
+ * Works with both baileys and @oxidezap/baileyrs transports.
+ *
+ * Usage with baileys:
+ *   import makeWASocket from 'baileys';
+ *   import { wrapSocket } from 'baileys-antiban';
+ *
+ *   const sock = makeWASocket({ ... });
+ *   const safeSock = wrapSocket(sock);
+ *
+ * Usage with baileyrs:
+ *   import { makeWASocket } from '@oxidezap/baileyrs';
+ *   import { wrapSocket } from 'baileys-antiban';
+ *
+ *   const sock = makeWASocket({ ... });
+ *   const safeSock = wrapSocket(sock);
+ *
+ *   // Use safeSock.sendMessage() — automatically rate-limited and monitored
+ *   await safeSock.sendMessage(jid, { text: 'Hello!' });
+ *
+ *   // Check health anytime
+ *   console.log(safeSock.antiban.getStats());
+ *
+ * Note: reachoutTimeLock timelock module silently noops on baileyrs until upstream
+ * emits reachoutTimeLock events — confirmed NOT present in baileyrs v0.0.8.
+ * Timelock guard will operate in detection-only mode (relies on 463 errors only).
+ */
+import { AntiBan } from './antiban.js';
+import { DeafSessionDetector } from './sessionStability.js';
+import { GroupOperationGuard } from './groupOperationGuard.js';
+import { LegitimacySignalInjector } from './legitimacySignalInjector.js';
+/**
+ * Wrap a Baileys socket with anti-ban protection.
+ * The returned socket has the same API but sendMessage() is protected.
+ */
+export function wrapSocket(sock, config, warmUpState, wrapOptions) {
+    const antiban = new AntiBan(config, warmUpState);
+    const options = {
+        autoRespondToIncoming: false,
+        ...wrapOptions,
+    };
+    // Deaf session detector — optional, enabled via wrapOptions.deafSession
+    const deafDetector = options.deafSession
+        ? new DeafSessionDetector(options.deafSession)
+        : null;
+    if (deafDetector)
+        deafDetector.attach(sock);
+    // Group operation guard — intercept group methods with rate limiting
+    if (options.groupOpGuard !== false) {
+        const guard = new GroupOperationGuard(options.groupOpGuard || {});
+        const origUpdate = sock.groupParticipantsUpdate?.bind(sock);
+        if (origUpdate) {
+            sock.groupParticipantsUpdate = async (jid, participants, action) => {
+                const op = action === 'add' ? 'add' : action === 'remove' ? 'remove' : 'add';
+                const check = guard.check(op, jid);
+                if (!check.allowed)
+                    throw new Error(check.reason || 'Group operation rate limited');
+                return origUpdate(jid, participants, action);
+            };
+        }
+        const origCreate = sock.groupCreate?.bind(sock);
+        if (origCreate) {
+            sock.groupCreate = async (subject, participants) => {
+                const check = guard.check('create', subject);
+                if (!check.allowed)
+                    throw new Error(check.reason || 'Group creation rate limited');
+                return origCreate(subject, participants);
+            };
+        }
+    }
+    // Legitimacy signal injector — wrap sendMessage for typo injection
+    let legitimacyInjector = null;
+    if (options.legitimacySignals !== false) {
+        legitimacyInjector = new LegitimacySignalInjector(typeof options.legitimacySignals === 'object' ? options.legitimacySignals : {});
+    }
+    // Hook into Baileys events for health monitoring
+    // Prefer ev.process() (Baileys ≥ late 2022) for batched event handling
+    // Fall back to ev.on() for older versions
+    if (typeof sock.ev.process === 'function') {
+        sock.ev.process(async (events) => {
+            // Handle connection updates
+            if (events['connection.update']) {
+                const update = events['connection.update'];
+                if (update.connection === 'close') {
+                    const reason = update.lastDisconnect?.error?.output?.statusCode || 'unknown';
+                    antiban.onDisconnect(reason);
+                    antiban.destroy(); // Clean up all timers
+                    deafDetector?.onDisconnect();
+                    deafDetector?.destroy();
+                    // Fleet event: detect ban-like disconnect codes
+                    if (options.fleetEventStore) {
+                        const banCodes = [401, 403, 428, 515]; // 401=logged out, 403=forbidden, 428=banned, 515=restart required
+                        if (typeof reason === 'number' && banCodes.includes(reason)) {
+                            void options.fleetEventStore.emit('ban', { statusCode: reason });
+                        }
+                    }
+                }
+                if (update.connection === 'open') {
+                    antiban.onReconnect();
+                    deafDetector?.onConnect();
+                    // Fleet event: recovery from previous ban/warn
+                    if (options.fleetEventStore) {
+                        const health = antiban.getStats().health;
+                        if (health.risk === 'low') {
+                            void options.fleetEventStore.emit('recovery', { risk: health.risk });
+                        }
+                    }
+                }
+                // Reachout timelock detection
+                if (update.reachoutTimeLock) {
+                    antiban.timelock.onTimelockUpdate({
+                        isActive: update.reachoutTimeLock.isActive,
+                        timeEnforcementEnds: update.reachoutTimeLock.timeEnforcementEnds,
+                        enforcementType: update.reachoutTimeLock.enforcementType,
+                    });
+                    // Fleet event: timelock
+                    if (options.fleetEventStore && update.reachoutTimeLock.isActive) {
+                        void options.fleetEventStore.emit('timelock', {
+                            enforcementType: update.reachoutTimeLock.enforcementType,
+                            endsAt: update.reachoutTimeLock.timeEnforcementEnds,
+                        });
+                    }
+                }
+            }
+            // Catch 463 errors from message updates + track retries + learn LID mappings
+            if (events['messages.update']) {
+                const updates = events['messages.update'];
+                deafDetector?.onMessageActivity();
+                for (const update of updates) {
+                    // 463 error detection
+                    if (update?.update?.messageStubParameters) {
+                        const params = Array.isArray(update.update.messageStubParameters)
+                            ? update.update.messageStubParameters
+                            : [];
+                        if (params.includes(463) || params.includes('463')) {
+                            antiban.timelock.record463Error();
+                            // Fleet event: rate limit detected
+                            if (options.fleetEventStore) {
+                                void options.fleetEventStore.emit('rate_limit', { error: '463' });
+                            }
+                        }
+                    }
+                    // Retry tracking
+                    antiban.retryTracker.onMessageUpdate(update);
+                    // Delivery receipt tracking
+                    const status = update?.update?.status;
+                    const msgId = update?.key?.id;
+                    // status 3 = DELIVERY_ACK (double tick), status 4 = READ
+                    if (msgId && (status === 3 || status === 4)) {
+                        antiban.onDeliveryReceipt(msgId);
+                    }
+                }
+                // LID canonicalizer learning
+                antiban.jidCanonicalizer?.onMessageUpdate(updates);
+            }
+            // Register known chats from incoming messages + handle reply suggestions + learn LID mappings
+            if (events['messages.upsert']) {
+                const { messages } = events['messages.upsert'];
+                deafDetector?.onMessageActivity();
+                // Learn LID mappings FIRST (before any other processing)
+                antiban.jidCanonicalizer?.onIncomingEvent(events['messages.upsert']);
+                for (const msg of messages || []) {
+                    const jid = msg.key?.remoteJid;
+                    if (!jid)
+                        continue;
+                    // Register known chat
+                    antiban.timelock.registerKnownChat(jid);
+                    // Skip self messages
+                    const isSelf = msg.key?.fromMe || false;
+                    if (isSelf)
+                        continue;
+                    // Extract message text
+                    const msgText = msg.message?.conversation ||
+                        msg.message?.extendedTextMessage?.text ||
+                        msg.message?.imageMessage?.caption ||
+                        msg.message?.videoMessage?.caption ||
+                        '';
+                    // Handle incoming message (updates reply ratio + contact graph)
+                    const replySuggestion = antiban.onIncomingMessage(jid, msgText);
+                    // Auto-respond if enabled and suggested
+                    if (options.autoRespondToIncoming && replySuggestion.shouldReply && replySuggestion.suggestedText) {
+                        // Random delay 3-15s
+                        const replyDelay = Math.floor(Math.random() * 12000) + 3000;
+                        setTimeout(async () => {
+                            try {
+                                await sock.sendMessage(jid, { text: replySuggestion.suggestedText });
+                            }
+                            catch (error) {
+                                // Silently fail — auto-reply is best-effort
+                            }
+                        }, replyDelay);
+                    }
+                }
+            }
+        });
+    }
+    else {
+        // Fallback to ev.on() for older Baileys versions
+        sock.ev.on('connection.update', (update) => {
+            if (update.connection === 'close') {
+                const reason = update.lastDisconnect?.error?.output?.statusCode || 'unknown';
+                antiban.onDisconnect(reason);
+                antiban.destroy(); // Clean up all timers
+                deafDetector?.onDisconnect();
+                deafDetector?.destroy();
+                // Fleet event: detect ban-like disconnect codes
+                if (options.fleetEventStore) {
+                    const banCodes = [401, 403, 428, 515]; // 401=logged out, 403=forbidden, 428=banned, 515=restart required
+                    if (typeof reason === 'number' && banCodes.includes(reason)) {
+                        void options.fleetEventStore.emit('ban', { statusCode: reason });
+                    }
+                }
+            }
+            if (update.connection === 'open') {
+                antiban.onReconnect();
+                deafDetector?.onConnect();
+                // Fleet event: recovery from previous ban/warn
+                if (options.fleetEventStore) {
+                    const health = antiban.getStats().health;
+                    if (health.risk === 'low') {
+                        void options.fleetEventStore.emit('recovery', { risk: health.risk });
+                    }
+                }
+            }
+            // Reachout timelock detection
+            if (update.reachoutTimeLock) {
+                antiban.timelock.onTimelockUpdate({
+                    isActive: update.reachoutTimeLock.isActive,
+                    timeEnforcementEnds: update.reachoutTimeLock.timeEnforcementEnds,
+                    enforcementType: update.reachoutTimeLock.enforcementType,
+                });
+                // Fleet event: timelock
+                if (options.fleetEventStore && update.reachoutTimeLock.isActive) {
+                    void options.fleetEventStore.emit('timelock', {
+                        enforcementType: update.reachoutTimeLock.enforcementType,
+                        endsAt: update.reachoutTimeLock.timeEnforcementEnds,
+                    });
+                }
+            }
+        });
+        // Catch 463 errors from message updates + track retries + learn LID mappings
+        sock.ev.on('messages.update', (updates) => {
+            deafDetector?.onMessageActivity();
+            for (const update of updates) {
+                // 463 error detection
+                if (update?.update?.messageStubParameters) {
+                    const params = update.update.messageStubParameters;
+                    if (params.includes(463) || params.includes('463')) {
+                        antiban.timelock.record463Error();
+                        // Fleet event: rate limit detected
+                        if (options.fleetEventStore) {
+                            void options.fleetEventStore.emit('rate_limit', { error: '463' });
+                        }
+                    }
+                }
+                // Retry tracking
+                antiban.retryTracker.onMessageUpdate(update);
+                // Delivery receipt tracking
+                const status = update?.update?.status;
+                const msgId = update?.key?.id;
+                // status 3 = DELIVERY_ACK (double tick), status 4 = READ
+                if (msgId && (status === 3 || status === 4)) {
+                    antiban.onDeliveryReceipt(msgId);
+                }
+            }
+            // LID canonicalizer learning
+            antiban.jidCanonicalizer?.onMessageUpdate(updates);
+        });
+        // Register known chats from incoming messages + handle reply suggestions + learn LID mappings
+        sock.ev.on('messages.upsert', (upsert) => {
+            const { messages } = upsert;
+            deafDetector?.onMessageActivity();
+            // Learn LID mappings FIRST (before any other processing)
+            antiban.jidCanonicalizer?.onIncomingEvent(upsert);
+            for (const msg of messages || []) {
+                const jid = msg.key?.remoteJid;
+                if (!jid)
+                    continue;
+                // Register known chat
+                antiban.timelock.registerKnownChat(jid);
+                // Skip self messages
+                const isSelf = msg.key?.fromMe || false;
+                if (isSelf)
+                    continue;
+                // Extract message text
+                const msgText = msg.message?.conversation ||
+                    msg.message?.extendedTextMessage?.text ||
+                    msg.message?.imageMessage?.caption ||
+                    msg.message?.videoMessage?.caption ||
+                    '';
+                // Handle incoming message (updates reply ratio + contact graph)
+                const replySuggestion = antiban.onIncomingMessage(jid, msgText);
+                // Auto-respond if enabled and suggested
+                if (options.autoRespondToIncoming && replySuggestion.shouldReply && replySuggestion.suggestedText) {
+                    // Random delay 3-15s
+                    const replyDelay = Math.floor(Math.random() * 12000) + 3000;
+                    setTimeout(async () => {
+                        try {
+                            await sock.sendMessage(jid, { text: replySuggestion.suggestedText });
+                        }
+                        catch (error) {
+                            // Silently fail — auto-reply is best-effort
+                        }
+                    }, replyDelay);
+                }
+            }
+        });
+    }
+    // Create proxy that intercepts sendMessage
+    const originalSendMessage = sock.sendMessage.bind(sock);
+    // Serializes beforeSend→afterSend so rate limiter accounting is accurate
+    // under concurrent sends. Without this, all concurrent callers read the same
+    // committed state before any afterSend records, bypassing per-minute limits.
+    let sendLock = Promise.resolve();
+    const wrappedSendMessage = async (jid, content, options) => {
+        /**
+         * LID/PN Canonicalization — Normalize JID to canonical form
+         *
+         * This mitigates the LID/PN race that causes "Bad MAC / No Session / Invalid PreKey"
+         * errors (Baileys #1769, our PR #2372). When a message event arrives under one form
+         * (e.g. LID) but the crypto session was established under another (e.g. PN), decryption
+         * fails. By normalizing all outbound targets to a single form, we reduce this race.
+         *
+         * This is middleware-layer mitigation only. Root fix requires PR #2372 merged upstream.
+         */
+        const canonicalJid = antiban.jidCanonicalizer?.canonicalizeTarget(jid) || jid;
+        // Extract text content for rate limiter analysis
+        let text = content?.text || content?.caption || content?.image?.caption || '';
+        // Check for typo injection (only for text messages)
+        let typoResult = null;
+        if (legitimacyInjector && content?.text && typeof content.text === 'string' && content.text.length > 10) {
+            typoResult = legitimacyInjector.shouldInjectTypo(content.text);
+        }
+        // Chain this send onto the previous — each waits for the prior send's
+        // afterSend to commit before running its own beforeSend check.
+        const sendResult = sendLock.then(async () => {
+            // Circuit breaker check (before antiban.beforeSend)
+            if (options.circuitBreaker) {
+                if (!options.circuitBreaker.canSend(canonicalJid)) {
+                    throw new Error('[baileys-antiban] circuit-breaker: send blocked for ' + canonicalJid);
+                }
+            }
+            const decision = await antiban.beforeSend(canonicalJid, text);
+            if (!decision.allowed) {
+                throw new Error(`[baileys-antiban] Message blocked: ${decision.reason}`);
+            }
+            // Apply delay from rate limiter
+            if (decision.delayMs > 0) {
+                await new Promise(resolve => setTimeout(resolve, decision.delayMs));
+            }
+            // Apply circuit breaker jitter for broadcast messages
+            if (options.circuitBreaker) {
+                const isBroadcast = canonicalJid.endsWith('@broadcast') || canonicalJid.endsWith('@newsletter');
+                const jitter = options.circuitBreaker.getJitter(isBroadcast);
+                if (jitter > 0) {
+                    await new Promise(resolve => setTimeout(resolve, jitter));
+                }
+            }
+            // Send message (using canonical JID)
+            // If typo injection is active, send typo first, then correction
+            try {
+                let result;
+                if (typoResult) {
+                    // Send typo version first
+                    const typoContent = { ...content, text: typoResult.typoText };
+                    await originalSendMessage(canonicalJid, typoContent, options);
+                    // Wait for correction delay
+                    await new Promise(r => setTimeout(r, typoResult.correctionDelay));
+                    // Send corrected version
+                    const correctionContent = { ...content, text: typoResult.correctionText };
+                    result = await originalSendMessage(canonicalJid, correctionContent, options);
+                }
+                else {
+                    // Normal send
+                    result = await originalSendMessage(canonicalJid, content, options);
+                }
+                // Pass msgId to afterSend for delivery tracking
+                const msgId = result?.key?.id;
+                antiban.afterSend(canonicalJid, text, msgId);
+                antiban.timelock.registerKnownChat(canonicalJid);
+                // Clear retry tracking on successful send
+                if (msgId) {
+                    antiban.retryTracker.clear(msgId);
+                }
+                // Circuit breaker success
+                if (options.circuitBreaker) {
+                    options.circuitBreaker.recordSuccess(canonicalJid);
+                }
+                return result;
+            }
+            catch (error) {
+                // Circuit breaker failure
+                if (options.circuitBreaker) {
+                    options.circuitBreaker.recordFailure(canonicalJid);
+                }
+                // Baileys PR #2587: partial-encrypt Boom now carries structured data:
+                //   error.data.failed[]   — per-recipient { jid, error } failures
+                //   error.data.firstCause — most likely root cause string
+                // Extract for richer health-monitor diagnostics vs plain error.message.
+                const boomData = error?.data;
+                if (boomData?.failed?.length) {
+                    const cause = boomData.firstCause ?? 'unknown';
+                    const failedJids = boomData.failed.map((f) => f.jid).join(', ');
+                    antiban.afterSendFailed(`encrypt-all-failed firstCause=${cause} jids=[${failedJids}]`);
+                }
+                else {
+                    antiban.afterSendFailed(error instanceof Error ? error.message : String(error));
+                }
+                throw error;
+            }
+        });
+        // Advance the lock regardless of success/failure so the chain never stalls
+        sendLock = sendResult.then(() => { }, () => { });
+        return sendResult;
+    };
+    // Return enhanced socket
+    const wrapped = Object.create(sock);
+    wrapped.sendMessage = wrappedSendMessage;
+    wrapped.antiban = antiban;
+    // Expose destroy method directly so consumers can call it manually if needed
+    wrapped.antiban.destroy = antiban.destroy.bind(antiban);
+    return wrapped;
+}
+/**
+ * Helper function to create a wrapped socket with device fingerprint applied.
+ *
+ * This combines device fingerprint generation, socket creation, and wrapping
+ * into a single call.
+ *
+ * Usage:
+ *   import makeWASocket from 'baileys';
+ *   import { wrapSocketWithFingerprint } from 'baileys-antiban';
+ *
+ *   const wrapped = wrapSocketWithFingerprint(makeWASocket, socketConfig, {
+ *     fingerprintSeed: 'stable-seed-123',
+ *     groupOpGuard: {},
+ *     legitimacySignals: {}
+ *   });
+ *
+ * @param makeWASocket - Baileys makeWASocket factory function
+ * @param socketConfig - Base socket configuration
+ * @param wrapOptions - Combined wrapper options + fingerprintSeed
+ */
+export function wrapSocketWithFingerprint(makeWASocket, socketConfig, wrapOptions) {
+    // Import fingerprint functions dynamically to avoid circular deps
+    const { generateFingerprint, applyFingerprint } = require('./deviceFingerprint.js');
+    const seed = wrapOptions?.fingerprintSeed ||
+        socketConfig.auth?.creds?.me?.id ||
+        String(Date.now());
+    const fp = generateFingerprint({ seed });
+    const config = applyFingerprint(socketConfig, fp);
+    const sock = makeWASocket(config);
+    return wrapSocket(sock, undefined, undefined, wrapOptions);
+}

package/lib/Socket/groups.js

@@ -440,31 +440,36 @@ export const extractGroupMetadata = (result) => {
     memberAddMode: memberAddMode,
     participants: getBinaryNodeChildren(group, "participant").map(
       ({ attrs }) => {
-        const id = jidNormalizedUser(attrs.jid);
-        const phone = attrs.phone_number
-          ? jidNormalizedUser(attrs.phone_number)
-          : isPnUser(id)
-            ? id
-            : undefined;
-        const lid = attrs.lid
-          ? jidNormalizedUser(attrs.lid)
-          : isLidUser(id)
-            ? id
-            : undefined;
+        // مهم: الـ id هنا لازم يفضل زي ما السيرفر بعته (attrs.jid) بالظبط,
+        // من غير ما نلمسه أو نبدله بـ lid/phone بديل. السبب: القيمة دي هي
+        // اللي بتتبعت زي ما هي في participantsList لـ getUSyncDevices وفي
+        // الـ addressing_mode بتاع الرسالة الصادرة (messages-send.js) —
+        // فلو الجروب addressingMode="pn" لازم كل الـ ids تكون بصيغة PN,
+        // ولو "lid" لازم تكون كلها LID. أي تبديل هنا بيسبب mismatch بين
+        // هوية المشارك والـ addressing_mode المعلن، وده اللي كان بيطلع
+        // "بيشفر"/Waiting for this message لمشاركين الـ username بالذات —
+        // مش مشكلة سيشن عشان كده افتكاك السيشن وإعادة الدخول ما كانتش بتحل حاجة.
+        // عرض الرقم/اليوزرنيم للمستخدم (لو الرقم مخفي) اتحل بالفعل في مكان
+        // تاني (resolveDisplayIdentity) وده المكان الصح ليه، مش هنا.
+        const id = attrs.jid;
         return {
-          // لو مفيش رقم ظاهر (حساب يوزرنيم/خاصية إخفاء الرقم)، استخدم الـ
-          // LID بدل ما تسيبها undefined — undefined كانت بتوصل لقايمة
-          // المشاركين اللي بتتبعت لـ getUSyncDevices وتكسر استعلام
-          // الأجهزة للجروب كله، مع إن الاستعلام المباشر بالـ LID بيرجع
-          // فورًا لو استخدمناه صح
-          id: phone || lid,
-          lid: lid,
-          jid: phone || lid,
-          admin: attrs.type || false,
+          id,
+          // jid هنا نفس قيمة id بالظبط (مش قيمة تانية زي الكود القديم) —
+          // مُبقّاها بس عشان بعض أوامر البوت (كتم.js, مجتمع.js, muteSystem.js,
+          // context/group.js) بتقرا p.jid كـ fallback؛ ما بتأثرش على
+          // participantsList/addressing_mode لأنها زي id بالظبط دلوقتي
+          jid: id,
+          phoneNumber:
+            isLidUser(id) && isPnUser(attrs.phone_number)
+              ? attrs.phone_number
+              : undefined,
+          lid: isPnUser(id) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+          username: attrs.participant_username || attrs.username || undefined,
+          admin: attrs.type || null,
         };
       },
     ),
     ephemeralDuration: eph ? +eph : undefined,
   };
   return metadata;
-};
+};

package/lib/Socket/index.js

@@ -2,28 +2,153 @@ import { DEFAULT_CONNECTION_CONFIG } from "../Defaults/index.js";
 import { makeCommunitiesSocket } from "./communities.js";
 
 /**
- * Create a WhatsApp socket (clean — no anti-ban wrapper).
+ * Optional AntiBan — مقفول افتراضياً.
+ * لتفعيله مرّر في إعدادات makeWASocket:
+ *   makeWASocket({ antiBan: true })                    // moderate preset
+ *   makeWASocket({ antiBan: 'conservative' })          // preset name
+ *   makeWASocket({ antiBan: { maxPerMinute: 8, ... } }) // config مخصص
+ *   makeWASocket({ antiBan: false })                   // صراحة مقفول (الافتراضي)
+ *
+ * الحالة الاختيارية:
+ *   antiBanWarmUpState  — حالة الـ warmup المحفوظة
+ *   antiBanWrapOptions  — خيارات إضافية لـ wrapSocket
+ */
+
+let _wrapSocket = null;
+let _wrapSocketWithFingerprint = null;
+let _PRESETS = {};
+let _antiBanLoadError = null;
+
+async function loadAntiBan() {
+  if (_wrapSocket) return true;
+  if (_antiBanLoadError) return false;
+  try {
+    const mod = await import("../AntiBan/index.js");
+    _wrapSocket = mod.wrapSocket;
+    _wrapSocketWithFingerprint = mod.wrapSocketWithFingerprint;
+    _PRESETS = mod.PRESETS || {};
+    return true;
+  } catch (e) {
+    // fallback: try wrapper export path
+    try {
+      const wrap = await import("../AntiBan/wrapper.js");
+      const presets = await import("../AntiBan/presets.js").catch(() => ({}));
+      _wrapSocket = wrap.wrapSocket;
+      _wrapSocketWithFingerprint = wrap.wrapSocketWithFingerprint;
+      _PRESETS = presets.PRESETS || {};
+      return true;
+    } catch (e2) {
+      _antiBanLoadError = e2;
+      console.warn(
+        "[@prototypevip/baileys] AntiBan module failed to load — continuing without it:",
+        e2?.message || e2
+      );
+      return false;
+    }
+  }
+}
+
+// Best-effort background load (fire-and-forget, NOT top-level await —
+// awaiting here breaks require() on this ESM package with ERR_REQUIRE_ASYNC_MODULE).
+// If antiBan is requested before this finishes, makeWASocket() below will just
+// warn and skip protection instead of crashing.
+loadAntiBan();
+
+/**
+ * Create a WhatsApp socket.
+ * AntiBan مقفول افتراضياً — فعّله عبر config.antiBan
  */
 const makeWASocket = (config = {}) => {
-  // strip antiBan options if present so they don't leak into internal config
   const {
-    antiBan,
+    antiBan = false, // مقفول افتراضياً
     antiBanWarmUpState,
     antiBanWrapOptions,
     ...restConfig
-  } = config;
+  } = config || {};
 
   delete restConfig.userDevicesCache;
   const newConfig = { ...DEFAULT_CONNECTION_CONFIG, ...restConfig };
 
   let sock;
   const originalGetMessage = newConfig.getMessage;
-  newConfig.getMessage = async function (key) {
-    return originalGetMessage.call(sock || this, key);
-  };
+  if (typeof originalGetMessage === "function") {
+    newConfig.getMessage = async function (key) {
+      return originalGetMessage.call(sock || this, key);
+    };
+  }
 
   sock = makeCommunitiesSocket(newConfig);
+
+  // ── AntiBan (اختياري) ──
+  const enabled =
+    antiBan === true ||
+    (typeof antiBan === "string" && antiBan.length > 0) ||
+    (antiBan && typeof antiBan === "object");
+
+  if (enabled) {
+    if (typeof _wrapSocket !== "function") {
+      console.warn(
+        "[@prototypevip/baileys] antiBan requested but module not available — socket without protection"
+      );
+      return sock;
+    }
+
+    const antiBanConfig =
+      antiBan === true
+        ? "moderate"
+        : antiBan; // string preset or object config
+
+    try {
+      sock = _wrapSocket(
+        sock,
+        antiBanConfig,
+        antiBanWarmUpState,
+        antiBanWrapOptions || {}
+      );
+      if (newConfig.logger?.info) {
+        newConfig.logger.info(
+          { antiBan: typeof antiBanConfig === "string" ? antiBanConfig : "custom" },
+          "AntiBan protection enabled"
+        );
+      }
+    } catch (e) {
+      console.warn(
+        "[@prototypevip/baileys] AntiBan wrap failed — continuing without it:",
+        e?.message || e
+      );
+    }
+  }
+
   return sock;
 };
 
+/** Pass-through stubs when antiban is not loaded; real functions when loaded */
+const wrapSocket = (sock, ...args) =>
+  typeof _wrapSocket === "function" ? _wrapSocket(sock, ...args) : sock;
+
+const wrapSocketWithFingerprint = (makeSock, opts, wrapOpts) => {
+  if (typeof _wrapSocketWithFingerprint === "function") {
+    return _wrapSocketWithFingerprint(makeSock, opts, wrapOpts);
+  }
+  return typeof makeSock === "function" ? makeSock(opts || {}) : makeSock;
+};
+
+const PRESETS = new Proxy(
+  {},
+  {
+    get(_, prop) {
+      return _PRESETS[prop];
+    },
+    ownKeys() {
+      return Reflect.ownKeys(_PRESETS);
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      if (prop in _PRESETS) {
+        return { enumerable: true, configurable: true, value: _PRESETS[prop] };
+      }
+    },
+  }
+);
+
 export default makeWASocket;
+export { makeWASocket, wrapSocket, wrapSocketWithFingerprint, PRESETS };