@badzz88/baileys 8.5.7 → 8.5.8

package/lib/Utils/jid-display-normalization.js

@@ -1,218 +0,0 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.normalizeMessageForDisplayJids = void 0
-exports.normalizeMentionedJidsForSend = void 0
-
-const WABinary_1 = require('../WABinary')
-
-const createLidPnDebug = logger => {
-	const enabled = process.env.LID_PN_DEBUG === '1' || process.env.LID_PN_DEBUG === 'true'
-	return (phase, payload) => {
-		if (!enabled) {
-			return
-		}
-		logger?.debug({ ...payload, phase }, 'lid->pn normalization trace')
-	}
-}
-
-const fallbackPnFromLidJid = jid => {
-	const decoded = (0, WABinary_1.jidDecode)(jid)
-	const rawUser = decoded?.user || (typeof jid === 'string' ? jid.split('@')[0] : '')
-	const user = rawUser.split(':')[0]
-	if (!user) {
-		return jid
-	}
-	return `${user}@s.whatsapp.net`
-}
-
-const toDisplayPnJid = jid => {
-	if (!jid || typeof jid !== 'string') {
-		return jid
-	}
-	const decoded = (0, WABinary_1.jidDecode)(jid)
-	if (!decoded?.user) {
-		return jid
-	}
-	if (!(0, WABinary_1.isPnUser)(jid) && !(0, WABinary_1.isHostedPnUser)(jid)) {
-		return jid
-	}
-	const user = decoded.user.split(':')[0]
-	if (!user) {
-		return jid
-	}
-	const server = decoded.server === 'hosted' ? 'hosted' : 's.whatsapp.net'
-	return `${user}@${server}`
-}
-
-const buildLidPnHints = key => {
-	const hints = new Map()
-	if (!key) {
-		return hints
-	}
-	const addHint = (lid, pn) => {
-		if (!(0, WABinary_1.isLidUser)(lid) && !(0, WABinary_1.isHostedLidUser)(lid)) {
-			return
-		}
-		if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn)) {
-			return
-		}
-		hints.set(lid, pn)
-		const lidDecoded = (0, WABinary_1.jidDecode)(lid)
-		const pnDecoded = (0, WABinary_1.jidDecode)(pn)
-		if (lidDecoded?.user && pnDecoded?.user) {
-			hints.set(`${lidDecoded.user}@lid`, `${pnDecoded.user}@s.whatsapp.net`)
-		}
-	}
-	addHint(key.participant, key.participantAlt)
-	addHint(key.remoteJid, key.remoteJidAlt)
-	addHint(key.participantAlt, key.participant)
-	addHint(key.remoteJidAlt, key.remoteJid)
-	return hints
-}
-
-const mergeGroupDataHints = (hints, groupData, debug) => {
-	if (!groupData?.participants?.length) {
-		return
-	}
-	debug?.('groupData-size', { participants: groupData.participants.length })
-	for (const participant of groupData.participants) {
-		const lidCandidate = participant?.lid
-		const idCandidate = participant?.id
-		const pnCandidate = participant?.phoneNumber
-		const lid =
-			((0, WABinary_1.isLidUser)(lidCandidate) || (0, WABinary_1.isHostedLidUser)(lidCandidate)
-				? lidCandidate
-				: undefined) ||
-			((0, WABinary_1.isLidUser)(idCandidate) || (0, WABinary_1.isHostedLidUser)(idCandidate) ? idCandidate : undefined)
-		const pn =
-			((0, WABinary_1.isPnUser)(pnCandidate) || (0, WABinary_1.isHostedPnUser)(pnCandidate)
-				? pnCandidate
-				: undefined) ||
-			((0, WABinary_1.isPnUser)(idCandidate) || (0, WABinary_1.isHostedPnUser)(idCandidate) ? idCandidate : undefined)
-		if (!lid || !pn) {
-			continue
-		}
-		if (
-			((0, WABinary_1.isLidUser)(lid) || (0, WABinary_1.isHostedLidUser)(lid)) &&
-			((0, WABinary_1.isPnUser)(pn) || (0, WABinary_1.isHostedPnUser)(pn))
-		) {
-			const displayPn = toDisplayPnJid(pn)
-			hints.set(lid, displayPn)
-			const lidDecoded = (0, WABinary_1.jidDecode)(lid)
-			if (lidDecoded?.user) {
-				hints.set(`${lidDecoded.user}@lid`, displayPn)
-			}
-			debug?.('group-hint', { lid, pn: displayPn })
-		}
-	}
-}
-
-const normalizeToPnJid = async (jid, hints, signalRepository, debug) => {
-	if (!jid || typeof jid !== 'string') {
-		return jid
-	}
-	if (!(0, WABinary_1.isLidUser)(jid) && !(0, WABinary_1.isHostedLidUser)(jid)) {
-		return jid
-	}
-	debug?.('input', { lid: jid })
-	const hinted = hints.get(jid)
-	if (hinted) {
-		const normalized = toDisplayPnJid(hinted)
-		debug?.('hint-exact', { lid: jid, hinted, normalized })
-		return normalized
-	}
-	const decoded = (0, WABinary_1.jidDecode)(jid)
-	if (decoded?.user) {
-		const userHint = hints.get(`${decoded.user}@lid`)
-		if (userHint) {
-			const normalized = toDisplayPnJid(userHint)
-			debug?.('hint-user', { lid: jid, userHint, normalized })
-			return normalized
-		}
-	}
-	const mapped = await signalRepository?.lidMapping?.getPNForLID?.(jid)
-	if (mapped) {
-		const normalized = toDisplayPnJid(mapped)
-		debug?.('mapping', { lid: jid, mapped, normalized })
-		return normalized
-	}
-	const fallback = fallbackPnFromLidJid(jid)
-	debug?.('fallback', { lid: jid, fallback })
-	return fallback
-}
-
-const normalizeMentionedJidsToPn = async (node, hints, signalRepository, debug) => {
-	if (!node || typeof node !== 'object') {
-		return
-	}
-	if (Array.isArray(node)) {
-		for (const item of node) {
-			await normalizeMentionedJidsToPn(item, hints, signalRepository, debug)
-		}
-		return
-	}
-	if (Array.isArray(node.mentionedJid)) {
-		const before = [...node.mentionedJid]
-		node.mentionedJid = await Promise.all(
-			node.mentionedJid.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug))
-		)
-		debug?.('mentions', { before, after: node.mentionedJid })
-	}
-	if (typeof node.participant === 'string') {
-		const before = node.participant
-		node.participant = await normalizeToPnJid(node.participant, hints, signalRepository, debug)
-		if (before !== node.participant) {
-			debug?.('participant-field', { before, after: node.participant })
-		}
-	}
-	if (typeof node.remoteJid === 'string') {
-		const before = node.remoteJid
-		node.remoteJid = await normalizeToPnJid(node.remoteJid, hints, signalRepository, debug)
-		if (before !== node.remoteJid) {
-			debug?.('remoteJid-field', { before, after: node.remoteJid })
-		}
-	}
-	for (const value of Object.values(node)) {
-		if (value && typeof value === 'object') {
-			await normalizeMentionedJidsToPn(value, hints, signalRepository, debug)
-		}
-	}
-}
-
-const normalizeMentionedJidsForSend = async (mentions, groupData, signalRepository, logger) => {
-	if (!Array.isArray(mentions)) {
-		return mentions
-	}
-	const debug = createLidPnDebug(logger)
-	const hints = new Map()
-	mergeGroupDataHints(hints, groupData, debug)
-	const normalized = await Promise.all(mentions.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug)))
-	debug('send-mentions-result', { before: mentions, after: normalized })
-	return normalized
-}
-
-const normalizeMessageForDisplayJids = async (messageInfo, signalRepository, logger, groupData) => {
-	if (!messageInfo?.key) {
-		return messageInfo
-	}
-	const debug = createLidPnDebug(logger)
-	const hints = buildLidPnHints(messageInfo.key)
-	mergeGroupDataHints(hints, groupData, debug)
-	const beforeKey = { ...messageInfo.key }
-	messageInfo.key.participant = await normalizeToPnJid(messageInfo.key.participant, hints, signalRepository, debug)
-	messageInfo.key.participantAlt = await normalizeToPnJid(
-		messageInfo.key.participantAlt,
-		hints,
-		signalRepository,
-		debug
-	)
-	messageInfo.key.remoteJid = await normalizeToPnJid(messageInfo.key.remoteJid, hints, signalRepository, debug)
-	messageInfo.key.remoteJidAlt = await normalizeToPnJid(messageInfo.key.remoteJidAlt, hints, signalRepository, debug)
-	await normalizeMentionedJidsToPn(messageInfo.message, hints, signalRepository, debug)
-	debug('display-key-result', { before: beforeKey, after: messageInfo.key })
-	return messageInfo
-}
-
-exports.normalizeMessageForDisplayJids = normalizeMessageForDisplayJids
-exports.normalizeMentionedJidsForSend = normalizeMentionedJidsForSend

package/lib/Utils/meta-ai-msmsg.js

@@ -1,262 +0,0 @@
-'use strict'
-
-const Crypto_1 = require('./crypto')
-const { proto } = require('../../WAProto')
-
-const BOT_MESSAGE_INFO = 'Bot Message'
-const KEY_LENGTH = 32
-const AUTH_TAG_LENGTH = 16
-
-const MSG_ID_HEX_RE = /^[0-9A-Fa-f]{32}$/
-
-const unpadRandomMax16 = value => {
-	const bytes = new Uint8Array(value)
-	if (!bytes.length) {
-		throw new Error('unpadPkcs7 given empty bytes')
-	}
-
-	const padLength = bytes[bytes.length - 1]
-	if (padLength > bytes.length) {
-		throw new Error(`unpad given ${bytes.length} bytes, but pad is ${padLength}`)
-	}
-
-	return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.length - padLength)
-}
-
-const toBuffer = value => {
-	if (Buffer.isBuffer(value)) {
-		return value
-	}
-
-	if (value instanceof Uint8Array) {
-		return Buffer.from(value.buffer, value.byteOffset, value.byteLength)
-	}
-
-	return Buffer.from(value)
-}
-
-const normalizeLidJid = jid => {
-	if (!jid || !jid.endsWith('@lid') || !jid.includes(':')) {
-		return jid
-	}
-
-	return `${jid.split(':')[0]}@lid`
-}
-
-const buildMessageIdRepresentations = messageId => {
-	const ascii = Buffer.from(messageId)
-	const binary = MSG_ID_HEX_RE.test(messageId) ? Buffer.from(messageId, 'hex') : ascii
-	return [
-		{ label: 'msgIdAscii', value: ascii },
-		...(binary.equals(ascii) ? [] : [{ label: 'msgIdBinary', value: binary }])
-	]
-}
-
-const pushUnique = (items, seen, item) => {
-	const key = JSON.stringify([
-		item.messageId,
-		item.idSource,
-		item.idSources,
-		item.infoSource,
-		item.aadSource,
-		item.info.toString('hex'),
-		item.aad.toString('hex')
-	])
-
-	if (!seen.has(key)) {
-		seen.add(key)
-		items.push(item)
-	}
-}
-
-const getCandidateIds = messageKey => {
-	const orderedCandidates = [
-		messageKey?.botType === 'full'
-			? { source: 'stanzaId', messageId: messageKey?.stanzaId }
-			: { source: 'botEditTargetId', messageId: messageKey?.botEditTargetId },
-		{ source: 'targetId', messageId: messageKey?.targetId },
-		{ source: 'metaTargetId', messageId: messageKey?.metaTargetId },
-		{ source: 'stanzaId', messageId: messageKey?.stanzaId }
-	]
-
-	const targetIdCandidates = Array.isArray(messageKey?.targetIdCandidates) ? messageKey.targetIdCandidates : []
-	for (let index = 0; index < targetIdCandidates.length; index += 1) {
-		orderedCandidates.push({
-			source: `targetIdCandidates[${index}]`,
-			messageId: targetIdCandidates[index]
-		})
-	}
-
-	const grouped = new Map()
-	for (const candidate of orderedCandidates) {
-		if (!candidate.messageId) {
-			continue
-		}
-
-		const messageId = String(candidate.messageId)
-		const existing = grouped.get(messageId)
-		if (existing) {
-			if (!existing.idSources.includes(candidate.source)) {
-				existing.idSources.push(candidate.source)
-			}
-		} else {
-			grouped.set(messageId, {
-				messageId,
-				idSource: candidate.source,
-				idSources: [candidate.source]
-			})
-		}
-	}
-
-	return Array.from(grouped.values())
-}
-
-const getJidCandidates = messageKey => {
-	const ordered = [
-		{ source: 'meId', jid: messageKey?.meId },
-		{ source: 'conversationJid', jid: messageKey?.conversationJid },
-		{ source: 'senderJid', jid: messageKey?.senderJid },
-		{ source: 'meLidNormalized', jid: normalizeLidJid(messageKey?.meLid) }
-	]
-
-	const seen = new Set()
-	const candidates = []
-	for (const candidate of ordered) {
-		if (!candidate.jid) {
-			continue
-		}
-
-		const jid = String(candidate.jid)
-		if (!seen.has(jid)) {
-			seen.add(jid)
-			candidates.push({ source: candidate.source, jid, value: Buffer.from(jid) })
-		}
-	}
-
-	return candidates
-}
-
-const buildMsmsgDecryptionStrategies = messageKey => {
-	const botJid = String(messageKey?.participant || '')
-	const botJidBuffer = Buffer.from(botJid)
-	const targetIds = getCandidateIds(messageKey)
-	const jidCandidates = getJidCandidates(messageKey)
-	const primaryJid = jidCandidates[0]
-	const alternateJid = jidCandidates.find(
-		candidate => candidate.source !== primaryJid?.source && candidate.jid !== botJid
-	)
-	const strategies = []
-	const seen = new Set()
-
-	for (const idCandidate of targetIds) {
-		const idForms = buildMessageIdRepresentations(idCandidate.messageId)
-		for (const idForm of idForms) {
-			pushUnique(strategies, seen, {
-				mode: '2step',
-				idSource: idCandidate.idSource,
-				idSources: idCandidate.idSources,
-				infoSource: `${idForm.label}+meId+botJid`,
-				aadSource: `${idForm.label}+0+botJid`,
-				authTagLayout: 'trailing',
-				messageId: idCandidate.messageId,
-				info: Buffer.concat([idForm.value, primaryJid.value, botJidBuffer, Buffer.alloc(0)]),
-				aad: Buffer.concat([idForm.value, Buffer.from([0]), botJidBuffer]),
-				attemptLabel: `${idCandidate.idSource}:${idForm.label}:primary`
-			})
-
-			if (alternateJid) {
-				pushUnique(strategies, seen, {
-					mode: '2step',
-					idSource: idCandidate.idSource,
-					idSources: idCandidate.idSources,
-					infoSource: `${idForm.label}+${alternateJid.source}+botJid`,
-					aadSource: `${idForm.label}+0+${alternateJid.source}`,
-					authTagLayout: 'trailing',
-					messageId: idCandidate.messageId,
-					info: Buffer.concat([idForm.value, alternateJid.value, botJidBuffer, Buffer.alloc(0)]),
-					aad: Buffer.concat([idForm.value, Buffer.from([0]), alternateJid.value]),
-					attemptLabel: `${idCandidate.idSource}:${idForm.label}:${alternateJid.source}`
-				})
-			}
-		}
-	}
-
-	return strategies.slice(0, 12)
-}
-
-const assertRequired = (value, label) => {
-	if (
-		!value ||
-		(Buffer.isBuffer(value) && value.length === 0) ||
-		(value instanceof Uint8Array && value.byteLength === 0)
-	) {
-		throw new Error(`Missing required ${label} for msmsg decryption`)
-	}
-}
-
-const decryptWithStrategy = (messageSecret, msMsg, strategy) => {
-	const baseSecret = Buffer.from(Crypto_1.hkdf(toBuffer(messageSecret), KEY_LENGTH, { info: BOT_MESSAGE_INFO }))
-	const key = Buffer.from(Crypto_1.hkdf(baseSecret, KEY_LENGTH, { info: strategy.info }))
-	const payload = toBuffer(msMsg.encPayload)
-	// ciphertext = payload without last 16 bytes (auth tag) + auth tag appended → standard GCM layout
-	const ciphertextWithTag = Buffer.concat([payload.slice(0, -AUTH_TAG_LENGTH), payload.slice(-AUTH_TAG_LENGTH)])
-	return Buffer.from(Crypto_1.aesDecryptGCM(ciphertextWithTag, key, toBuffer(msMsg.encIv), strategy.aad))
-}
-
-const decodeDecryptedMsmsgMessage = decrypted => {
-	const messageBuffer = toBuffer(decrypted)
-
-	try {
-		const unpadded = Buffer.from(unpadRandomMax16(messageBuffer))
-		const decoded = proto.Message.decode(unpadded)
-		const hasContent = Object.keys(decoded).some(key => key !== 'messageContextInfo' && decoded[key] != null)
-		if (hasContent) {
-			return decoded
-		}
-	} catch {}
-
-	return proto.Message.decode(messageBuffer)
-}
-
-const decryptMsmsgBotMessage = async (messageSecret, messageKey, msMsg) => {
-	assertRequired(messageSecret, 'messageSecret')
-	assertRequired(messageKey?.participant, 'participant')
-	assertRequired(messageKey?.meId, 'meId')
-	assertRequired(msMsg?.encIv, 'encIv')
-	assertRequired(msMsg?.encPayload, 'encPayload')
-	if (getCandidateIds(messageKey).length === 0) {
-		throw new Error('Missing required target message id for msmsg decryption')
-	}
-
-	const strategies = buildMsmsgDecryptionStrategies(messageKey)
-	const attemptedStrategies = []
-	let lastError
-
-	for (const strategy of strategies) {
-		const attempt = {
-			idSource: strategy.idSource,
-			idSources: strategy.idSources,
-			infoSource: strategy.infoSource,
-			aadSource: strategy.aadSource,
-			messageId: strategy.messageId
-		}
-
-		try {
-			return await decryptWithStrategy(messageSecret, msMsg, strategy)
-		} catch (error) {
-			attemptedStrategies.push(attempt)
-			lastError = error
-		}
-	}
-
-	const error = new Error('Failed to decrypt msmsg with bounded deterministic strategies')
-	error.attemptedStrategies = attemptedStrategies
-	error.cause = lastError
-	throw error
-}
-
-module.exports = {
-	buildMsmsgDecryptionStrategies,
-	decodeDecryptedMsmsgMessage,
-	decryptMsmsgBotMessage
-}

package/lib/Utils/native-bridge.js

@@ -1,82 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.loadRustBridge = void 0
-const fs = require('fs')
-const path = require('path')
-
-const BRIDGE_NAME = 'whatsapp-rust-bridge'
-let cached
-let attempted = false
-
-/**
- * Finds the installed package directory for `pkgName` by walking the same
- * node_modules search path Node itself would use, without going through
- * Node's package "exports" resolution gate.
- */
-const findPackageDir = pkgName => {
-	let searchPaths
-	try {
-		searchPaths = require.resolve.paths(pkgName) || []
-	} catch {
-		searchPaths = []
-	}
-	for (const dir of searchPaths) {
-		const candidate = path.join(dir, pkgName)
-		if (fs.existsSync(path.join(candidate, 'package.json'))) {
-			return candidate
-		}
-	}
-	return null
-}
-
-/**
- * Loads whatsapp-rust-bridge, tolerating published versions/forks whose
- * package.json ships an "exports" map with no "." entry (or an otherwise
- * broken one) -- which makes a plain `require('whatsapp-rust-bridge')` throw
- * ERR_PACKAGE_PATH_NOT_EXPORTED even though the module's files are present
- * and perfectly usable. In that case, we locate the package directory
- * ourselves and require its real entry file directly, bypassing the broken
- * "exports" gate. Returns the loaded module, or null if it's unavailable.
- */
-const loadRustBridge = () => {
-	if (attempted) return cached
-	attempted = true
-	try {
-		cached = require(BRIDGE_NAME)
-		return cached
-	} catch (error) {
-		const recoverableCodes = new Set(['ERR_PACKAGE_PATH_NOT_EXPORTED', 'ERR_PACKAGE_IMPORT_NOT_DEFINED'])
-		if (!recoverableCodes.has(error?.code)) {
-			cached = null
-			return null
-		}
-		try {
-			const dir = findPackageDir(BRIDGE_NAME)
-			if (!dir) {
-				cached = null
-				return null
-			}
-			const pkgJson = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'))
-			const candidates = [
-				pkgJson.main,
-				'index.js',
-				'index.node',
-				'dist/index.js',
-				'lib/index.js',
-				'build/index.js'
-			].filter(Boolean)
-			for (const rel of candidates) {
-				const fullPath = path.join(dir, rel)
-				if (fs.existsSync(fullPath)) {
-					cached = require(fullPath)
-					return cached
-				}
-			}
-		} catch {
-			// fall through to returning null below
-		}
-		cached = null
-		return null
-	}
-}
-exports.loadRustBridge = loadRustBridge

package/lib/Utils/session-pool.d.ts

@@ -1,16 +0,0 @@
-export interface SessionPoolOptions {
-	makeSocket: (sessionId: string) => Promise<any> | any
-	logger?: any
-	maxBackoffMs?: number
-	onSessionUpdate?: (sessionId: string, sock: any) => void
-	onLoggedOut?: (sessionId: string) => void
-}
-
-export interface SessionPool {
-	add: (sessionId: string) => Promise<void>
-	remove: (sessionId: string) => void
-	get: (sessionId: string) => any
-	list: () => string[]
-}
-
-export function createSessionPool(options: SessionPoolOptions): SessionPool

package/lib/Utils/session-pool.js

@@ -1,94 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })
-exports.createSessionPool = void 0
-
-const DISCONNECT_REASON_LOGGED_OUT = 401
-
-/**
- * Manages multiple Baileys socket instances (one per account/session), automatically
- * restarting any session that disconnects -- except when it was logged out -- using
- * exponential backoff with jitter, instead of every project re-implementing its own
- * reconnect loop.
- *
- * @param {{
- *   makeSocket: (sessionId: string) => Promise<any> | any,
- *   logger?: any,
- *   maxBackoffMs?: number,
- *   onSessionUpdate?: (sessionId: string, sock: any) => void,
- *   onLoggedOut?: (sessionId: string) => void
- * }} options
- * @returns {{
- *   add: (sessionId: string) => Promise<void>,
- *   remove: (sessionId: string) => void,
- *   get: (sessionId: string) => any,
- *   list: () => string[]
- * }}
- */
-const createSessionPool = options => {
-	const logger = options.logger
-	const maxBackoffMs = options.maxBackoffMs ?? 60000
-	const sessions = new Map() // sessionId -> { sock, attempts, stopped }
-
-	const computeBackoffMs = attempts => {
-		const base = Math.min(1000 * 2 ** attempts, maxBackoffMs)
-		return base + Math.floor(Math.random() * (base * 0.2))
-	}
-
-	const start = async sessionId => {
-		const entry = sessions.get(sessionId) || { attempts: 0, stopped: false }
-		sessions.set(sessionId, entry)
-		if (entry.stopped) return
-		try {
-			const sock = await options.makeSocket(sessionId)
-			entry.sock = sock
-			options.onSessionUpdate?.(sessionId, sock)
-			sock.ev.on('connection.update', update => {
-				if (update.connection === 'open') {
-					entry.attempts = 0
-				}
-				if (update.connection === 'close') {
-					const statusCode = update.lastDisconnect?.error?.output?.statusCode
-					if (statusCode === DISCONNECT_REASON_LOGGED_OUT) {
-						logger?.info?.({ sessionId }, 'session logged out, removing from pool')
-						sessions.delete(sessionId)
-						options.onLoggedOut?.(sessionId)
-						return
-					}
-					if (entry.stopped) return
-					entry.attempts += 1
-					const backoffMs = computeBackoffMs(entry.attempts)
-					logger?.warn?.(
-						{ sessionId, attempt: entry.attempts, backoffMs },
-						'session disconnected, reconnecting with backoff'
-					)
-					setTimeout(() => start(sessionId), backoffMs)
-				}
-			})
-		} catch (error) {
-			entry.attempts += 1
-			const backoffMs = computeBackoffMs(entry.attempts)
-			logger?.error?.({ error, sessionId, backoffMs }, 'failed to start session, retrying with backoff')
-			if (!entry.stopped) {
-				setTimeout(() => start(sessionId), backoffMs)
-			}
-		}
-	}
-
-	const add = sessionId => start(sessionId)
-	const remove = sessionId => {
-		const entry = sessions.get(sessionId)
-		if (!entry) return
-		entry.stopped = true
-		if (entry.sock?.end) {
-			try {
-				entry.sock.end(undefined)
-			} catch {}
-		}
-		sessions.delete(sessionId)
-	}
-	const get = sessionId => sessions.get(sessionId)?.sock
-	const list = () => [...sessions.keys()]
-
-	return { add, remove, get, list }
-}
-exports.createSessionPool = createSessionPool

package/lib/Utils/sticker.d.ts

@@ -1,17 +0,0 @@
-export interface StickerMetaOptions {
-	packName?: string
-	packPublisher?: string
-	categories?: string[]
-}
-
-export function addExifToWebp(webpBuffer: Buffer, options?: StickerMetaOptions): Promise<Buffer>
-
-export function imageToWebpSticker(
-	imageBuffer: Buffer,
-	options?: StickerMetaOptions & { quality?: number }
-): Promise<Buffer>
-
-export function videoToWebpSticker(
-	videoBuffer: Buffer,
-	options?: StickerMetaOptions & { fps?: number; seconds?: number }
-): Promise<Buffer>

package/lib/Utils/view-once-cache.d.ts

@@ -1,9 +0,0 @@
-export interface AutoCacheViewOnceOptions {
-	cacheDir?: string
-	logger?: any
-	onCached?: (info: { id: string; jid: string; filePath: string; type: string }) => void
-}
-
-export function getViewOnceContent(message: any): Record<string, any> | null
-
-export function autoCacheViewOnceMedia(sock: any, options?: AutoCacheViewOnceOptions): () => void