@prototypevip/baileys 0.0.8 → 0.1.0

package/lib/AntiBan/proxyRotator.js

@@ -0,0 +1,306 @@
+/**
+ * Proxy Rotation — Native proxy injection for Baileys with health tracking
+ *
+ * WhatsApp's ban detection includes IP reputation scoring. Datacenter IPs (VPS)
+ * are flagged, while residential/4G proxies stay alive. No Baileys library handles
+ * native proxy injection — every implementation is DIY hacks. We close that gap.
+ *
+ * Features:
+ * - Multi-strategy rotation (round-robin, random, LRU, weighted)
+ * - Auto-failover on endpoint failure
+ * - Scheduled rotation for proactive IP rotation
+ * - Cooldown periods between endpoint reuse
+ * - Health tracking and auto-resurrection
+ * - Lazy-loaded proxy agent dependencies (optional peerDeps)
+ *
+ * @author Kobus Wentzel <kobie@pop.co.za>
+ * @license MIT
+ */
+// Load optional peer dependencies synchronously in both ESM and CJS builds.
+// CJS: native require is available. ESM: new Function() reads import.meta.url
+// without causing TypeScript parse errors in CJS compilation. The string passed
+// to new Function is a static literal — not user-controlled.
+function lazyRequire(moduleName) {
+    if (typeof require !== 'undefined') {
+        return require(moduleName);
+    }
+    // ESM path: new Function with static literal string avoids TS CJS-parse error on import.meta.
+    // Not user-controlled — both strings are compile-time constants.
+    const { createRequire } = (new Function('return require')())('node:module');
+    const metaUrl = new Function('return import.meta.url')();
+    return createRequire(metaUrl)(moduleName);
+}
+const NoopLogger = {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+export function proxyRotator(config) {
+    const { pool, strategy = 'round-robin', rotateOn = ['disconnect', 'ban-warning'], scheduledIntervalMs = 0, maxFailures = 3, deadCooldownMs = 600_000, // 10 minutes
+    logger = NoopLogger, } = config;
+    if (!pool || pool.length === 0) {
+        throw new Error('proxyRotator: pool cannot be empty');
+    }
+    // Warn once for pool size 1
+    if (pool.length === 1) {
+        logger.warn?.('proxyRotator: pool size is 1. Rotation is a no-op.');
+    }
+    // Warn for aggressive scheduled rotation
+    if (scheduledIntervalMs > 0 && scheduledIntervalMs < 60_000) {
+        logger.warn?.(`proxyRotator: scheduledIntervalMs (${scheduledIntervalMs}ms) is < 60s. May hammer proxy provider.`);
+    }
+    // Internal state
+    const states = pool.map((endpoint) => ({
+        endpoint,
+        failures: 0,
+        lastUsedAt: null,
+        isDead: false,
+    }));
+    let currentIndex = 0;
+    let totalRotations = 0;
+    const rotationsByTrigger = {};
+    let scheduledTimer = null;
+    // Agent cache: map endpoint -> Agent (cleared on rotation)
+    const agentCache = new Map();
+    // Module cache for lazy-loaded proxy agents
+    const moduleCache = {};
+    function buildProxyUrl(endpoint) {
+        const { type, host, port, username, password } = endpoint;
+        const auth = username && password ? `${username}:${password}@` : '';
+        return `${type}://${auth}${host}:${port}`;
+    }
+    function createAgentForEndpointSync(endpoint) {
+        // Check cache first
+        if (agentCache.has(endpoint)) {
+            return agentCache.get(endpoint);
+        }
+        const url = buildProxyUrl(endpoint);
+        let agent = null;
+        try {
+            if (endpoint.type === 'socks5' || endpoint.type === 'socks5h') {
+                if (!moduleCache['socks-proxy-agent']) {
+                    try {
+                        moduleCache['socks-proxy-agent'] = lazyRequire('socks-proxy-agent');
+                    }
+                    catch {
+                        logger.error?.('socks-proxy-agent not installed. Run: npm install socks-proxy-agent');
+                        return null;
+                    }
+                }
+                agent = new moduleCache['socks-proxy-agent'].SocksProxyAgent(url);
+            }
+            else if (endpoint.type === 'http') {
+                if (!moduleCache['http-proxy-agent']) {
+                    try {
+                        moduleCache['http-proxy-agent'] = lazyRequire('http-proxy-agent');
+                    }
+                    catch {
+                        logger.error?.('http-proxy-agent not installed. Run: npm install http-proxy-agent');
+                        return null;
+                    }
+                }
+                agent = new moduleCache['http-proxy-agent'].HttpProxyAgent(url);
+            }
+            else if (endpoint.type === 'https') {
+                if (!moduleCache['https-proxy-agent']) {
+                    try {
+                        moduleCache['https-proxy-agent'] = lazyRequire('https-proxy-agent');
+                    }
+                    catch {
+                        logger.error?.('https-proxy-agent not installed. Run: npm install https-proxy-agent');
+                        return null;
+                    }
+                }
+                agent = new moduleCache['https-proxy-agent'].HttpsProxyAgent(url);
+            }
+            else {
+                logger.error?.(`Unknown proxy type: ${endpoint.type}`);
+                return null;
+            }
+            // Cache the agent
+            if (agent) {
+                agentCache.set(endpoint, agent);
+            }
+            return agent;
+        }
+        catch (err) {
+            logger.error?.(`Failed to create agent for ${endpoint.label || endpoint.host}: ${err}`);
+            return null;
+        }
+    }
+    function getAliveEndpoints() {
+        const now = Date.now();
+        return states
+            .map((s, idx) => {
+            // Dead check with auto-resurrection
+            if (s.isDead && s.lastUsedAt) {
+                if (now - s.lastUsedAt.getTime() >= deadCooldownMs) {
+                    s.isDead = false;
+                    s.failures = 0;
+                    logger.info?.(`Resurrected endpoint ${s.endpoint.label || s.endpoint.host} after cooldown`);
+                }
+            }
+            // Cooldown check
+            const cooldown = s.endpoint.cooldownMs || 0;
+            if (cooldown > 0 && s.lastUsedAt) {
+                if (now - s.lastUsedAt.getTime() < cooldown) {
+                    return -1; // Still in cooldown
+                }
+            }
+            return !s.isDead ? idx : -1;
+        })
+            .filter((idx) => idx !== -1);
+    }
+    function selectNextIndex(alive) {
+        if (alive.length === 0)
+            return currentIndex; // All dead, stay on current
+        if (strategy === 'round-robin') {
+            // Pick next after currentIndex in circular fashion
+            const afterCurrent = alive.filter((idx) => idx > currentIndex);
+            if (afterCurrent.length > 0)
+                return afterCurrent[0];
+            return alive[0]; // Wrap around
+        }
+        if (strategy === 'random') {
+            return alive[Math.floor(Math.random() * alive.length)];
+        }
+        if (strategy === 'least-recently-used') {
+            // Pick the one with oldest lastUsedAt (never-used = highest priority)
+            const neverUsed = alive.filter((idx) => states[idx].lastUsedAt === null);
+            if (neverUsed.length > 0) {
+                return neverUsed[0];
+            }
+            let oldestIdx = alive[0];
+            let oldestTime = states[oldestIdx].lastUsedAt.getTime();
+            for (const idx of alive) {
+                const time = states[idx].lastUsedAt.getTime();
+                if (time < oldestTime) {
+                    oldestTime = time;
+                    oldestIdx = idx;
+                }
+            }
+            return oldestIdx;
+        }
+        if (strategy === 'weighted') {
+            // Weighted by inverse failure count (healthier = more likely)
+            const weights = alive.map((idx) => {
+                const failures = states[idx].failures;
+                return 1 / (failures + 1); // Avoid divide-by-zero
+            });
+            const totalWeight = weights.reduce((a, b) => a + b, 0);
+            let rand = Math.random() * totalWeight;
+            for (let i = 0; i < alive.length; i++) {
+                rand -= weights[i];
+                if (rand <= 0)
+                    return alive[i];
+            }
+            return alive[alive.length - 1]; // Fallback
+        }
+        return alive[0]; // Default fallback
+    }
+    function rotateImpl(reason = 'manual') {
+        if (pool.length === 1) {
+            // No-op for single endpoint
+            return states[0].endpoint;
+        }
+        const alive = getAliveEndpoints();
+        if (alive.length === 0) {
+            logger.warn?.('All endpoints are dead. Cannot rotate.');
+            return states[currentIndex].endpoint;
+        }
+        const nextIdx = selectNextIndex(alive);
+        if (nextIdx === currentIndex && alive.length > 1) {
+            // Try to pick a different one if possible
+            const others = alive.filter((idx) => idx !== currentIndex);
+            if (others.length > 0) {
+                currentIndex = others[0];
+            }
+            else {
+                currentIndex = nextIdx;
+            }
+        }
+        else {
+            currentIndex = nextIdx;
+        }
+        states[currentIndex].lastUsedAt = new Date();
+        totalRotations++;
+        rotationsByTrigger[reason] = (rotationsByTrigger[reason] || 0) + 1;
+        const label = states[currentIndex].endpoint.label || states[currentIndex].endpoint.host;
+        logger.info?.(`Rotated to endpoint ${label} (reason: ${reason})`);
+        return states[currentIndex].endpoint;
+    }
+    function markFailureImpl() {
+        const state = states[currentIndex];
+        state.failures++;
+        const label = state.endpoint.label || state.endpoint.host;
+        logger.warn?.(`Endpoint ${label} failed (${state.failures}/${maxFailures})`);
+        if (state.failures >= maxFailures) {
+            state.isDead = true;
+            logger.error?.(`Endpoint ${label} marked DEAD after ${maxFailures} failures`);
+            // Auto-rotate to next alive endpoint
+            const alive = getAliveEndpoints();
+            if (alive.length > 0) {
+                rotateImpl('manual'); // Trigger rotation as recovery
+            }
+        }
+    }
+    function resurrectAllImpl() {
+        let count = 0;
+        for (const state of states) {
+            if (state.isDead) {
+                state.isDead = false;
+                state.failures = 0;
+                count++;
+            }
+        }
+        if (count > 0) {
+            logger.info?.(`Resurrected ${count} dead endpoint(s)`);
+        }
+    }
+    function stopImpl() {
+        if (scheduledTimer) {
+            clearInterval(scheduledTimer);
+            scheduledTimer = null;
+            logger.info?.('Stopped scheduled rotation timer');
+        }
+    }
+    function getStatsImpl() {
+        return {
+            totalRotations,
+            rotationsByTrigger: { ...rotationsByTrigger },
+            endpointHealth: states.map((s) => ({
+                label: s.endpoint.label || s.endpoint.host,
+                inUse: states[currentIndex] === s,
+                failures: s.failures,
+                lastUsedAt: s.lastUsedAt,
+                isDead: s.isDead,
+            })),
+            currentEndpoint: states[currentIndex].endpoint.label || states[currentIndex].endpoint.host,
+        };
+    }
+    function currentAgentImpl() {
+        const endpoint = states[currentIndex].endpoint;
+        return createAgentForEndpointSync(endpoint);
+    }
+    function currentImpl() {
+        return states[currentIndex].endpoint;
+    }
+    // Setup scheduled rotation if enabled
+    if (rotateOn.includes('scheduled') && scheduledIntervalMs > 0) {
+        scheduledTimer = setInterval(() => {
+            rotateImpl('scheduled');
+        }, scheduledIntervalMs);
+        logger.info?.(`Scheduled rotation enabled (every ${scheduledIntervalMs}ms)`);
+    }
+    // Initialize: select first endpoint
+    states[0].lastUsedAt = new Date();
+    return {
+        currentAgent: currentAgentImpl,
+        current: currentImpl,
+        rotate: rotateImpl,
+        markFailure: markFailureImpl,
+        resurrectAll: resurrectAllImpl,
+        stop: stopImpl,
+        getStats: getStatsImpl,
+    };
+}

package/lib/AntiBan/rateLimiter.js

@@ -0,0 +1,261 @@
+/**
+ * Rate Limiter — Enforces human-like message pacing
+ *
+ * WhatsApp's detection looks for:
+ * - Too many messages per minute/hour
+ * - Identical messages to multiple recipients
+ * - No variation in timing between messages
+ * - Sudden spikes in activity
+ * - Messages sent at inhuman speed
+ */
+// Time constants for clarity
+const TIME_CONSTANTS = {
+    MS_PER_SECOND: 1000,
+    MS_PER_MINUTE: 60000,
+    MS_PER_HOUR: 3600000,
+    MS_PER_DAY: 86400000,
+    BURST_RESET_MS: 30000,
+    IDENTICAL_WINDOW_MS: 3600000, // 1 hour
+};
+const DEFAULT_CONFIG = {
+    maxPerMinute: 8,
+    maxPerHour: 200,
+    maxPerDay: 1500,
+    minDelayMs: 1500,
+    maxDelayMs: 5000,
+    newChatDelayMs: 3000,
+    maxIdenticalMessages: 3,
+    burstAllowance: 3,
+    identicalMessageWindowMs: TIME_CONSTANTS.IDENTICAL_WINDOW_MS,
+};
+export class RateLimiter {
+    config;
+    originalConfig;
+    messages = [];
+    identicalCount = new Map();
+    knownChats = new Set();
+    burstCount = 0;
+    lastMessageTime = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.originalConfig = { ...this.config };
+    }
+    /**
+     * Calculate delay before next message can be sent.
+     * Returns 0 if message can be sent immediately.
+     * Returns -1 if message should be blocked entirely.
+     */
+    async getDelay(recipient, content) {
+        const now = Date.now();
+        this.cleanup(now);
+        const contentHash = this.hashContent(content);
+        // Check daily limit
+        const dayMessages = this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_DAY);
+        if (dayMessages.length >= this.config.maxPerDay) {
+            return -1; // Hard block — daily limit reached
+        }
+        // Check hourly limit
+        const hourMessages = this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_HOUR);
+        if (hourMessages.length >= this.config.maxPerHour) {
+            // Sort by timestamp to find the oldest message in the window
+            hourMessages.sort((a, b) => a.timestamp - b.timestamp);
+            const oldestInHour = hourMessages[0];
+            const delay = oldestInHour ? (oldestInHour.timestamp + TIME_CONSTANTS.MS_PER_HOUR) - now : TIME_CONSTANTS.MS_PER_HOUR;
+            // Return a proper blocking delay (at least the time until the oldest message expires)
+            return Math.max(delay, TIME_CONSTANTS.MS_PER_MINUTE);
+        }
+        // Check per-minute limit
+        const minuteMessages = this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_MINUTE);
+        if (minuteMessages.length >= this.config.maxPerMinute) {
+            // Sort by timestamp to find the oldest message in the window
+            minuteMessages.sort((a, b) => a.timestamp - b.timestamp);
+            const oldestInMinute = minuteMessages[0];
+            const delay = oldestInMinute ? (oldestInMinute.timestamp + TIME_CONSTANTS.MS_PER_MINUTE) - now : TIME_CONSTANTS.MS_PER_MINUTE;
+            return Math.max(delay, TIME_CONSTANTS.MS_PER_SECOND);
+        }
+        // Check identical message limit (within time window)
+        const tracker = this.identicalCount.get(contentHash);
+        if (tracker) {
+            // Check if tracker is still within the time window
+            if (now - tracker.firstSeen < this.config.identicalMessageWindowMs) {
+                if (tracker.count >= this.config.maxIdenticalMessages) {
+                    return -1; // Block identical spam within time window
+                }
+            }
+        }
+        // Calculate human-like delay
+        let delay = 0;
+        // Burst allowance — first few messages can be faster
+        if (this.burstCount < this.config.burstAllowance) {
+            this.burstCount++;
+            delay = this.jitter(this.config.minDelayMs * 0.5, this.config.minDelayMs);
+        }
+        else {
+            delay = this.jitter(this.config.minDelayMs, this.config.maxDelayMs);
+        }
+        // Extra delay for new chats (first message to this recipient)
+        if (!this.knownChats.has(recipient)) {
+            delay += this.jitter(this.config.newChatDelayMs * 0.5, this.config.newChatDelayMs);
+        }
+        // Ensure minimum time since last message
+        const timeSinceLast = now - this.lastMessageTime;
+        if (timeSinceLast < this.config.minDelayMs) {
+            delay = Math.max(delay, this.config.minDelayMs - timeSinceLast);
+        }
+        // Add "typing simulation" delay based on content length
+        const typingDelay = Math.min(content.length * 30, 3000); // ~30ms per char, max 3s
+        delay += this.jitter(typingDelay * 0.5, typingDelay);
+        return Math.round(delay);
+    }
+    /**
+     * Record a sent message
+     */
+    record(recipient, content) {
+        const now = Date.now();
+        const contentHash = this.hashContent(content);
+        // BUG FIX 1: Check burst reset BEFORE updating lastMessageTime
+        const timeSinceLast = now - this.lastMessageTime;
+        if (timeSinceLast > TIME_CONSTANTS.BURST_RESET_MS) {
+            this.burstCount = 0;
+        }
+        this.messages.push({ timestamp: now, recipient, contentHash });
+        this.knownChats.add(recipient);
+        this.lastMessageTime = now;
+        // Track identical messages with time window
+        const tracker = this.identicalCount.get(contentHash);
+        if (tracker) {
+            // Check if within same window
+            if (now - tracker.firstSeen < this.config.identicalMessageWindowMs) {
+                tracker.count++;
+                tracker.lastSeen = now;
+            }
+            else {
+                // Start new window
+                this.identicalCount.set(contentHash, { count: 1, firstSeen: now, lastSeen: now });
+            }
+        }
+        else {
+            this.identicalCount.set(contentHash, { count: 1, firstSeen: now, lastSeen: now });
+        }
+    }
+    /**
+     * Get current usage stats
+     */
+    getStats() {
+        const now = Date.now();
+        this.cleanup(now);
+        return {
+            lastMinute: this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_MINUTE).length,
+            lastHour: this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_HOUR).length,
+            lastDay: this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_DAY).length,
+            limits: {
+                perMinute: this.config.maxPerMinute,
+                perHour: this.config.maxPerHour,
+                perDay: this.config.maxPerDay,
+            },
+            knownChats: this.knownChats.size,
+            currentFactor: this.getCurrentFactor(),
+        };
+    }
+    /**
+     * Dynamically scale rate limits by a factor (0.1–1.0).
+     * factor=1.0 = original config limits (full speed)
+     * factor=0.5 = 50% of configured limits
+     * Floors: perMinute >= 1, perHour >= 5, perDay >= 20
+     * Also scales minDelayMs/maxDelayMs inversely (slower sends when throttled).
+     */
+    adaptLimits(factor) {
+        const f = Math.max(0.1, Math.min(1.0, factor));
+        this.config.maxPerMinute = Math.max(1, Math.floor(this.originalConfig.maxPerMinute * f));
+        this.config.maxPerHour = Math.max(5, Math.floor(this.originalConfig.maxPerHour * f));
+        this.config.maxPerDay = Math.max(20, Math.floor(this.originalConfig.maxPerDay * f));
+        // Inverse: lower factor = longer delays (more human when throttled)
+        const delayScale = 1 + (1 - f) * 2; // f=1.0→1x, f=0.5→2x, f=0.1→3.8x
+        this.config.minDelayMs = Math.floor(this.originalConfig.minDelayMs * delayScale);
+        this.config.maxDelayMs = Math.floor(this.originalConfig.maxDelayMs * delayScale);
+    }
+    /** Return current effective factor (0.1–1.0) */
+    getCurrentFactor() {
+        return this.config.maxPerMinute / this.originalConfig.maxPerMinute;
+    }
+    /** Get the set of known chat JIDs (for state persistence) */
+    getKnownChats() {
+        return this.knownChats;
+    }
+    /** Restore known chats from persisted state */
+    restoreKnownChats(chats) {
+        for (const jid of chats) {
+            this.knownChats.add(jid);
+        }
+    }
+    /**
+     * BUG FIX 3: Inject historical timestamps into the sliding window
+     * Used by InstanceCoordinator to sync local limiter with shared pool after reconnect.
+     * This prevents the double-spend window where local limiter thinks it has full budget
+     * but the shared pool already shows most slots used.
+     */
+    injectTimestamps(timestamps) {
+        const now = Date.now();
+        // Filter to last 24 hours only (our cleanup window)
+        const recentTimestamps = timestamps.filter(ts => now - ts < TIME_CONSTANTS.MS_PER_DAY);
+        // Merge with existing messages, avoiding duplicates by timestamp
+        const existingTimes = new Set(this.messages.map(m => m.timestamp));
+        for (const ts of recentTimestamps) {
+            if (!existingTimes.has(ts)) {
+                // Create synthetic message record with placeholder data
+                this.messages.push({
+                    timestamp: ts,
+                    recipient: '__injected__', // placeholder - we don't know the actual recipient
+                    contentHash: '__injected__', // placeholder - we don't know the content
+                });
+            }
+        }
+        // Update lastMessageTime if injected timestamps are more recent
+        const maxInjected = Math.max(...recentTimestamps, 0);
+        if (maxInjected > this.lastMessageTime) {
+            this.lastMessageTime = maxInjected;
+        }
+        // Sort messages by timestamp to maintain sliding window integrity
+        this.messages.sort((a, b) => a.timestamp - b.timestamp);
+    }
+    cleanup(now) {
+        // Remove messages older than 24 hours
+        this.messages = this.messages.filter(m => now - m.timestamp < TIME_CONSTANTS.MS_PER_DAY);
+        // Clean up identicalCount Map based on time windows (not just message presence)
+        // Remove trackers where the window has expired
+        for (const [hash, tracker] of this.identicalCount.entries()) {
+            if (now - tracker.lastSeen > this.config.identicalMessageWindowMs) {
+                this.identicalCount.delete(hash);
+            }
+        }
+        // LRU size cap — prevents unbounded growth when sending many unique messages.
+        // Evict oldest-by-lastSeen entries when map exceeds 10,000 entries.
+        const IDENTICAL_COUNT_MAX = 10_000;
+        if (this.identicalCount.size > IDENTICAL_COUNT_MAX) {
+            const sorted = [...this.identicalCount.entries()].sort(([, a], [, b]) => a.lastSeen - b.lastSeen);
+            const excess = this.identicalCount.size - IDENTICAL_COUNT_MAX;
+            for (let i = 0; i < excess; i++)
+                this.identicalCount.delete(sorted[i][0]);
+        }
+    }
+    /** Random delay between min and max (gaussian-ish distribution) */
+    jitter(min, max) {
+        // Use Box-Muller for more human-like distribution (clustered around middle)
+        const u1 = Math.random();
+        const u2 = Math.random();
+        const normal = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+        const normalized = (normal + 3) / 6; // Map to ~0-1 range
+        const clamped = Math.max(0, Math.min(1, normalized));
+        return Math.round(min + clamped * (max - min));
+    }
+    /** Simple hash for content dedup */
+    hashContent(content) {
+        let hash = 0;
+        for (let i = 0; i < content.length; i++) {
+            const char = content.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash |= 0;
+        }
+        return hash.toString(36);
+    }
+}

package/lib/AntiBan/readReceiptVariance.js

@@ -0,0 +1,88 @@
+/**
+ * Read Receipt Timing Variance
+ *
+ * Extends presence choreography to randomize read-receipt delay.
+ * Instant reads = bot signal. Gaussian jitter makes reads feel human.
+ *
+ * @author Kobus Wentzel <kobie@pop.co.za>
+ * @license MIT
+ */
+/**
+ * Box-Muller transform for Gaussian random samples
+ * Returns a value from normal distribution (mean=0, stdDev=1)
+ */
+function gaussianRandom() {
+    let u = 0;
+    let v = 0;
+    while (u === 0)
+        u = Math.random(); // Avoid log(0)
+    while (v === 0)
+        v = Math.random();
+    return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+}
+export function readReceiptVariance(config = {}) {
+    const { meanMs = 1500, stdDevMs = 800, minMs = 200, maxMs = 8000, skipIfOlderThanMs = 60_000, } = config;
+    const pendingTimers = new Set();
+    function delayMs() {
+        // Generate Gaussian sample and scale to configured mean/stdDev
+        const gaussian = gaussianRandom();
+        const value = meanMs + gaussian * stdDevMs;
+        // Clamp to min/max
+        return Math.max(minMs, Math.min(maxMs, value));
+    }
+    function wrap(sock) {
+        const originalReadMessages = sock.readMessages.bind(sock);
+        // Proxy the readMessages method
+        const wrappedReadMessages = async (keys) => {
+            // Check if messages are too old (backlog)
+            const now = Date.now();
+            const oldMessages = keys.every((key) => {
+                if (!key.messageTimestamp)
+                    return false;
+                const msgTime = typeof key.messageTimestamp === 'number'
+                    ? key.messageTimestamp * 1000 // Baileys uses seconds
+                    : parseInt(key.messageTimestamp, 10) * 1000;
+                return now - msgTime > skipIfOlderThanMs;
+            });
+            if (oldMessages) {
+                // Skip delay for backlog messages
+                return originalReadMessages(keys);
+            }
+            // Apply jittered delay
+            const delay = delayMs();
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(async () => {
+                    pendingTimers.delete(timer);
+                    try {
+                        const result = await originalReadMessages(keys);
+                        resolve(result);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                }, delay);
+                pendingTimers.add(timer);
+            });
+        };
+        // Return proxy with wrapped readMessages
+        return new Proxy(sock, {
+            get(target, prop) {
+                if (prop === 'readMessages') {
+                    return wrappedReadMessages;
+                }
+                return target[prop];
+            },
+        });
+    }
+    function stop() {
+        for (const timer of pendingTimers) {
+            clearTimeout(timer);
+        }
+        pendingTimers.clear();
+    }
+    return {
+        wrap,
+        delayMs,
+        stop,
+    };
+}