@badzz88/baileys 8.5.6 → 8.5.8

package/lib/Utils/logger.js

@@ -0,0 +1,3 @@
+import P from 'pino';
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+//# sourceMappingURL=logger.js.map

package/lib/Utils/lt-hash.js

@@ -0,0 +1,8 @@
+import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */
+export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
+//# sourceMappingURL=lt-hash.js.map

package/{src → lib}/Utils/make-mutex.js

@@ -1,23 +1,19 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.makeKeyedMutex = exports.makeMutex = void 0;
-const async_mutex_1 = require('async-mutex');
-const makeMutex = () => {
-    const mutex = new async_mutex_1.Mutex();
+import { Mutex as AsyncMutex } from 'async-mutex';
+export const makeMutex = () => {
+    const mutex = new AsyncMutex();
     return {
         mutex(code) {
             return mutex.runExclusive(code);
         }
     };
 };
-exports.makeMutex = makeMutex;
-const makeKeyedMutex = () => {
+export const makeKeyedMutex = () => {
     const map = new Map();
     return {
         async mutex(key, task) {
             let entry = map.get(key);
             if (!entry) {
-                entry = { mutex: new async_mutex_1.Mutex(), refCount: 0 };
+                entry = { mutex: new AsyncMutex(), refCount: 0 };
                 map.set(key, entry);
             }
             entry.refCount++;
@@ -26,6 +22,7 @@ const makeKeyedMutex = () => {
             }
             finally {
                 entry.refCount--;
+                // only delete it if this is still the current entry
                 if (entry.refCount === 0 && map.get(key) === entry) {
                     map.delete(key);
                 }
@@ -33,4 +30,4 @@ const makeKeyedMutex = () => {
         }
     };
 };
-exports.makeKeyedMutex = makeKeyedMutex;
+//# sourceMappingURL=make-mutex.js.map

package/lib/Utils/message-composer.js

@@ -0,0 +1,273 @@
+import { proto } from '../../WAProto/index.js'
+import { generateMessageIDV2 } from './generics.js'
+
+const JS_KEYWORDS = new Set([
+    'import', 'export', 'from', 'default', 'as', 'const', 'let', 'var',
+    'function', 'class', 'extends', 'new', 'return', 'if', 'else', 'for',
+    'while', 'do', 'switch', 'case', 'break', 'continue', 'try', 'catch',
+    'finally', 'throw', 'async', 'await', 'yield', 'typeof', 'instanceof',
+    'in', 'of', 'delete', 'void', 'true', 'false', 'null', 'undefined',
+    'NaN', 'Infinity', 'this', 'super', 'static', 'get', 'set', 'debugger', 'with'
+])
+
+const PYTHON_KEYWORDS = new Set([
+    'import', 'from', 'as', 'def', 'class', 'return', 'if', 'elif', 'else',
+    'for', 'while', 'break', 'continue', 'try', 'except', 'finally', 'raise',
+    'with', 'yield', 'lambda', 'pass', 'del', 'global', 'nonlocal', 'assert',
+    'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'async', 'await',
+    'self', 'print'
+])
+
+const LANGUAGE_KEYWORDS = {
+    javascript: JS_KEYWORDS,
+    typescript: JS_KEYWORDS,
+    js: JS_KEYWORDS,
+    ts: JS_KEYWORDS,
+    python: PYTHON_KEYWORDS,
+    py: PYTHON_KEYWORDS
+}
+
+export var CodeHighlightType
+;(function (CodeHighlightType) {
+    CodeHighlightType[(CodeHighlightType['DEFAULT'] = 0)] = 'DEFAULT'
+    CodeHighlightType[(CodeHighlightType['KEYWORD'] = 1)] = 'KEYWORD'
+    CodeHighlightType[(CodeHighlightType['METHOD'] = 2)] = 'METHOD'
+    CodeHighlightType[(CodeHighlightType['STRING'] = 3)] = 'STRING'
+    CodeHighlightType[(CodeHighlightType['NUMBER'] = 4)] = 'NUMBER'
+    CodeHighlightType[(CodeHighlightType['COMMENT'] = 5)] = 'COMMENT'
+})(CodeHighlightType || (CodeHighlightType = {}))
+
+export var RichSubMessageType
+;(function (RichSubMessageType) {
+    RichSubMessageType[(RichSubMessageType['UNKNOWN'] = 0)] = 'UNKNOWN'
+    RichSubMessageType[(RichSubMessageType['GRID_IMAGE'] = 1)] = 'GRID_IMAGE'
+    RichSubMessageType[(RichSubMessageType['TEXT'] = 2)] = 'TEXT'
+    RichSubMessageType[(RichSubMessageType['INLINE_IMAGE'] = 3)] = 'INLINE_IMAGE'
+    RichSubMessageType[(RichSubMessageType['TABLE'] = 4)] = 'TABLE'
+    RichSubMessageType[(RichSubMessageType['CODE'] = 5)] = 'CODE'
+    RichSubMessageType[(RichSubMessageType['DYNAMIC'] = 6)] = 'DYNAMIC'
+    RichSubMessageType[(RichSubMessageType['MAP'] = 7)] = 'MAP'
+    RichSubMessageType[(RichSubMessageType['LATEX'] = 8)] = 'LATEX'
+    RichSubMessageType[(RichSubMessageType['CONTENT_ITEMS'] = 9)] = 'CONTENT_ITEMS'
+})(RichSubMessageType || (RichSubMessageType = {}))
+
+export const tokenizeCode = (codeStr, language = 'javascript') => {
+    const keywords = LANGUAGE_KEYWORDS[language] || JS_KEYWORDS
+    const blocks = []
+    const lines = codeStr.split('\n')
+    for (let li = 0; li < lines.length; li++) {
+        const line = lines[li]
+        const isLast = li === lines.length - 1
+        const nl = isLast? '' : '\n'
+        if (!line.trim()) {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: line + nl })
+            continue
+        }
+        if (line.trim().startsWith('//') || line.trim().startsWith('#')) {
+            blocks.push({ highlightType: CodeHighlightType.COMMENT, codeContent: line + nl })
+            continue
+        }
+        const regex = /(\/\/.*$|#.*$)|(["'`](?:[^"'`\\]|\\.)*["'`])|(\b\d+(?:\.\d+)?\b)|(\b[a-zA-Z_$][\w$]*\b)|([^\s\w$"'`]+)|(\s+)/g
+        let match
+        const tokens = []
+        while ((match = regex.exec(line))!== null) {
+            const val = match[0]
+            if (match[1]) {
+                tokens.push({ highlightType: CodeHighlightType.COMMENT, codeContent: val })
+            } else if (match[2]) {
+                tokens.push({ highlightType: CodeHighlightType.STRING, codeContent: val })
+            } else if (match[3]) {
+                tokens.push({ highlightType: CodeHighlightType.NUMBER, codeContent: val })
+            } else if (match[4]) {
+                if (keywords.has(val)) {
+                    tokens.push({ highlightType: CodeHighlightType.KEYWORD, codeContent: val })
+                } else {
+                    const after = line.slice(regex.lastIndex).trimStart()
+                    if (after.startsWith('(')) {
+                        tokens.push({ highlightType: CodeHighlightType.METHOD, codeContent: val })
+                    } else {
+                        tokens.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: val })
+                    }
+                }
+            } else {
+                tokens.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: val })
+            }
+        }
+        if (tokens.length === 0) {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: line + nl })
+            continue
+        }
+        const merged = []
+        for (const t of tokens) {
+            const prev = merged.length > 0? merged[merged.length - 1] : undefined
+            if (prev && prev.highlightType === t.highlightType) {
+                prev.codeContent += t.codeContent
+            } else {
+                merged.push({...t })
+            }
+        }
+        if (merged.length > 0) {
+            merged[merged.length - 1].codeContent += nl
+        }
+        blocks.push(...merged)
+    }
+    return blocks
+}
+
+export const buildRichContextInfo = (quoted, options) => {
+    const ctxInfo = {
+        forwardingScore: 1,
+        isForwarded: true,
+        forwardedAiBotMessageInfo: { botJid: options?.botJid? options.botJid : '867051314767696@bot' },
+        forwardOrigin: 4,
+       ...(options?.mentions? { mentionedJid: options.mentions } : {})
+    }
+    if (quoted?.key) {
+        ctxInfo.stanzaId = quoted.key.id
+        ctxInfo.participant = quoted.key.participant || quoted.sender || quoted.key.remoteJid
+        ctxInfo.quotedMessage = quoted.message
+    }
+    return ctxInfo
+}
+
+export const buildBotForwardedMessage = (submessages, contextInfo, unifiedResponse) => {
+    const richResponse = { messageType: 1, submessages, contextInfo }
+    if (unifiedResponse) {
+        richResponse.unifiedResponse = unifiedResponse
+    }
+    return {
+        botForwardedMessage: {
+            message: { richResponseMessage: richResponse }
+        }
+    }
+}
+
+export const generateTableContent = (title, headers, rows, quoted, options = {}) => {
+    const { footer, headerText } = options
+    const tableRows = [{ items: headers, isHeading: true },...rows.map(row => ({ items: row.map(String) }))]
+    const submessages = []
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText })
+    submessages.push({ messageType: 4, tableMetadata: { title, rows: tableRows } })
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const generateListContent = (title, items, quoted, options = {}) => {
+    const { footer, headerText } = options
+    const tableRows = items.map(item => ({
+        items: Array.isArray(item)? item.map(String) : [String(item)]
+    }))
+    const submessages = []
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText })
+    submessages.push({ messageType: 4, tableMetadata: { title, rows: tableRows } })
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const generateCodeBlockContent = (code, quoted, options = {}) => {
+    const { title, footer, language = 'javascript' } = options
+    const submessages = []
+    if (title) submessages.push({ messageType: 2, messageText: title })
+    submessages.push({
+        messageType: 5,
+        codeMetadata: { codeLanguage: language, codeBlocks: tokenizeCode(code, language) }
+    })
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const generateLatexContent = (quoted, options) => {
+    const { text, expressions, headerText, footer } = options
+    const submessages = []
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText })
+    const latexExpressions = expressions.map(expr => {
+        const entry = {
+            latexExpression: expr.latexExpression,
+            url: expr.url,
+            width: expr.width,
+            height: expr.height
+        }
+        if (expr.fontHeight!== undefined) entry.fontHeight = expr.fontHeight
+        if (expr.imageTopPadding!== undefined) entry.imageTopPadding = expr.imageTopPadding
+        if (expr.imageLeadingPadding!== undefined) entry.imageLeadingPadding = expr.imageLeadingPadding
+        if (expr.imageBottomPadding!== undefined) entry.imageBottomPadding = expr.imageBottomPadding
+        if (expr.imageTrailingPadding!== undefined) entry.imageTrailingPadding = expr.imageTrailingPadding
+        return entry
+    })
+    submessages.push({ messageType: 8, latexMetadata: { text: text || '', expressions: latexExpressions } })
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const generateLatexImageContent = async (quoted, options, uploadFn, renderLatexToPng) => {
+    const { text, expressions, headerText, footer } = options
+    const submessages = []
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText })
+    const latexExpressions = await Promise.all(
+        expressions.map(async expr => {
+            const { buffer, width, height } = await renderLatexToPng(expr.latexExpression)
+            const uploadResult = await uploadFn(buffer, 'image')
+            const imageUrl = uploadResult.url || uploadResult.directPath
+            return { latexExpression: expr.latexExpression, url: imageUrl, width, height }
+        })
+    )
+    submessages.push({ messageType: 8, latexMetadata: { text: text || '', expressions: latexExpressions } })
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const generateLatexInlineImageContent = async (quoted, options, uploadFn, renderLatexToPng) => {
+    const { text, expressions, headerText, footer } = options
+    const submessages = []
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText })
+    if (text) submessages.push({ messageType: 2, messageText: text })
+    for (const expr of expressions) {
+        const { buffer, width, height } = await renderLatexToPng(expr.latexExpression)
+        const uploadResult = await uploadFn(buffer, 'image')
+        const imageUrl = uploadResult.url || uploadResult.directPath
+        submessages.push({
+            messageType: 3,
+            imageMetadata: {
+                imageUrl: { imagePreviewUrl: imageUrl, imageHighResUrl: imageUrl },
+                imageText: expr.latexExpression,
+                alignment: 2
+            }
+        })
+    }
+    if (footer) submessages.push({ messageType: 2, messageText: footer })
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export const captureUnifiedResponse = msg => {
+    const botFwd = msg?.botForwardedMessage?.message
+    if (!botFwd) return null
+    const rich = botFwd.richResponseMessage
+    if (!rich?.unifiedResponse?.data) return null
+    return {
+        unifiedResponse: { data: rich.unifiedResponse.data },
+        submessages: rich.submessages || [],
+        contextInfo: rich.contextInfo || {}
+    }
+}
+
+export const generateUnifiedResponseContent = (quoted, captured) => {
+    const ctxInfo = buildRichContextInfo(quoted)
+    return { message: buildBotForwardedMessage(captured.submessages, ctxInfo, captured.unifiedResponse), messageId: generateMessageIDV2() }
+}
+
+export const generateRichMessageContent = (submessages, quoted, options) => {
+    const ctxInfo = buildRichContextInfo(quoted, options)
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() }
+}
+
+export {
+    JS_KEYWORDS,
+    PYTHON_KEYWORDS,
+    LANGUAGE_KEYWORDS
+}

package/{src → lib}/Utils/message-retry-manager.js

@@ -1,33 +1,36 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.MessageRetryManager = exports.RetryReason = void 0;
-const lru_cache_1 = require('lru-cache');
+import { LRUCache } from 'lru-cache';
+/** Number of sent messages to cache in memory for handling retry receipts */
 const RECENT_MESSAGES_SIZE = 512;
 const MESSAGE_KEY_SEPARATOR = '\u0000';
-const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000;
+/** Timeout for session recreation - 1 hour */
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000; // 1 hour in milliseconds
 const PHONE_REQUEST_DELAY = 3000;
-var RetryReason;
+// Retry reason codes matching WhatsApp Web's Signal error codes.
+export var RetryReason;
 (function (RetryReason) {
-    RetryReason[(RetryReason['UnknownError'] = 0)] = 'UnknownError';
-    RetryReason[(RetryReason['SignalErrorNoSession'] = 1)] = 'SignalErrorNoSession';
-    RetryReason[(RetryReason['SignalErrorInvalidKey'] = 2)] = 'SignalErrorInvalidKey';
-    RetryReason[(RetryReason['SignalErrorInvalidKeyId'] = 3)] = 'SignalErrorInvalidKeyId';
-    RetryReason[(RetryReason['SignalErrorInvalidMessage'] = 4)] = 'SignalErrorInvalidMessage';
-    RetryReason[(RetryReason['SignalErrorInvalidSignature'] = 5)] = 'SignalErrorInvalidSignature';
-    RetryReason[(RetryReason['SignalErrorFutureMessage'] = 6)] = 'SignalErrorFutureMessage';
-    RetryReason[(RetryReason['SignalErrorBadMac'] = 7)] = 'SignalErrorBadMac';
-    RetryReason[(RetryReason['SignalErrorInvalidSession'] = 8)] = 'SignalErrorInvalidSession';
-    RetryReason[(RetryReason['SignalErrorInvalidMsgKey'] = 9)] = 'SignalErrorInvalidMsgKey';
-    RetryReason[(RetryReason['BadBroadcastEphemeralSetting'] = 10)] = 'BadBroadcastEphemeralSetting';
-    RetryReason[(RetryReason['UnknownCompanionNoPrekey'] = 11)] = 'UnknownCompanionNoPrekey';
-    RetryReason[(RetryReason['AdvFailure'] = 12)] = 'AdvFailure';
-    RetryReason[(RetryReason['StatusRevokeDelay'] = 13)] = 'StatusRevokeDelay';
-})(RetryReason || (exports.RetryReason = RetryReason = {}));
+    RetryReason[RetryReason["UnknownError"] = 0] = "UnknownError";
+    RetryReason[RetryReason["SignalErrorNoSession"] = 1] = "SignalErrorNoSession";
+    RetryReason[RetryReason["SignalErrorInvalidKey"] = 2] = "SignalErrorInvalidKey";
+    RetryReason[RetryReason["SignalErrorInvalidKeyId"] = 3] = "SignalErrorInvalidKeyId";
+    /** MAC verification failed - most common cause of decryption failures */
+    RetryReason[RetryReason["SignalErrorInvalidMessage"] = 4] = "SignalErrorInvalidMessage";
+    RetryReason[RetryReason["SignalErrorInvalidSignature"] = 5] = "SignalErrorInvalidSignature";
+    RetryReason[RetryReason["SignalErrorFutureMessage"] = 6] = "SignalErrorFutureMessage";
+    /** Explicit MAC failure - session is definitely out of sync */
+    RetryReason[RetryReason["SignalErrorBadMac"] = 7] = "SignalErrorBadMac";
+    RetryReason[RetryReason["SignalErrorInvalidSession"] = 8] = "SignalErrorInvalidSession";
+    RetryReason[RetryReason["SignalErrorInvalidMsgKey"] = 9] = "SignalErrorInvalidMsgKey";
+    RetryReason[RetryReason["BadBroadcastEphemeralSetting"] = 10] = "BadBroadcastEphemeralSetting";
+    RetryReason[RetryReason["UnknownCompanionNoPrekey"] = 11] = "UnknownCompanionNoPrekey";
+    RetryReason[RetryReason["AdvFailure"] = 12] = "AdvFailure";
+    RetryReason[RetryReason["StatusRevokeDelay"] = 13] = "StatusRevokeDelay";
+})(RetryReason || (RetryReason = {}));
+/** Error codes that indicate a MAC failure and require immediate session recreation */
 const MAC_ERROR_CODES = new Set([RetryReason.SignalErrorInvalidMessage, RetryReason.SignalErrorBadMac]);
-class MessageRetryManager {
+export class MessageRetryManager {
     constructor(logger, maxMsgRetryCount) {
         this.logger = logger;
-        this.recentMessagesMap = new lru_cache_1.LRUCache({
+        this.recentMessagesMap = new LRUCache({
             max: RECENT_MESSAGES_SIZE,
             ttl: 5 * 60 * 1000,
             ttlAutopurge: true,
@@ -40,16 +43,16 @@ class MessageRetryManager {
             }
         });
         this.messageKeyIndex = new Map();
-        this.sessionRecreateHistory = new lru_cache_1.LRUCache({
+        this.sessionRecreateHistory = new LRUCache({
             ttl: RECREATE_SESSION_TIMEOUT * 2,
             ttlAutopurge: true
         });
-        this.retryCounters = new lru_cache_1.LRUCache({
+        this.retryCounters = new LRUCache({
             ttl: 15 * 60 * 1000,
             ttlAutopurge: true,
             updateAgeOnGet: true
-        });
-        this.baseKeys = new lru_cache_1.LRUCache({
+        }); // 15 minutes TTL
+        this.baseKeys = new LRUCache({
             max: 1024,
             ttl: 15 * 60 * 1000,
             ttlAutopurge: true
@@ -66,9 +69,13 @@ class MessageRetryManager {
         };
         this.maxMsgRetryCount = maxMsgRetryCount;
     }
+    /**
+     * Add a recent message to the cache for retry handling
+     */
     addRecentMessage(to, id, message) {
         const key = { to, id };
         const keyStr = this.keyToString(key);
+        // Add new message
         this.recentMessagesMap.set(keyStr, {
             message,
             timestamp: Date.now()
@@ -76,12 +83,20 @@ class MessageRetryManager {
         this.messageKeyIndex.set(id, keyStr);
         this.logger.debug(`Added message to retry cache: ${to}/${id}`);
     }
+    /**
+     * Get a recent message from the cache
+     */
     getRecentMessage(to, id) {
         const key = { to, id };
         const keyStr = this.keyToString(key);
         return this.recentMessagesMap.get(keyStr);
     }
+    /**
+     * Check if a session should be recreated based on retry count, history, and error code.
+     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
+     */
     shouldRecreateSession(jid, hasSession, errorCode) {
+        // If we don't have a session, always recreate
         if (!hasSession) {
             this.sessionRecreateHistory.set(jid, Date.now());
             this.statistics.sessionRecreations++;
@@ -90,6 +105,7 @@ class MessageRetryManager {
                 recreate: true
             };
         }
+        // IMMEDIATE recreation for MAC errors - session is definitely out of sync
         if (errorCode !== undefined && MAC_ERROR_CODES.has(errorCode)) {
             this.sessionRecreateHistory.set(jid, Date.now());
             this.statistics.sessionRecreations++;
@@ -101,6 +117,7 @@ class MessageRetryManager {
         }
         const now = Date.now();
         const prevTime = this.sessionRecreateHistory.get(jid);
+        // If no previous recreation or it's been more than an hour
         if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) {
             this.sessionRecreateHistory.set(jid, now);
             this.statistics.sessionRecreations++;
@@ -111,6 +128,10 @@ class MessageRetryManager {
         }
         return { reason: '', recreate: false };
     }
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
     parseRetryErrorCode(errorAttr) {
         if (errorAttr === undefined || errorAttr === '') {
             return undefined;
@@ -119,38 +140,62 @@ class MessageRetryManager {
         if (Number.isNaN(code)) {
             return undefined;
         }
+        // Validate it's a known RetryReason
         if (code >= RetryReason.UnknownError && code <= RetryReason.StatusRevokeDelay) {
             return code;
         }
         return RetryReason.UnknownError;
     }
+    /**
+     * Check if an error code indicates a MAC failure
+     */
     isMacError(errorCode) {
         return errorCode !== undefined && MAC_ERROR_CODES.has(errorCode);
     }
+    /**
+     * Increment retry counter for a message
+     */
     incrementRetryCount(messageId) {
         this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1);
         this.statistics.totalRetries++;
         return this.retryCounters.get(messageId);
     }
+    /**
+     * Get retry count for a message
+     */
     getRetryCount(messageId) {
         return this.retryCounters.get(messageId) || 0;
     }
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
     hasExceededMaxRetries(messageId) {
         return this.getRetryCount(messageId) >= this.maxMsgRetryCount;
     }
+    /**
+     * Mark retry as successful
+     */
     markRetrySuccess(messageId) {
         this.statistics.successfulRetries++;
+        // Clean up retry counter for successful message
         this.retryCounters.delete(messageId);
         this.cancelPendingPhoneRequest(messageId);
         this.removeRecentMessage(messageId);
     }
+    /**
+     * Mark retry as failed
+     */
     markRetryFailed(messageId) {
         this.statistics.failedRetries++;
         this.retryCounters.delete(messageId);
         this.cancelPendingPhoneRequest(messageId);
         this.removeRecentMessage(messageId);
     }
+    /**
+     * Schedule a phone request with delay
+     */
     schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+        // Cancel any existing request for this message
         this.cancelPendingPhoneRequest(messageId);
         this.pendingPhoneRequests[messageId] = setTimeout(() => {
             delete this.pendingPhoneRequests[messageId];
@@ -159,6 +204,9 @@ class MessageRetryManager {
         }, delay);
         this.logger.debug(`Scheduled phone request for message ${messageId} with ${delay}ms delay`);
     }
+    /**
+     * Cancel pending phone request
+     */
     cancelPendingPhoneRequest(messageId) {
         const timeout = this.pendingPhoneRequests[messageId];
         if (timeout) {
@@ -214,4 +262,4 @@ class MessageRetryManager {
         this.messageKeyIndex.delete(messageId);
     }
 }
-exports.MessageRetryManager = MessageRetryManager;
+//# sourceMappingURL=message-retry-manager.js.map