@prototypevip/baileys 0.0.8 → 0.0.9

package/lib/AntiBan/index.js

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

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

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

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