@prototypevip/baileys 0.1.0 → 0.1.2

package/lib/AntiBan/proxyRotator.js

@@ -1,306 +0,0 @@
-/**
- * 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

@@ -1,261 +0,0 @@
-/**
- * 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

@@ -1,88 +0,0 @@
-/**
- * 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,
-    };
-}