@prototypevip/baileys 0.0.9 → 0.1.1

package/lib/AntiBan/index.js

@@ -1,77 +0,0 @@
-/**
- * baileys-antiban — Anti-ban middleware for Baileys
- *
- * Wraps a Baileys socket with human-like messaging patterns
- * to minimize the risk of WhatsApp banning your number.
- *
- * @author Kobus Wentzel <kobie@pop.co.za>
- * @license MIT
- */
-// Core
-export { AntiBan } from './antiban.js';
-export { RateLimiter } from './rateLimiter.js';
-export { WarmUp } from './warmup.js';
-export { HealthMonitor } from './health.js';
-export { TimelockGuard } from './timelockGuard.js';
-// v1.3 new modules
-export { ReplyRatioGuard } from './replyRatio.js';
-export { ContactGraphWarmer } from './contactGraph.js';
-export { PresenceChoreographer, getCircadianMultiplier, } from './presenceChoreographer.js';
-// v1.5 new modules
-export { RetryReasonTracker } from './retryTracker.js';
-export { PostReconnectThrottle } from './reconnectThrottle.js';
-// v1.6 new modules
-export { LidResolver } from './lidResolver.js';
-export { JidCanonicalizer } from './jidCanonicalizer.js';
-// v2.0 new modules
-export { SessionHealthMonitor, wrapWithSessionStability, classifyDisconnect, DeafSessionDetector, } from './sessionStability.js';
-// v2.1 new modules
-export { LidFirstResolver, createLidFirstResolver, } from './lidFirstResolver.js';
-export { MessageRetryReason, MAC_ERROR_CODES, parseRetryReason, isMacError, getRetryReasonDescription, } from './retryReason.js';
-// Socket wrapper
-export { wrapSocket, wrapSocketWithFingerprint } from './wrapper.js';
-// Optional features
-export { MessageQueue } from './messageQueue.js';
-export { ContentVariator } from './contentVariator.js';
-export { WebhookAlerts } from './webhooks.js';
-export { Scheduler } from './scheduler.js';
-// State persistence
-export { FileStateAdapter } from './stateAdapter.js';
-// v3.0 new modules
-export { resolveConfig, PRESETS } from './presets.js';
-export { StateManager } from './persist.js';
-export { isGroup, isNewsletter, isBroadcast, shouldUseGroupProfile, applyGroupMultiplier } from './profiles.js';
-// v3.1 new modules
-export { messageRecovery } from './messageRecovery.js';
-// v3.2 new modules
-export { generateFingerprint, applyFingerprint, } from './deviceFingerprint.js';
-export { credsSnapshot, } from './credsSnapshot.js';
-export { readReceiptVariance, } from './readReceiptVariance.js';
-// v3.5 new modules
-export { proxyRotator, } from './proxyRotator.js';
-// v3.6 new modules (Obscura-inspired)
-export { generateSessionFingerprint, applySessionFingerprint, getMessageSendJitter, getTypingJitter, getRetryJitter, getVoiceNoteMetadata, getBatteryState, createStealthFingerprint, } from './sessionFingerprint.js';
-// v3.8 new modules
-export { getStealthSocketConfig, rampPresenceAfterConnect, STEALTH_BROWSER_POOL, AbortError, } from './stealthConnect.js';
-// v4.0 new modules
-export { GroupOperationGuard, classifyGroupOpError, extractPrivacyBlock, GROUP_OP_ERRORS, } from './groupOperationGuard.js';
-// v4.1 new modules
-export { LegitimacySignalInjector, } from './legitimacySignalInjector.js';
-// v4.2 new modules
-export { BanRecoveryOrchestrator, } from './banRecoveryOrchestrator.js';
-// v4.3 new modules
-export { DeliveryTracker } from './deliveryTracker.js';
-// v4.4 new modules
-export { InstanceCoordinator } from './instanceCoordinator.js';
-// v4.7 new modules
-export { JidCircuitBreaker, createJidCircuitBreaker } from './jidCircuitBreaker.js';
-export { createFleetEventStore, createMySQLEventStoreBackend, createInMemoryEventStoreBackend } from './fleetEventStore.js';
-export { HumanEntropyService, createHumanEntropyService } from './humanEntropy.js';
-// v4.8 new modules
-export { MessageTypeRegistry } from './messageTypeRegistry.js';
-export { exportAntibanState, importAntibanState } from './stateExport.js';
-export { TopologyThrottler } from './topologyThrottler.js';
-// v4.9 new modules
-export { ReputationVoucher } from './reputationVoucher.js';
-// Observability
-export { createConsoleLogger, exportPrometheusMetrics, createMetricsHandler, createPeriodicExporter, } from './observability.js';

package/lib/AntiBan/instanceCoordinator.js

@@ -1,175 +0,0 @@
-/**
- * InstanceCoordinator — cross-process rate pool via shared state file
- *
- * Problem: N bot instances on the same IP each enforce their own per-minute
- * limit. Collectively they can exceed safe IP-level thresholds.
- *
- * Solution: shared JSON file updated on every send. Each instance reads the
- * shared pool before sending and deducts from a shared per-minute budget.
- *
- * File format: { sends: number[], updatedAt: number }
- *   sends = array of timestamps (ms) of recent sends across ALL instances
- *
- * Coordination model: optimistic read-modify-write with rename-swap atomicity.
- * Race window is tiny (sub-ms) and consequences are minor (brief over-limit).
- * No hard lock needed — this is best-effort coordination, not a mutex.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-export class InstanceCoordinator {
-    config;
-    constructor(config) {
-        this.config = {
-            sharedFilePath: config.sharedFilePath,
-            poolMaxPerMinute: config.poolMaxPerMinute ?? 20,
-            poolMaxPerHour: config.poolMaxPerHour ?? 500,
-            poolExhaustedDelayMs: config.poolExhaustedDelayMs ?? 5000,
-            staleThresholdMs: config.staleThresholdMs ?? 120000, // 2 minutes
-        };
-        // Ensure directory exists
-        const dir = path.dirname(this.config.sharedFilePath);
-        if (!fs.existsSync(dir)) {
-            try {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            catch (err) {
-                console.warn(`[baileys-antiban] instanceCoordinator: Failed to create directory ${dir}:`, err);
-            }
-        }
-    }
-    /**
-     * Try to acquire a send slot from the shared pool.
-     * Returns { allowed: true } if send is allowed, or { allowed: false, retryAfterMs } if pool is exhausted.
-     */
-    tryAcquireSlot() {
-        try {
-            const now = Date.now();
-            let state = this.readState();
-            // Filter stale timestamps (older than staleThreshold)
-            const staleThreshold = now - this.config.staleThresholdMs;
-            state.sends = state.sends.filter(ts => ts > staleThreshold);
-            // Calculate time windows
-            const oneMinuteAgo = now - 60000;
-            const oneHourAgo = now - 3600000;
-            const sendsLastMinute = state.sends.filter(ts => ts > oneMinuteAgo).length;
-            const sendsLastHour = state.sends.filter(ts => ts > oneHourAgo).length;
-            // Check minute limit
-            if (sendsLastMinute >= this.config.poolMaxPerMinute) {
-                const oldestInWindow = state.sends.filter(ts => ts > oneMinuteAgo).sort((a, b) => a - b)[0];
-                const retryAfterMs = oldestInWindow ? Math.max(1000, oldestInWindow + 60000 - now) : this.config.poolExhaustedDelayMs;
-                return { allowed: false, retryAfterMs };
-            }
-            // Check hour limit
-            if (sendsLastHour >= this.config.poolMaxPerHour) {
-                const oldestInWindow = state.sends.filter(ts => ts > oneHourAgo).sort((a, b) => a - b)[0];
-                const retryAfterMs = oldestInWindow ? Math.max(10000, oldestInWindow + 3600000 - now) : 60000;
-                return { allowed: false, retryAfterMs };
-            }
-            // Acquire slot — add current timestamp
-            state.sends.push(now);
-            state.updatedAt = now;
-            // Prune to last 2 hours to prevent unbounded growth
-            const twoHoursAgo = now - 7200000;
-            state.sends = state.sends.filter(ts => ts > twoHoursAgo);
-            // Write back atomically
-            this.writeState(state);
-            return { allowed: true };
-        }
-        catch (err) {
-            // Fail open — coordination failure should never block sends
-            console.warn('[baileys-antiban] instanceCoordinator: Error in tryAcquireSlot, failing open:', err);
-            return { allowed: true };
-        }
-    }
-    /**
-     * Get current statistics for the shared pool
-     */
-    getStats() {
-        try {
-            const now = Date.now();
-            const state = this.readState();
-            const oneMinuteAgo = now - 60000;
-            const oneHourAgo = now - 3600000;
-            const sendsLastMinute = state.sends.filter(ts => ts > oneMinuteAgo).length;
-            const sendsLastHour = state.sends.filter(ts => ts > oneHourAgo).length;
-            return {
-                poolSendsLastMinute: sendsLastMinute,
-                poolSendsLastHour: sendsLastHour,
-                poolMaxPerMinute: this.config.poolMaxPerMinute,
-                poolMaxPerHour: this.config.poolMaxPerHour,
-                poolUtilization: sendsLastMinute / this.config.poolMaxPerMinute,
-                coordinationFilePath: this.config.sharedFilePath,
-            };
-        }
-        catch (err) {
-            console.warn('[baileys-antiban] instanceCoordinator: Error in getStats:', err);
-            return {
-                poolSendsLastMinute: 0,
-                poolSendsLastHour: 0,
-                poolMaxPerMinute: this.config.poolMaxPerMinute,
-                poolMaxPerHour: this.config.poolMaxPerHour,
-                poolUtilization: 0,
-                coordinationFilePath: this.config.sharedFilePath,
-            };
-        }
-    }
-    /**
-     * Read coordination state from file. Returns empty state if file doesn't exist.
-     */
-    readState() {
-        try {
-            if (!fs.existsSync(this.config.sharedFilePath)) {
-                return { sends: [], updatedAt: Date.now() };
-            }
-            const content = fs.readFileSync(this.config.sharedFilePath, 'utf-8');
-            const parsed = JSON.parse(content);
-            // Validate structure
-            if (!Array.isArray(parsed.sends) || typeof parsed.updatedAt !== 'number') {
-                console.warn('[baileys-antiban] instanceCoordinator: Invalid state file format, resetting');
-                return { sends: [], updatedAt: Date.now() };
-            }
-            return parsed;
-        }
-        catch (err) {
-            // File doesn't exist or is corrupt — return empty state
-            return { sends: [], updatedAt: Date.now() };
-        }
-    }
-    /**
-     * Write coordination state to file atomically using rename-swap
-     */
-    writeState(state) {
-        try {
-            const tmp = `${this.config.sharedFilePath}.tmp.${process.pid}`;
-            fs.writeFileSync(tmp, JSON.stringify(state), 'utf-8');
-            fs.renameSync(tmp, this.config.sharedFilePath);
-        }
-        catch (err) {
-            console.warn('[baileys-antiban] instanceCoordinator: Failed to write state file:', err);
-            // Fail silently — don't throw, this is best-effort coordination
-        }
-    }
-    /**
-     * BUG FIX 3: Sync local rate limiter with shared pool after reconnect
-     * Reads shared pool timestamps and injects them into the local limiter's sliding window.
-     * This prevents the double-spend window where the limiter thinks it has full budget
-     * post-reconnect but the shared pool already shows most slots used.
-     */
-    syncLocalLimiter(rateLimiter) {
-        try {
-            const state = this.readState();
-            const now = Date.now();
-            // Filter to last 24 hours (rate limiter's cleanup window)
-            const recentTimestamps = state.sends.filter(ts => now - ts < 86400000);
-            // Inject into local rate limiter
-            rateLimiter.injectTimestamps(recentTimestamps);
-            if (recentTimestamps.length > 0) {
-                console.log(`[baileys-antiban] instanceCoordinator: Synced ${recentTimestamps.length} shared pool timestamps to local limiter after reconnect`);
-            }
-        }
-        catch (err) {
-            console.warn('[baileys-antiban] instanceCoordinator: Failed to sync local limiter:', err);
-            // Fail silently — this is best-effort sync
-        }
-    }
-}

package/lib/AntiBan/jidCanonicalizer.js

@@ -1,256 +0,0 @@
-/**
- * JID Canonicalizer — Opt-in middleware for LID/PN normalization
- *
- * Wraps LidResolver to provide automatic:
- * 1. Learning from incoming message events
- * 2. Canonicalization of outbound send targets
- *
- * This mitigates the LID/PN race condition that causes "Bad MAC / No Session /
- * Invalid PreKey" errors (Baileys issue #1769, our PR #2372).
- *
- * Usage:
- *   const canonicalizer = new JidCanonicalizer({ enabled: true });
- *
- *   // On incoming event
- *   canonicalizer.onIncomingEvent({ messages: [...] });
- *
- *   // On outbound send
- *   const canonicalJid = canonicalizer.canonicalizeTarget(jid);
- *   await sock.sendMessage(canonicalJid, content);
- *
- * Note: This is a middleware-layer mitigation. The root fix requires merging
- * PR #2372 into Baileys' crypto pipeline.
- */
-import { LidResolver } from './lidResolver.js';
-const DEFAULT_CONFIG = {
-    enabled: false,
-    canonicalizeOutbound: true,
-    learnFromEvents: true,
-};
-export class JidCanonicalizer {
-    config;
-    lidResolver;
-    ownsResolver; // Track if we created the resolver (for destroy)
-    stats = {
-        outboundCanonicalized: 0,
-        outboundPassthrough: 0,
-        inboundLearned: 0,
-        canonicalKeyHits: 0,
-        canonicalKeyMisses: 0,
-    };
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        // Use provided resolver or create new one
-        if (config.resolver) {
-            this.lidResolver = config.resolver;
-            this.ownsResolver = false;
-        }
-        else {
-            this.lidResolver = new LidResolver(config.resolverConfig);
-            this.ownsResolver = true;
-        }
-    }
-    /**
-     * Access the underlying resolver (for cross-module sharing)
-     */
-    get resolver() {
-        return this.lidResolver;
-    }
-    /**
-     * Called by wrapper on every outbound send. Returns canonical JID.
-     */
-    canonicalizeTarget(jid) {
-        if (!this.config.enabled || !this.config.canonicalizeOutbound) {
-            return jid;
-        }
-        const canonical = this.lidResolver.resolveCanonical(jid);
-        if (canonical !== jid) {
-            this.stats.outboundCanonicalized++;
-        }
-        else {
-            this.stats.outboundPassthrough++;
-        }
-        return canonical;
-    }
-    /**
-     * Returns a stable, canonical thread key for storage / DB indexing.
-     *
-     * Different from `canonicalizeTarget()` (which picks the right send target):
-     * - canonicalizeTarget('1234@lid') → '+27...@s.whatsapp.net' (best send target)
-     * - canonicalKey('1234@lid')      → 'thread:27...'  (stable thread identifier)
-     *
-     * If LID has known PN mapping → use phone-number form
-     * If only LID known → use LID stripped of suffix
-     * Always lowercase, no @-suffix, prefixed with `thread:`
-     *
-     * Apps using this as their DB key won't double-thread on LID/PN drift.
-     *
-     * @param jid - WhatsApp JID (can be PN, LID, group, or broadcast)
-     * @returns Stable thread key for DB indexing
-     */
-    canonicalKey(jid) {
-        // Defensive: handle null/undefined/empty
-        if (!jid || typeof jid !== 'string' || jid.trim() === '') {
-            return 'thread:invalid';
-        }
-        const normalized = jid.trim().toLowerCase();
-        // Extract parts: user@domain
-        const atIndex = normalized.indexOf('@');
-        if (atIndex === -1) {
-            return 'thread:invalid';
-        }
-        const user = normalized.substring(0, atIndex);
-        const domain = normalized.substring(atIndex + 1);
-        // Handle special domains
-        if (domain === 'g.us') {
-            // Group chat
-            return `thread:group:${user}`;
-        }
-        if (domain === 'broadcast') {
-            // Broadcast list
-            return `thread:broadcast:${user}`;
-        }
-        if (domain === 'newsletter') {
-            // Newsletter (WA Channels)
-            return `thread:newsletter:${user}`;
-        }
-        // Handle @s.whatsapp.net (PN form)
-        if (domain === 's.whatsapp.net') {
-            this.stats.canonicalKeyHits++;
-            return `thread:${user}`;
-        }
-        // Handle @lid form
-        if (domain === 'lid') {
-            // Try to resolve to PN via learned mappings
-            const mapping = this.lidResolver.getMapping(normalized);
-            if (mapping?.pn) {
-                // We have a PN mapping — use it
-                const pnUser = mapping.pn.split('@')[0];
-                this.stats.canonicalKeyHits++;
-                return `thread:${pnUser}`;
-            }
-            else {
-                // No PN known yet — use LID form
-                this.stats.canonicalKeyMisses++;
-                return `thread:lid:${user}`;
-            }
-        }
-        // Unknown domain — return generic form
-        return `thread:${domain}:${user}`;
-    }
-    /**
-     * Called by wrapper on messages.upsert event. Learns mappings.
-     */
-    onIncomingEvent(upsert) {
-        if (!this.config.enabled || !this.config.learnFromEvents) {
-            return;
-        }
-        for (const msg of upsert.messages || []) {
-            this.learnFromMessage(msg);
-        }
-    }
-    /**
-     * Learn LID↔PN mappings from group metadata participants.
-     * Call after fetchGroupMetadata() to pre-populate the resolver map.
-     * No-op if canonicalization is disabled.
-     *
-     * @param participants - Group metadata participants array from Baileys
-     * @returns Number of new mappings learned (0 if disabled)
-     */
-    learnFromGroupMetadata(participants) {
-        if (!this.config.enabled || !this.config.learnFromEvents) {
-            return 0;
-        }
-        return this.lidResolver.learnFromGroupMetadata(participants);
-    }
-    /**
-     * Called by wrapper on messages.update event. Learns from sent-message refs.
-     */
-    onMessageUpdate(updates) {
-        if (!this.config.enabled || !this.config.learnFromEvents) {
-            return;
-        }
-        for (const update of updates) {
-            // messages.update doesn't typically carry LID info — mostly for retry tracking
-            // But handle edge case where update.key has participant/participantPn
-            if (update.key) {
-                this.learnFromMessageKey(update.key);
-            }
-        }
-    }
-    getStats() {
-        return {
-            resolver: this.lidResolver.getStats(),
-            outboundCanonicalized: this.stats.outboundCanonicalized,
-            outboundPassthrough: this.stats.outboundPassthrough,
-            inboundLearned: this.stats.inboundLearned,
-            canonicalKeyHits: this.stats.canonicalKeyHits,
-            canonicalKeyMisses: this.stats.canonicalKeyMisses,
-        };
-    }
-    destroy() {
-        // Only destroy resolver if we created it
-        if (this.ownsResolver) {
-            this.lidResolver.destroy();
-        }
-    }
-    // Private helpers
-    /**
-     * Extract LID↔PN mappings from a message object
-     */
-    learnFromMessage(msg) {
-        if (!msg.key)
-            return;
-        // Extract from message key
-        this.learnFromMessageKey(msg.key);
-        // Additional extraction from message envelope (if present)
-        // Some Baileys forks/versions expose participantPn at the message level
-        if (msg.participantPn && msg.key.participant) {
-            this.lidResolver.learn({
-                lid: msg.key.participant.endsWith('@lid') ? msg.key.participant : undefined,
-                pn: msg.participantPn,
-            });
-            this.stats.inboundLearned++;
-        }
-    }
-    /**
-     * Extract mappings from message.key
-     */
-    learnFromMessageKey(key) {
-        if (!key)
-            return;
-        // Case 1: participant (LID) + participantPn (PN)
-        // This appears in group messages where sender uses LID
-        if (key.participant && key.participantPn) {
-            if (key.participant.endsWith('@lid')) {
-                this.lidResolver.learn({
-                    lid: key.participant,
-                    pn: key.participantPn,
-                });
-                this.stats.inboundLearned++;
-            }
-        }
-        // Case 2: remoteJid (LID) + senderPn (PN)
-        // This appears in 1:1 messages from LID senders
-        if (key.remoteJid && key.senderPn) {
-            if (key.remoteJid.endsWith('@lid')) {
-                this.lidResolver.learn({
-                    lid: key.remoteJid,
-                    pn: key.senderPn,
-                });
-                this.stats.inboundLearned++;
-            }
-        }
-        // Case 3: participant (PN) exists but we have remoteJid (LID)
-        // Inverse case where participant is PN form
-        if (key.participant && key.remoteJid) {
-            if (key.participant.endsWith('@s.whatsapp.net') && key.remoteJid.endsWith('@lid')) {
-                this.lidResolver.learn({
-                    lid: key.remoteJid,
-                    pn: key.participant,
-                });
-                this.stats.inboundLearned++;
-            }
-        }
-    }
-}

package/lib/AntiBan/jidCircuitBreaker.js

@@ -1,186 +0,0 @@
-/**
- * JID Circuit Breaker — Per-recipient circuit breaker for send protection
- *
- * Tracks failures per JID and opens circuit after threshold to prevent
- * cascading failures and reduce ban risk on problematic recipients.
- *
- * State machine:
- * - closed: Normal operation, sends allowed
- * - open: Threshold exceeded, sends blocked until cooldown
- * - half-open: Cooldown elapsed, allow one probe send
- *
- * Usage:
- *   const breaker = createJidCircuitBreaker({ failureThreshold: 3, cooldownMs: 30_000 });
- *   if (!breaker.canSend(jid)) throw new Error('circuit open');
- *   // ... send message ...
- *   breaker.recordSuccess(jid);  // or recordFailure(jid)
- */
-const EVICTION_AGE_MS = 10 * 60 * 1000; // 10 minutes
-export class JidCircuitBreaker {
-    failureThreshold;
-    cooldownMs;
-    logger;
-    circuits = new Map();
-    constructor(config) {
-        this.failureThreshold = config?.failureThreshold ?? 3;
-        this.cooldownMs = config?.cooldownMs ?? 30_000;
-        this.logger = config?.logger;
-    }
-    evictStale() {
-        const now = Date.now();
-        const staleJids = [];
-        this.circuits.forEach((entry, jid) => {
-            const age = entry.openedAt ? now - entry.openedAt : Infinity;
-            if (age > EVICTION_AGE_MS && entry.state === 'closed') {
-                staleJids.push(jid);
-            }
-        });
-        for (const jid of staleJids) {
-            this.circuits.delete(jid);
-        }
-    }
-    getOrCreateEntry(jid) {
-        let entry = this.circuits.get(jid);
-        if (!entry) {
-            entry = {
-                state: 'closed',
-                failures: 0,
-                openedAt: null,
-                halfOpenProbeUsed: false,
-            };
-            this.circuits.set(jid, entry);
-            // Evict stale entries periodically
-            if (this.circuits.size > 1000) {
-                this.evictStale();
-            }
-        }
-        return entry;
-    }
-    canSend(jid) {
-        const entry = this.getOrCreateEntry(jid);
-        const now = Date.now();
-        if (entry.state === 'closed') {
-            return true;
-        }
-        if (entry.state === 'open') {
-            // Check if cooldown has elapsed
-            if (entry.openedAt && now - entry.openedAt >= this.cooldownMs) {
-                // Transition to half-open
-                entry.state = 'half-open';
-                entry.halfOpenProbeUsed = false;
-                this.logger?.info('[circuit-breaker] transitioning to half-open', { jid });
-                return true;
-            }
-            return false;
-        }
-        if (entry.state === 'half-open') {
-            // Allow one probe
-            if (!entry.halfOpenProbeUsed) {
-                entry.halfOpenProbeUsed = true;
-                return true;
-            }
-            return false;
-        }
-        return false;
-    }
-    recordSuccess(jid) {
-        const entry = this.getOrCreateEntry(jid);
-        if (entry.state === 'half-open') {
-            // Probe succeeded, reset to closed
-            entry.state = 'closed';
-            entry.failures = 0;
-            entry.openedAt = null;
-            entry.halfOpenProbeUsed = false;
-            this.logger?.info('[circuit-breaker] reset to closed after successful probe', { jid });
-        }
-        else if (entry.state === 'closed') {
-            // Normal operation, reset failure count
-            entry.failures = 0;
-        }
-    }
-    recordFailure(jid) {
-        const entry = this.getOrCreateEntry(jid);
-        const now = Date.now();
-        if (entry.state === 'half-open') {
-            // Probe failed, reopen circuit
-            entry.state = 'open';
-            entry.openedAt = now;
-            entry.halfOpenProbeUsed = false;
-            this.logger?.warn('[circuit-breaker] reopened after failed probe', { jid });
-            return;
-        }
-        if (entry.state === 'closed') {
-            entry.failures += 1;
-            if (entry.failures >= this.failureThreshold) {
-                entry.state = 'open';
-                entry.openedAt = now;
-                this.logger?.warn('[circuit-breaker] opened circuit', { jid, failures: entry.failures, threshold: this.failureThreshold });
-            }
-        }
-    }
-    getState(jid) {
-        const entry = this.circuits.get(jid);
-        return entry?.state ?? 'closed';
-    }
-    getJitter(isBroadcast) {
-        if (!isBroadcast)
-            return 0;
-        return Math.floor(Math.random() * 500) + 400;
-    }
-    getStats() {
-        let open = 0;
-        let halfOpen = 0;
-        let closed = 0;
-        this.circuits.forEach((entry) => {
-            if (entry.state === 'open')
-                open++;
-            else if (entry.state === 'half-open')
-                halfOpen++;
-            else
-                closed++;
-        });
-        return {
-            open,
-            halfOpen,
-            closed,
-            total: this.circuits.size,
-        };
-    }
-    /**
-     * BUG FIX 2: Export all circuit states for persistence
-     * Returns array of { jid, state, failures, openedAt, halfOpenProbeUsed }
-     */
-    exportState() {
-        const result = [];
-        this.circuits.forEach((entry, jid) => {
-            // Only export circuits that are open or half-open (non-trivial state)
-            if (entry.state !== 'closed' || entry.failures > 0) {
-                result.push({
-                    jid,
-                    state: entry.state,
-                    failures: entry.failures,
-                    openedAt: entry.openedAt,
-                    halfOpenProbeUsed: entry.halfOpenProbeUsed,
-                });
-            }
-        });
-        return result;
-    }
-    /**
-     * BUG FIX 2: Import circuit states from persistence
-     * Restores open/half-open circuits so blocked JIDs remain blocked after restart
-     */
-    importState(states) {
-        for (const item of states) {
-            this.circuits.set(item.jid, {
-                state: item.state,
-                failures: item.failures,
-                openedAt: item.openedAt,
-                halfOpenProbeUsed: item.halfOpenProbeUsed ?? false,
-            });
-        }
-    }
-}
-export function createJidCircuitBreaker(config) {
-    return new JidCircuitBreaker(config);
-}