@prototypevip/baileys 0.1.0 → 0.1.2

package/lib/AntiBan/scheduler.js

@@ -1,111 +0,0 @@
-/**
- * Smart Scheduler — Send messages during safe hours only
- *
- * WhatsApp is more suspicious of messages sent at 3 AM.
- * This module ensures messages go out during "business hours"
- * and adds realistic daily activity patterns.
- */
-const DEFAULT_CONFIG = {
-    timezone: 'UTC',
-    activeHours: [8, 21],
-    weekendFactor: 0.5,
-    peakHours: [10, 14],
-    peakFactor: 1.3,
-    lunchBreak: [12, 13],
-    lunchFactor: 0.5,
-};
-export class Scheduler {
-    config;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Check if now is within active hours
-     */
-    isActiveTime() {
-        const hour = this.getCurrentHour();
-        const [start, end] = this.config.activeHours;
-        return hour >= start && hour < end;
-    }
-    /**
-     * Get the speed multiplier for current time
-     * > 1 = faster, < 1 = slower, 0 = don't send
-     */
-    getSpeedFactor() {
-        if (!this.isActiveTime())
-            return 0;
-        const hour = this.getCurrentHour();
-        const day = this.getCurrentDay();
-        let factor = 1.0;
-        // Weekend reduction
-        if (day === 0 || day === 6) {
-            factor *= this.config.weekendFactor;
-        }
-        // Peak hours boost
-        const [peakStart, peakEnd] = this.config.peakHours;
-        if (hour >= peakStart && hour < peakEnd) {
-            factor *= this.config.peakFactor;
-        }
-        // Lunch slowdown
-        const [lunchStart, lunchEnd] = this.config.lunchBreak;
-        if (hour >= lunchStart && hour < lunchEnd) {
-            factor *= this.config.lunchFactor;
-        }
-        return factor;
-    }
-    /**
-     * Get ms until next active window
-     */
-    msUntilActive() {
-        if (this.isActiveTime())
-            return 0;
-        const now = new Date();
-        const hour = now.getHours();
-        const [start] = this.config.activeHours;
-        let nextActive;
-        if (hour >= this.config.activeHours[1]) {
-            // After hours — next active is tomorrow
-            nextActive = new Date(now);
-            nextActive.setDate(nextActive.getDate() + 1);
-            nextActive.setHours(start, 0, 0, 0);
-        }
-        else {
-            // Before hours — next active is today
-            nextActive = new Date(now);
-            nextActive.setHours(start, 0, 0, 0);
-        }
-        return nextActive.getTime() - now.getTime();
-    }
-    /**
-     * Adjust a delay based on current time factors
-     */
-    adjustDelay(baseDelayMs) {
-        const factor = this.getSpeedFactor();
-        if (factor === 0)
-            return -1; // Don't send
-        return Math.round(baseDelayMs / factor);
-    }
-    /**
-     * Get current schedule status
-     */
-    getStatus() {
-        const hour = this.getCurrentHour();
-        const day = this.getCurrentDay();
-        const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
-        return {
-            active: this.isActiveTime(),
-            currentHour: hour,
-            day: dayNames[day],
-            isWeekend: day === 0 || day === 6,
-            speedFactor: this.getSpeedFactor(),
-            msUntilActive: this.msUntilActive(),
-            activeWindow: `${this.config.activeHours[0]}:00 - ${this.config.activeHours[1]}:00`,
-        };
-    }
-    getCurrentHour() {
-        return new Date().getHours();
-    }
-    getCurrentDay() {
-        return new Date().getDay();
-    }
-}

package/lib/AntiBan/sessionFingerprint.js

@@ -1,248 +0,0 @@
-/**
- * Session Fingerprint Randomization (Obscura-inspired)
- *
- * Per-session fingerprint randomization to prevent device tracking.
- * Scavenged patterns from Obscura headless browser's stealth mode.
- *
- * Key principles from Obscura:
- * 1. Per-session randomization (not per-request)
- * 2. Consistent within session (same session = same fingerprint)
- * 3. Feature-flag pattern for optional anti-detection
- * 4. Emulation of real device profiles (not synthetic values)
- *
- * Browser fingerprint → WhatsApp signal mapping:
- * - TLS fingerprint → WA protocol version
- * - Canvas noise → message timing jitter
- * - Audio fingerprint → voice note metadata
- * - GPU info → device model/brand
- * - Battery → connection state variation
- * - User agent → WA client version
- *
- * @author Kobus Wentzel <kobie@pop.co.za>
- * @license MIT
- */
-import { generateFingerprint } from './deviceFingerprint.js';
-/**
- * Simple deterministic PRNG using mulberry32
- * Same as deviceFingerprint.ts for consistency
- */
-class SeededRandom {
-    state;
-    constructor(seed) {
-        let hash = 0;
-        for (let i = 0; i < seed.length; i++) {
-            hash = (hash << 5) - hash + seed.charCodeAt(i);
-            hash = hash & hash;
-        }
-        this.state = Math.abs(hash) || 1;
-    }
-    next() {
-        let t = (this.state += 0x6d2b79f5);
-        t = Math.imul(t ^ (t >>> 15), t | 1);
-        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    }
-    range(min, max) {
-        return Math.floor(this.next() * (max - min + 1)) + min;
-    }
-    rangeFloat(min, max) {
-        return this.next() * (max - min) + min;
-    }
-    pick(array) {
-        return array[Math.floor(this.next() * array.length)];
-    }
-    boolean(probability = 0.5) {
-        return this.next() < probability;
-    }
-}
-// Default configuration values (conservative, realistic)
-const DEFAULT_SEND_JITTER_MS = [50, 300];
-const DEFAULT_TYPING_JITTER_MS = [30, 150];
-const DEFAULT_RETRY_JITTER_MS = [100, 500];
-const DEFAULT_DURATION_JITTER_MS = 200;
-const DEFAULT_SAMPLE_RATE_POOL = [8000, 16000, 44100, 48000];
-const DEFAULT_IDLE_TIMEOUT_JITTER_MS = [25000, 35000];
-const DEFAULT_KEEPALIVE_JITTER_MS = [15000, 25000];
-const DEFAULT_BATTERY_LEVEL_POOL = [20, 35, 50, 65, 80, 95, 100];
-const DEFAULT_PROTOCOL_VERSION_POOL = ['2.24.5', '2.24.4', '2.24.3'];
-/**
- * Generate a comprehensive session fingerprint.
- * Call once per session (socket initialization).
- *
- * Obscura pattern: consistent per session, randomized across sessions.
- */
-export function generateSessionFingerprint(config = {}, sessionId) {
-    const { enabled = true, deviceProfile = {}, networkTiming = {}, voiceNote = {}, connectionState = {}, protocolVersion = {}, seed, } = config;
-    const finalSessionId = sessionId || `session-${Date.now()}-${Math.random()}`;
-    const rng = new SeededRandom(seed || finalSessionId);
-    // Generate base device fingerprint (delegates to deviceFingerprint.ts)
-    const device = generateFingerprint({
-        enabled,
-        randomizeAppVersion: deviceProfile.randomizeAppVersion ?? true,
-        randomizeOsVersion: deviceProfile.randomizeOsVersion ?? true,
-        randomizeDeviceModel: deviceProfile.randomizeDeviceModel ?? true,
-        seed: seed || finalSessionId,
-        appVersionPool: deviceProfile.appVersionPool,
-        osVersionPool: deviceProfile.osVersionPool,
-        deviceModelPool: deviceProfile.deviceModelPool,
-    }, finalSessionId);
-    // Network timing variances (Obscura: prevent timing pattern detection)
-    const sendJitterRange = networkTiming.sendJitterMs || DEFAULT_SEND_JITTER_MS;
-    const typingJitterRange = networkTiming.typingJitterMs || DEFAULT_TYPING_JITTER_MS;
-    const retryJitterRange = networkTiming.retryJitterMs || DEFAULT_RETRY_JITTER_MS;
-    const networkTimingProfile = enabled
-        ? {
-            sendJitterMs: rng.range(sendJitterRange[0], sendJitterRange[1]),
-            typingJitterMs: rng.range(typingJitterRange[0], typingJitterRange[1]),
-            retryJitterMs: rng.range(retryJitterRange[0], retryJitterRange[1]),
-        }
-        : {
-            sendJitterMs: 0,
-            typingJitterMs: 0,
-            retryJitterMs: 0,
-        };
-    // Voice note profile (Obscura: audio fingerprint variance)
-    const sampleRatePool = voiceNote.sampleRatePool || DEFAULT_SAMPLE_RATE_POOL;
-    const voiceNoteProfile = {
-        waveformSeed: enabled ? rng.range(0, 2147483647) : 0,
-        durationJitterMs: enabled && voiceNote.randomizeWaveform !== false
-            ? rng.range(0, voiceNote.durationJitterMs || DEFAULT_DURATION_JITTER_MS)
-            : 0,
-        sampleRate: enabled ? rng.pick(sampleRatePool) : sampleRatePool[0],
-    };
-    // Connection state profile (Obscura: battery/network state variance)
-    const idleTimeoutRange = connectionState.idleTimeoutJitterMs || DEFAULT_IDLE_TIMEOUT_JITTER_MS;
-    const keepaliveRange = connectionState.keepaliveJitterMs || DEFAULT_KEEPALIVE_JITTER_MS;
-    const batteryLevelPool = connectionState.batteryLevelPool || DEFAULT_BATTERY_LEVEL_POOL;
-    const connectionStateProfile = {
-        idleTimeoutMs: enabled
-            ? rng.range(idleTimeoutRange[0], idleTimeoutRange[1])
-            : 30000,
-        keepaliveMs: enabled
-            ? rng.range(keepaliveRange[0], keepaliveRange[1])
-            : 20000,
-        batteryLevel: enabled && connectionState.randomizeBattery !== false
-            ? rng.pick(batteryLevelPool)
-            : 100,
-        batteryCharging: enabled ? rng.boolean(0.3) : false, // 30% charging probability
-    };
-    // Protocol version (Obscura: TLS fingerprint variance → WA protocol variance)
-    const versionPool = protocolVersion.versionPool || DEFAULT_PROTOCOL_VERSION_POOL;
-    const protocolVersionStr = enabled && protocolVersion.randomizeSubVersion !== false
-        ? rng.pick(versionPool)
-        : versionPool[0];
-    return {
-        device,
-        networkTiming: networkTimingProfile,
-        voiceNote: voiceNoteProfile,
-        connectionState: connectionStateProfile,
-        protocolVersion: protocolVersionStr,
-        sessionId: finalSessionId,
-        createdAt: Date.now(),
-    };
-}
-/**
- * Apply session fingerprint to Baileys socket config.
- *
- * Usage:
- *   const fingerprint = generateSessionFingerprint({ enabled: true });
- *   const sock = makeWASocket(applySessionFingerprint(config, fingerprint));
- */
-export function applySessionFingerprint(socketConfig, fingerprint) {
-    const config = { ...socketConfig };
-    // Apply device profile (appVersion, browser tuple)
-    config.version = fingerprint.device.appVersion;
-    config.browser = [
-        fingerprint.device.deviceModel,
-        fingerprint.device.osVersion,
-        `WhatsApp/${fingerprint.device.appVersion.join('.')}`,
-    ];
-    // Apply connection timeouts if fields exist
-    if ('connectTimeoutMs' in config || config.connectTimeoutMs !== undefined) {
-        // Add idle timeout jitter to connection config
-        config.connectTimeoutMs = fingerprint.connectionState.idleTimeoutMs;
-    }
-    // Apply keepalive if supported
-    if ('keepAliveIntervalMs' in config || config.keepAliveIntervalMs !== undefined) {
-        config.keepAliveIntervalMs = fingerprint.connectionState.keepaliveMs;
-    }
-    // Store fingerprint for runtime access (helpers can read this)
-    config.__sessionFingerprint = fingerprint;
-    return config;
-}
-/**
- * Get timing jitter for message send (helper for presenceChoreographer/rateLimiter)
- *
- * Usage in beforeSend():
- *   const jitter = getMessageSendJitter(fingerprint);
- *   await sleep(baseDelay + jitter);
- */
-export function getMessageSendJitter(fingerprint) {
-    // Return a random value within ±50% of the session's base jitter
-    // This adds per-message variance while staying within session profile
-    const base = fingerprint.networkTiming.sendJitterMs;
-    return Math.floor(base * 0.5 + Math.random() * base * 0.5);
-}
-/**
- * Get typing indicator jitter (helper for presenceChoreographer)
- */
-export function getTypingJitter(fingerprint) {
-    const base = fingerprint.networkTiming.typingJitterMs;
-    return Math.floor(base * 0.5 + Math.random() * base * 0.5);
-}
-/**
- * Get retry backoff jitter (helper for reconnectThrottle)
- */
-export function getRetryJitter(fingerprint) {
-    const base = fingerprint.networkTiming.retryJitterMs;
-    return Math.floor(base * 0.5 + Math.random() * base * 0.5);
-}
-/**
- * Get voice note metadata (helper for voice message encoding)
- *
- * Returns suggested sample rate and duration adjustment based on session fingerprint.
- */
-export function getVoiceNoteMetadata(fingerprint) {
-    return {
-        sampleRate: fingerprint.voiceNote.sampleRate,
-        durationJitterMs: fingerprint.voiceNote.durationJitterMs,
-        waveformSeed: fingerprint.voiceNote.waveformSeed,
-    };
-}
-/**
- * Get battery state (helper for presence/connection state signals)
- */
-export function getBatteryState(fingerprint) {
-    return {
-        level: fingerprint.connectionState.batteryLevel,
-        charging: fingerprint.connectionState.batteryCharging,
-    };
-}
-/**
- * Create a session fingerprint preset (Obscura-inspired feature flag pattern)
- */
-export function createStealthFingerprint(sessionId) {
-    return generateSessionFingerprint({
-        enabled: true,
-        deviceProfile: {
-            randomizeAppVersion: true,
-            randomizeOsVersion: true,
-            randomizeDeviceModel: true,
-        },
-        networkTiming: {
-            sendJitterMs: [100, 500],
-            typingJitterMs: [50, 200],
-            retryJitterMs: [200, 800],
-        },
-        voiceNote: {
-            randomizeWaveform: true,
-            durationJitterMs: 300,
-        },
-        connectionState: {
-            randomizeBattery: true,
-        },
-        protocolVersion: {
-            randomizeSubVersion: true,
-        },
-    }, sessionId);
-}

package/lib/AntiBan/sessionStability.js

@@ -1,330 +0,0 @@
-/**
- * Session Stability Module — Middleware layer for Baileys socket stability
- *
- * Wraps Baileys socket to provide:
- * 1. Canonical JID normalization before sendMessage (reduces mutex race triggers)
- * 2. Typed disconnect reason classification with recovery recommendations
- * 3. Session health monitoring (Bad MAC detection and degradation alerts)
- *
- * This is a pure middleware layer — cannot modify Baileys internals, but can wrap
- * the socket interface to provide stability improvements.
- *
- * @author Kobus Wentzel <kobie@pop.co.za>
- * @license MIT
- */
-/**
- * Classify Baileys DisconnectReason codes into typed categories.
- * Based on PR #2367 and observed behavior from production bots.
- */
-export function classifyDisconnect(statusCode) {
-    // Fatal errors — logged out or banned, need QR restart
-    if (statusCode === 401 || statusCode === 440) {
-        return {
-            category: 'fatal',
-            shouldReconnect: false,
-            message: 'Logged out — restart with QR code required',
-            code: statusCode,
-        };
-    }
-    if (statusCode === 515) {
-        return {
-            category: 'fatal',
-            shouldReconnect: false,
-            message: 'Restart required by WhatsApp — client too old or protocol mismatch',
-            code: statusCode,
-        };
-    }
-    // Method not allowed — server rejecting connection method
-    if (statusCode === 405) {
-        return {
-            category: 'fatal',
-            shouldReconnect: false,
-            message: 'Method not allowed — server rejected connection method',
-            code: statusCode,
-        };
-    }
-    // Conflict / Connection replaced — user logged in elsewhere or multi-device conflict
-    if (statusCode === 409 || statusCode === 428) {
-        return {
-            category: 'fatal',
-            shouldReconnect: false,
-            message: 'Connection replaced — another device took over',
-            code: statusCode,
-        };
-    }
-    // Precondition failed — auth state mismatch, retry after delay
-    if (statusCode === 412) {
-        return {
-            category: 'recoverable',
-            shouldReconnect: true,
-            backoffMs: 30_000, // 30 seconds
-            message: 'Precondition failed — auth state mismatch, retry after delay',
-            code: statusCode,
-        };
-    }
-    // Rate limited — back off before reconnecting
-    if (statusCode === 429) {
-        return {
-            category: 'rate-limited',
-            shouldReconnect: true,
-            backoffMs: 300_000, // 5 minutes
-            message: 'Rate limited by WhatsApp — cool-off period required',
-            code: statusCode,
-        };
-    }
-    if (statusCode === 503) {
-        return {
-            category: 'rate-limited',
-            shouldReconnect: true,
-            backoffMs: 60_000, // 1 minute
-            message: 'WhatsApp service unavailable — temporary outage',
-            code: statusCode,
-        };
-    }
-    // Timeout — transient network issue
-    if (statusCode === 408) {
-        return {
-            category: 'recoverable',
-            shouldReconnect: true,
-            backoffMs: 5_000, // 5 seconds
-            message: 'Connection timeout — network issue, safe to retry',
-            code: statusCode,
-        };
-    }
-    // Internal server error — WhatsApp hiccup
-    if (statusCode === 500) {
-        return {
-            category: 'recoverable',
-            shouldReconnect: true,
-            backoffMs: 10_000, // 10 seconds
-            message: 'WhatsApp internal error — temporary server issue',
-            code: statusCode,
-        };
-    }
-    // Connection closed gracefully
-    if (statusCode === 1000) {
-        return {
-            category: 'recoverable',
-            shouldReconnect: true,
-            backoffMs: 2_000, // 2 seconds
-            message: 'Connection closed gracefully — safe to reconnect',
-            code: statusCode,
-        };
-    }
-    // Unknown code — conservative approach
-    return {
-        category: 'unknown',
-        shouldReconnect: true,
-        backoffMs: 15_000, // 15 seconds
-        message: `Unknown disconnect reason (code ${statusCode}) — reconnect with caution`,
-        code: statusCode,
-    };
-}
-const DEFAULT_HEALTH_CONFIG = {
-    badMacThreshold: 3,
-    badMacWindowMs: 60_000,
-};
-/**
- * Track session health via decrypt success/failure ratio.
- * Emits 'session:degraded' event when Bad MAC rate exceeds threshold.
- */
-export class SessionHealthMonitor {
-    config;
-    onDegraded;
-    onRecovered;
-    stats = {
-        decryptSuccess: 0,
-        decryptFail: 0,
-        badMacCount: 0,
-        isDegraded: false,
-    };
-    badMacTimestamps = [];
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_HEALTH_CONFIG, ...config };
-        this.onDegraded = config.onDegraded;
-        this.onRecovered = config.onRecovered;
-    }
-    /**
-     * Record successful decrypt
-     */
-    recordDecryptSuccess() {
-        this.stats.decryptSuccess++;
-        this.checkRecovery();
-    }
-    /**
-     * Record failed decrypt (Bad MAC or similar)
-     */
-    recordDecryptFail(isBadMac = false) {
-        this.stats.decryptFail++;
-        if (isBadMac) {
-            const now = Date.now();
-            this.stats.badMacCount++;
-            this.stats.lastBadMac = new Date(now);
-            this.badMacTimestamps.push(now);
-            // Clean up old timestamps outside window
-            const cutoff = now - this.config.badMacWindowMs;
-            this.badMacTimestamps = this.badMacTimestamps.filter(ts => ts > cutoff);
-            // Check if we've crossed threshold
-            if (!this.stats.isDegraded && this.badMacTimestamps.length >= this.config.badMacThreshold) {
-                this.stats.isDegraded = true;
-                this.stats.degradedSince = new Date(now);
-                this.onDegraded?.(this.getStats());
-            }
-        }
-    }
-    /**
-     * Check if session has recovered from degraded state
-     */
-    checkRecovery() {
-        if (!this.stats.isDegraded)
-            return;
-        const now = Date.now();
-        const cutoff = now - this.config.badMacWindowMs;
-        this.badMacTimestamps = this.badMacTimestamps.filter(ts => ts > cutoff);
-        // Recovered if Bad MAC count dropped below threshold
-        if (this.badMacTimestamps.length < this.config.badMacThreshold) {
-            this.stats.isDegraded = false;
-            this.stats.degradedSince = undefined;
-            this.onRecovered?.(this.getStats());
-        }
-    }
-    /**
-     * Get current health stats
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Reset all counters
-     */
-    reset() {
-        this.stats = {
-            decryptSuccess: 0,
-            decryptFail: 0,
-            badMacCount: 0,
-            isDegraded: false,
-        };
-        this.badMacTimestamps = [];
-    }
-}
-/**
- * Detects "deaf sessions" — WebSocket connections that stay open but stop
- * delivering messages.upsert / messages.update events.
- *
- * Root cause (Baileys issue #2491): messageMutex holding ACKs hostage under
- * Redis latency spikes causes WhatsApp's server-side flow control to stop
- * delivering messages to that client, while keepAlive pings still succeed.
- *
- * Usage: call onConnect() / onDisconnect() from connection.update events,
- * onMessageActivity() from messages.upsert and messages.update events.
- * Pass a sock reference via attach() so auto-reconnect can call sock.end().
- */
-export class DeafSessionDetector {
-    timeoutMs;
-    minUptimeMs;
-    autoReconnect;
-    onDeafSessionCb;
-    lastMessageAt = null;
-    connectedAt = null;
-    timer = null;
-    sockRef = null;
-    constructor(config = {}) {
-        this.timeoutMs = config.timeoutMs ?? 5 * 60_000;
-        this.minUptimeMs = config.minUptimeMs ?? 2 * 60_000;
-        this.autoReconnect = config.autoReconnect ?? true;
-        this.onDeafSessionCb = config.onDeafSession;
-    }
-    /** Attach a socket so auto-reconnect can call sock.end() */
-    attach(sock) {
-        this.sockRef = sock;
-    }
-    /** Call when connection.update → connection === 'open' */
-    onConnect() {
-        this.connectedAt = Date.now();
-        this.lastMessageAt = Date.now(); // reset — fresh connect is not silence
-        this.startTimer();
-    }
-    /** Call when connection.update → connection === 'close' */
-    onDisconnect() {
-        this.connectedAt = null;
-        this.stopTimer();
-    }
-    /** Call on every messages.upsert and messages.update event */
-    onMessageActivity() {
-        this.lastMessageAt = Date.now();
-    }
-    /** Release the interval — call when discarding the socket */
-    destroy() {
-        this.stopTimer();
-        this.sockRef = null;
-    }
-    startTimer() {
-        this.stopTimer();
-        this.timer = setInterval(() => this.check(), 30_000);
-    }
-    stopTimer() {
-        if (this.timer !== null) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    check() {
-        if (this.connectedAt === null)
-            return;
-        const now = Date.now();
-        const connectedSinceMs = now - this.connectedAt;
-        if (connectedSinceMs < this.minUptimeMs)
-            return;
-        const silenceDurationMs = now - (this.lastMessageAt ?? this.connectedAt);
-        if (silenceDurationMs < this.timeoutMs)
-            return;
-        const info = {
-            lastMessageAt: this.lastMessageAt !== null ? new Date(this.lastMessageAt) : null,
-            silenceDurationMs,
-            connectedSinceMs,
-        };
-        this.onDeafSessionCb?.(info);
-        if (this.autoReconnect && this.sockRef) {
-            try {
-                this.sockRef.end(new Error('deaf-session'));
-            }
-            catch {
-                // socket may already be closing
-            }
-        }
-        // Stop checking after triggering — let onConnect reset on next reconnect
-        this.stopTimer();
-    }
-}
-/**
- * Wrap a Baileys socket with session stability features.
- * Returns a Proxy that intercepts sendMessage to canonicalize JIDs.
- */
-export function wrapWithSessionStability(sock, config = {}) {
-    const { canonicalJidNormalization = true, healthMonitoring = true, health: healthConfig, lidResolver, } = config;
-    // Initialize health monitor if enabled
-    const healthMonitor = healthMonitoring ? new SessionHealthMonitor(healthConfig) : null;
-    // Return a Proxy that intercepts method calls
-    return new Proxy(sock, {
-        get(target, prop) {
-            // Intercept sendMessage for JID canonicalization
-            if (prop === 'sendMessage' && canonicalJidNormalization && lidResolver) {
-                return async (jid, content, options) => {
-                    // Canonicalize JID using LID resolver
-                    const canonical = lidResolver.resolveCanonical(jid);
-                    return target.sendMessage(canonical, content, options);
-                };
-            }
-            // Expose health monitor stats via a getter
-            if (prop === 'sessionHealthStats' && healthMonitor) {
-                return healthMonitor.getStats();
-            }
-            // Expose health monitor instance
-            if (prop === 'sessionHealthMonitor' && healthMonitor) {
-                return healthMonitor;
-            }
-            // Pass through everything else
-            return target[prop];
-        },
-    });
-}