@areumtecnologia/wasockets 1.1.6 → 2.0.0

package/lib/Store/make-in-memory-store.js

@@ -13,7 +13,9 @@ const {
 } = require("../Utils")
 const {
   jidDecode, 
-  jidNormalizedUser
+  jidNormalizedUser,
+  isPnUser,
+  isLidUser
 } = require("../WABinary")
 const { makeOrderedDictionary } = require("./make-ordered-dictionary")
 const { ObjectRepository } = require("./object-repository")
@@ -37,6 +39,7 @@ const makeInMemoryStore = (config) => {
     const chatKey = config.chatKey || waChatKey(true)
     const labelAssociationKey = config.labelAssociationKey || waLabelAssociationKey
     const logger = config.logger || DEFAULT_CONNECTION_CONFIG.logger.child({ stream: 'in-mem-store' })
+    const maxMessagesPerChat = config.maxMessagesPerChat || 500
     const KeyedDB = require('@adiwajshing/keyed-db').default
     const chats = new KeyedDB(chatKey, c => c.id)
     const messages = {}
@@ -46,6 +49,142 @@ const makeInMemoryStore = (config) => {
     const state = { connection: 'close' }
     const labels = new ObjectRepository()
     const labelAssociations = new KeyedDB(labelAssociationKey, labelAssociationKey.key)
+    const lidToId = new Map()
+    const pnToId = new Map()
+
+    const updateIndices = (contact) => {
+        if (!contact || !contact.id) return
+        const id = contact.id
+        const normId = jidNormalizedUser(id)
+        const decodedId = jidDecode(id)
+        const userId = decodedId?.user
+
+        if (isLidUser(id)) {
+            lidToId.set(id, id)
+            lidToId.set(normId, id)
+            if (userId) lidToId.set(userId, id)
+        } else if (isPnUser(id)) {
+            pnToId.set(id, id)
+            pnToId.set(normId, id)
+            if (userId) pnToId.set(userId, id)
+        }
+
+        if (contact.lid) {
+            const normLid = jidNormalizedUser(contact.lid)
+            const decodedLid = jidDecode(contact.lid)
+            lidToId.set(contact.lid, id)
+            lidToId.set(normLid, id)
+            if (decodedLid?.user) lidToId.set(decodedLid.user, id)
+        }
+
+        if (contact.phoneNumber) {
+            const normPn = jidNormalizedUser(contact.phoneNumber)
+            const decodedPn = jidDecode(contact.phoneNumber)
+            pnToId.set(contact.phoneNumber, id)
+            pnToId.set(normPn, id)
+            if (decodedPn?.user) pnToId.set(decodedPn.user, id)
+        }
+
+        // Bridge with socket signalRepository.lidMapping if available
+        const lid = contact.lid || (isLidUser(id) ? id : undefined)
+        const pn = contact.phoneNumber || (isPnUser(id) ? id : undefined)
+        if (lid && pn && isLidUser(lid) && isPnUser(pn)) {
+            if (socket?.signalRepository?.lidMapping?.storeLIDPNMappings) {
+                socket.signalRepository.lidMapping.storeLIDPNMappings([{ lid, pn }]).catch(err => {
+                    logger.debug({ err, lid, pn }, 'Error storing LID-PN mapping from contact')
+                })
+            }
+        }
+    }
+
+    const learnMapping = (jidA, jidB) => {
+        if (!jidA || !jidB) return
+        const isLidA = isLidUser(jidA)
+        const isPnA = isPnUser(jidA)
+        const isLidB = isLidUser(jidB)
+        const isPnB = isPnUser(jidB)
+
+        const lid = isLidA ? jidA : (isLidB ? jidB : undefined)
+        const pn = isPnA ? jidA : (isPnB ? jidB : undefined)
+
+        if (lid && pn) {
+            const normLid = jidNormalizedUser(lid)
+            const normPn = jidNormalizedUser(pn)
+            const userLid = jidDecode(lid)?.user
+            const userPn = jidDecode(pn)?.user
+
+            lidToId.set(lid, normPn)
+            lidToId.set(normLid, normPn)
+            if (userLid) lidToId.set(userLid, normPn)
+
+            pnToId.set(pn, normPn)
+            pnToId.set(normPn, normPn)
+            if (userPn) pnToId.set(userPn, normPn)
+
+            if (contacts[normPn]) {
+                contacts[normPn].lid = contacts[normPn].lid || normLid
+            }
+            if (contacts[normLid]) {
+                contacts[normLid].phoneNumber = contacts[normLid].phoneNumber || normPn
+            }
+
+            if (socket?.signalRepository?.lidMapping?.storeLIDPNMappings) {
+                socket.signalRepository.lidMapping.storeLIDPNMappings([{ lid: normLid, pn: normPn }]).catch(() => {})
+            }
+        }
+    }
+
+    const getContact = (jid) => {
+        if (!jid) return undefined
+        if (contacts[jid]) return contacts[jid]
+
+        const norm = jidNormalizedUser(jid)
+        if (contacts[norm]) return contacts[norm]
+
+        const decoded = jidDecode(jid)
+        const user = decoded?.user || (typeof jid === 'string' ? jid.split('@')[0].split(':')[0] : undefined)
+
+        const idFromLid = lidToId.get(jid) || lidToId.get(norm) || (user ? lidToId.get(user) : undefined)
+        if (idFromLid && contacts[idFromLid]) return contacts[idFromLid]
+
+        const idFromPn = pnToId.get(jid) || pnToId.get(norm) || (user ? pnToId.get(user) : undefined)
+        if (idFromPn && contacts[idFromPn]) return contacts[idFromPn]
+
+        for (const id in contacts) {
+            const c = contacts[id]
+            if (c.lid === jid || c.lid === norm || (c.lid && jidDecode(c.lid)?.user === user)) {
+                return c
+            }
+            if (c.phoneNumber === jid || c.phoneNumber === norm || (c.phoneNumber && jidDecode(c.phoneNumber)?.user === user)) {
+                return c
+            }
+            if (c.id === jid || c.id === norm || (c.id && jidDecode(c.id)?.user === user)) {
+                return c
+            }
+        }
+        return undefined
+    }
+
+    const getChat = (jid) => {
+        if (!jid) return undefined
+        let chat = chats.get(jid)
+        if (chat) return chat
+
+        const norm = jidNormalizedUser(jid)
+        chat = chats.get(norm)
+        if (chat) return chat
+
+        const contact = getContact(jid)
+        if (contact) {
+            const altJids = [contact.id, contact.phoneNumber, contact.lid].filter(Boolean)
+            for (const alt of altJids) {
+                chat = chats.get(alt) || chats.get(jidNormalizedUser(alt))
+                if (chat) return chat
+            }
+        }
+        return undefined
+    }
+
     const assertMessageList = (jid) => {
         if (!messages[jid]) {
             messages[jid] = makeMessagesDictionary()
@@ -57,6 +196,7 @@ const makeInMemoryStore = (config) => {
         for (const contact of newContacts) {
             oldContacts.delete(contact.id)
             contacts[contact.id] = Object.assign(contacts[contact.id] || {}, contact)
+            updateIndices(contacts[contact.id])
         }
         return oldContacts
     }
@@ -112,8 +252,12 @@ const makeInMemoryStore = (config) => {
                     contact = contacts[update.id]
                 }
                 else {
+                    contact = getContact(update.id)
+                }
+                if (!contact) {
                     const contactHashes = await Promise.all(Object.keys(contacts).map(async (contactId) => {
-                        const { user } = jidDecode(contactId)
+                        const decoded = jidDecode(contactId)
+                        const user = decoded?.user || ''
                         return [contactId, (await md5(Buffer.from(user + 'WA_ADD_NOTIF', 'utf8'))).toString('base64').slice(0, 3)]
                     }))
                     contact = contacts[contactHashes.find(([, b]) => b === update.id?.[0]) || ''] // find contact by attrs.hash, when user is not saved as a contact
@@ -125,11 +269,12 @@ const makeInMemoryStore = (config) => {
                     else if (update.imgUrl === 'removed') {
                         delete contact.imgUrl
                     }
+                    Object.assign(contacts[contact.id], update)
+                    updateIndices(contacts[contact.id])
                 }
                 else {
-                    return logger.debug({ update }, 'got update for non-existant contact')
+                    logger.debug({ update }, 'got update for non-existant contact')
                 }
-                Object.assign(contacts[contact.id], contact)
             }
         })
         ev.on('chats.upsert', newChats => {
@@ -137,13 +282,29 @@ const makeInMemoryStore = (config) => {
         })
         ev.on('chats.update', updates => {
             for (let update of updates) {
-                const result = chats.update(update.id, chat => {
+                let result = chats.update(update.id, chat => {
                     if (update.unreadCount > 0) {
                         update = { ...update }
                         update.unreadCount = (chat.unreadCount || 0) + update.unreadCount
                     }
                     Object.assign(chat, update)
                 })
+                if (!result) {
+                    const altContact = getContact(update.id)
+                    if (altContact) {
+                        const candidates = [altContact.id, altContact.phoneNumber, altContact.lid].filter(id => id && id !== update.id)
+                        for (const altId of candidates) {
+                            result = chats.update(altId, chat => {
+                                if (update.unreadCount > 0) {
+                                    update = { ...update }
+                                    update.unreadCount = (chat.unreadCount || 0) + update.unreadCount
+                                }
+                                Object.assign(chat, update)
+                            })
+                            if (result) break
+                        }
+                    }
+                }
                 if (!result) {
                     logger.debug({ update }, 'got update for non-existant chat')
                 }
@@ -190,14 +351,33 @@ const makeInMemoryStore = (config) => {
                         const jid = jidNormalizedUser(msg.key.remoteJid)
                         const list = assertMessageList(jid)
                         list.upsert(msg, 'append')
+
+                        if (maxMessagesPerChat && list.array.length > maxMessagesPerChat) {
+                            const excess = list.array.length - maxMessagesPerChat
+                            const toRemove = list.array.slice(0, excess)
+                            for (const oldMsg of toRemove) {
+                                list.remove(oldMsg)
+                            }
+                        }
+
+                        // Learn LID mapping from participantAlt / remoteJidAlt
+                        const alt = msg.key.participantAlt || msg.key.remoteJidAlt
+                        const primary = msg.key.participant || msg.key.remoteJid
+                        if (alt && primary) {
+                            learnMapping(primary, alt)
+                        }
+
                         if (type === 'notify' && !chats.get(jid)) {
-                            ev.emit('chats.upsert', [
-                                {
-                                    id: jid,
-                                    conversationTimestamp: toNumber(msg.messageTimestamp),
-                                    unreadCount: 1
-                                }
-                            ])
+                            const existingChat = getChat(jid)
+                            if (!existingChat) {
+                                ev.emit('chats.upsert', [
+                                    {
+                                        id: jid,
+                                        conversationTimestamp: toNumber(msg.messageTimestamp),
+                                        unreadCount: 1
+                                    }
+                                ])
+                            }
                         }
                     }
                     break
@@ -314,30 +494,44 @@ const makeInMemoryStore = (config) => {
         labels,
         labelAssociations,
         bind,
+        getContact,
+        getChat,
         /** loads messages from the store, if not found -- uses the legacy connection */
         loadMessages: async (jid, count, cursor) => {
-            const list = assertMessageList(jid)
+            let list = assertMessageList(jid)
+            if (list.array.length === 0) {
+                const contact = getContact(jid)
+                if (contact) {
+                    const altJids = [contact.id, contact.phoneNumber, contact.lid].filter(Boolean)
+                    for (const alt of altJids) {
+                        if (alt !== jid && messages[alt]?.array.length > 0) {
+                            list = messages[alt]
+                            break
+                        }
+                    }
+                }
+            }
             const mode = !cursor || 'before' in cursor ? 'before' : 'after'
             const cursorKey = !!cursor ? ('before' in cursor ? cursor.before : cursor.after) : undefined
             const cursorValue = cursorKey ? list.get(cursorKey.id) : undefined
-            let messages
+            let messagesResult
             if (list && mode === 'before' && (!cursorKey || cursorValue)) {
                 if (cursorValue) {
                     const msgIdx = list.array.findIndex(m => m.key.id === cursorKey?.id)
-                    messages = list.array.slice(0, msgIdx)
+                    messagesResult = list.array.slice(0, msgIdx)
                 }
                 else {
-                    messages = list.array
+                    messagesResult = list.array
                 }
-                const diff = count - messages.length
+                const diff = count - messagesResult.length
                 if (diff < 0) {
-                    messages = messages.slice(-count) // get the last X messages
+                    messagesResult = messagesResult.slice(-count) // get the last X messages
                 }
             }
             else {
-                messages = []
+                messagesResult = []
             }
-            return messages
+            return messagesResult
         },
         /**
          * Get all available labels for profile
@@ -367,18 +561,44 @@ const makeInMemoryStore = (config) => {
                 .all()
             return associations.map(({ labelId }) => labelId)
         },
-        loadMessage: async (jid, id) => messages[jid]?.get(id), 
+        loadMessage: async (jid, id) => {
+            let msg = messages[jid]?.get(id)
+            if (!msg) {
+                const contact = getContact(jid)
+                if (contact) {
+                    const altJids = [contact.id, contact.phoneNumber, contact.lid].filter(Boolean)
+                    for (const alt of altJids) {
+                        if (alt !== jid && messages[alt]?.get(id)) {
+                            return messages[alt].get(id)
+                        }
+                    }
+                }
+            }
+            return msg
+        }, 
         mostRecentMessage: async (jid) => {
-            const message = messages[jid]?.array.slice(-1)[0]
+            let message = messages[jid]?.array.slice(-1)[0]
+            if (!message) {
+                const contact = getContact(jid)
+                if (contact) {
+                    const altJids = [contact.id, contact.phoneNumber, contact.lid].filter(Boolean)
+                    for (const alt of altJids) {
+                        if (alt !== jid && messages[alt]?.array.length) {
+                            return messages[alt].array.slice(-1)[0]
+                        }
+                    }
+                }
+            }
             return message
         },
         fetchImageUrl: async (jid, suki) => {
-            const contact = contacts[jid]
+            const contact = getContact(jid) || contacts[jid]
+            const targetJid = contact?.id || jid
             if (!contact) {
-                return suki?.profilePictureUrl(jid)
+                return suki?.profilePictureUrl(targetJid)
             }
             if (typeof contact.imgUrl === 'undefined') {
-                contact.imgUrl = await suki?.profilePictureUrl(jid)
+                contact.imgUrl = await suki?.profilePictureUrl(targetJid)
             }
             return contact.imgUrl
         },
@@ -421,6 +641,55 @@ const makeInMemoryStore = (config) => {
                 const json = JSON.parse(jsonStr)
                 fromJSON(json)
             }
+        },
+        pruneMessages: (jid, keepLastN = 100) => {
+            if (jid) {
+                const list = messages[jid] || messages[jidNormalizedUser(jid)]
+                if (list && list.array.length > keepLastN) {
+                    const excess = list.array.length - keepLastN
+                    const toRemove = list.array.slice(0, excess)
+                    for (const oldMsg of toRemove) {
+                        list.remove(oldMsg)
+                    }
+                    return excess
+                }
+                return 0
+            }
+            let totalPruned = 0
+            for (const id in messages) {
+                const list = messages[id]
+                if (list && list.array.length > keepLastN) {
+                    const excess = list.array.length - keepLastN
+                    const toRemove = list.array.slice(0, excess)
+                    for (const oldMsg of toRemove) {
+                        list.remove(oldMsg)
+                    }
+                    totalPruned += excess
+                }
+            }
+            return totalPruned
+        },
+        clear: (chatId) => {
+            if (chatId) {
+                const norm = jidNormalizedUser(chatId)
+                delete messages[chatId]
+                delete messages[norm]
+            } else {
+                for (const id in messages) {
+                    delete messages[id]
+                }
+            }
+        },
+        getMessageCount: (jid) => {
+            if (jid) {
+                const list = messages[jid] || messages[jidNormalizedUser(jid)]
+                return list ? list.array.length : 0
+            }
+            let total = 0
+            for (const id in messages) {
+                total += messages[id]?.array?.length || 0
+            }
+            return total
         }
     }
 }

package/lib/Types/index.d.ts

@@ -0,0 +1,199 @@
+import { proto } from '../../WAProto'
+
+export declare const DisconnectReason: {
+    readonly connectionClosed: 428
+    readonly connectionLost: 408
+    readonly connectionReplaced: 440
+    readonly timedOut: 408
+    readonly loggedOut: 401
+    readonly badSession: 500
+    readonly restartRequired: 515
+    readonly multideviceMismatch: 411
+    readonly forbidden: 403
+    readonly unavailableService: 503
+}
+
+export type DisconnectReasonCode = typeof DisconnectReason[keyof typeof DisconnectReason]
+
+export interface AuthenticationCreds {
+    noiseKey?: any
+    pairingEphemeralKeyPair?: any
+    signedIdentityKey?: any
+    signedPreKey?: any
+    registrationId?: number
+    advSecretKey?: string
+    processedHistoryMessages?: any[]
+    nextPreKeyId?: number
+    firstUnuploadedPreKeyId?: number
+    accountSyncCounter?: number
+    accountSettings?: any
+    me?: Contact
+    signalIdentities?: any[]
+    myAppStateKeyId?: string
+    registered?: boolean
+    [key: string]: any
+}
+
+export interface SignalKeyStore {
+    get(type: string, ids: string[]): Promise<Record<string, any>>
+    set(data: Record<string, any>): Promise<void>
+    clear?(): Promise<void>
+}
+
+export interface AuthenticationState {
+    creds: AuthenticationCreds
+    keys: SignalKeyStore
+}
+
+export interface Contact {
+    id: string
+    name?: string
+    notify?: string
+    verifiedName?: string
+    imgUrl?: string | null
+    status?: string
+    [key: string]: any
+}
+
+export interface GroupParticipant {
+    id: string
+    admin?: 'admin' | 'superadmin' | null
+    [key: string]: any
+}
+
+export interface GroupMetadata {
+    id: string
+    owner?: string
+    subject: string
+    subjectOwner?: string
+    subjectTime?: number
+    creation?: number
+    desc?: string
+    descOwner?: string
+    descId?: string
+    restrict?: boolean
+    announce?: boolean
+    size?: number
+    participants: GroupParticipant[]
+    ephemeralDuration?: number
+    inviteCode?: string
+    author?: string
+    memberAddMode?: 'admin_add' | 'all_member_add'
+    approvalMode?: boolean | 'on' | 'off'
+    [key: string]: any
+}
+
+export interface WAMessageKey {
+    remoteJid?: string | null
+    fromMe?: boolean | null
+    id?: string | null
+    participant?: string | null
+}
+
+export interface WAMessageContent {
+    conversation?: string | null
+    extendedTextMessage?: any
+    imageMessage?: any
+    videoMessage?: any
+    audioMessage?: any
+    documentMessage?: any
+    stickerMessage?: any
+    contactMessage?: any
+    contactsArrayMessage?: any
+    locationMessage?: any
+    liveLocationMessage?: any
+    pollCreationMessage?: any
+    pollCreationMessageV2?: any
+    pollCreationMessageV3?: any
+    pollUpdateMessage?: any
+    reactionMessage?: any
+    [key: string]: any
+}
+
+export interface WAMessage {
+    key: WAMessageKey
+    message?: WAMessageContent | null
+    messageTimestamp?: number | any
+    pushName?: string | null
+    status?: number | string | null
+    broadcast?: boolean | null
+    [key: string]: any
+}
+
+export type AnyMessageContent =
+    | { text: string; [key: string]: any }
+    | { image: any; caption?: string; [key: string]: any }
+    | { video: any; caption?: string; [key: string]: any }
+    | { audio: any; mimetype?: string; ptt?: boolean; [key: string]: any }
+    | { document: any; mimetype: string; fileName?: string; [key: string]: any }
+    | { sticker: any; [key: string]: any }
+    | { location: { degreesLatitude: number; degreesLongitude: number; [key: string]: any }; [key: string]: any }
+    | { contacts: { displayName?: string; contacts: Array<{ vcard: string }> }; [key: string]: any }
+    | { poll: { name: string; values: string[]; selectableCount?: number }; [key: string]: any }
+    | { react: { text: string; key: WAMessageKey }; [key: string]: any }
+    | { edit: WAMessageKey; text?: string; [key: string]: any }
+    | { pin: WAMessageKey; type: number; time?: number; [key: string]: any }
+    | Record<string, any>
+
+export interface MiscMessageGenerationOptions {
+    quoted?: WAMessage
+    timestamp?: Date | number
+    messageId?: string
+    cachedGroupMetadata?: (jid: string) => Promise<GroupMetadata | undefined>
+    font?: number
+    textColor?: string
+    backgroundColor?: string
+    broadcast?: boolean
+    statusJidList?: string[]
+    [key: string]: any
+}
+
+export interface ConnectionState {
+    connection: 'close' | 'open' | 'connecting'
+    lastDisconnect?: {
+        error?: Error | any
+        date?: Date
+    }
+    isNewLogin?: boolean
+    qr?: string
+    receivedPendingNotifications?: boolean
+    legacy?: any
+    isOnline?: boolean
+}
+
+export interface WACallEvent {
+    id: string
+    from: string
+    timestamp: number
+    status: 'offer' | 'accept' | 'reject' | 'timeout' | 'terminate'
+    isVideo?: boolean
+    isGroup?: boolean
+    [key: string]: any
+}
+
+export interface BaileysEventMap {
+    'connection.update': Partial<ConnectionState>
+    'creds.update': Partial<AuthenticationCreds>
+    'messages.upsert': { messages: WAMessage[]; type: 'append' | 'notify'; [key: string]: any }
+    'messages.update': Array<{ key: WAMessageKey; update: Partial<WAMessage> }>
+    'message-receipt.update': Array<{ key: WAMessageKey; receipt: any }>
+    'messages.reaction': Array<{ key: WAMessageKey; reaction: any }>
+    'messages.delete': { keys: WAMessageKey[] } | { jid: string; all: true }
+    'chats.upsert': any[]
+    'chats.update': any[]
+    'chats.delete': string[]
+    'presence.update': { id: string; presences: Record<string, any> }
+    'contacts.upsert': Contact[]
+    'contacts.update': Partial<Contact>[]
+    'group-participants.update': { id: string; author?: string; participants: string[]; action: 'add' | 'remove' | 'demote' | 'promote' }
+    'call': WACallEvent[]
+    [key: string]: any
+}
+
+export interface BaileysEventEmitter {
+    on<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): this
+    off<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): this
+    removeAllListeners<T extends keyof BaileysEventMap>(event?: T): this
+    emit<T extends keyof BaileysEventMap>(event: T, arg: BaileysEventMap[T]): boolean
+    [key: string]: any
+}

package/lib/Utils/index.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+
+import { AuthenticationState, WAMessage, AnyMessageContent, MiscMessageGenerationOptions } from '../Types'
+import { proto } from '../../WAProto'
+
+export declare function useMultiFileAuthState(folder: string): Promise<{
+    state: AuthenticationState
+    saveCreds: () => Promise<void>
+}>
+
+export declare function shouldReconnect(error: any): boolean
+
+export declare const Browsers: {
+    ubuntu(browser: string): [string, string, string]
+    macOS(browser: string): [string, string, string]
+    baileys(browser: string): [string, string, string]
+    windows(browser: string): [string, string, string]
+    appropriate(browser: string): [string, string, string]
+}
+
+export declare function delay(ms: number): Promise<void>
+export declare function downloadMediaMessage(message: WAMessage, type: 'buffer' | 'stream', options: any, ctx?: any): Promise<Buffer | any>
+export declare function generateWAMessageFromContent(jid: string, message: proto.IMessage, options: MiscMessageGenerationOptions): any
+export declare function generateWAMessage(jid: string, content: AnyMessageContent, options: MiscMessageGenerationOptions): Promise<WAMessage>
+export declare function jidDecode(jid: string): { user: string; server: string; device?: number } | undefined
+export declare function jidNormalizedUser(jid: string): string
+export declare function areJidsSameUser(jid1: string | undefined, jid2: string | undefined): boolean
+export declare function isJidGroup(jid: string | undefined): boolean
+export declare function isJidBroadcast(jid: string | undefined): boolean
+export declare function isJidUser(jid: string | undefined): boolean
+export declare function isJidNewsletter(jid: string | undefined): boolean
+export declare function isJidStatusBroadcast(jid: string | undefined): boolean
+export declare function fetchLatestWaWebVersion(options?: any): Promise<{ version: [number, number, number]; isLatest: boolean }>

package/lib/Utils/index.js

@@ -51,4 +51,5 @@ __exportStar(require("./browser-utils"), exports)
 __exportStar(require("./use-multi-file-auth-state"), exports)
 __exportStar(require("./link-preview"), exports)
 __exportStar(require("./event-buffer"), exports)
-__exportStar(require("./process-message"), exports)
+__exportStar(require("./process-message"), exports)
+__exportStar(require("./reconnect"), exports)