@badzz88/baileys 8.4.9 → 8.5.0

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

@@ -0,0 +1,262 @@
+'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

@@ -0,0 +1,82 @@
+'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/{src → lib}/Utils/noise-handler.js

@@ -4,7 +4,7 @@ exports.makeNoiseHandler = void 0
 const boom_1 = require('@hapi/boom')
 const index_js_1 = require('../../WAProto/index.js')
 const Defaults_1 = require('../Defaults')
-const rb = require('whatsapp-rust-bridge-baron')
+const rb = require('./native-bridge').loadRustBridge()
 
 // rustNodeToJs mirrors the one in decode.js — converts InternalBinaryNode to plain JS object
 const rustNodeToJs = node => {
@@ -33,6 +33,14 @@ const makeNoiseHandler = ({
 }) => {
 	logger = logger.child({ class: 'ns' })
 
+	if (!rb) {
+		throw new Error(
+			'Establishing a WhatsApp connection requires the "whatsapp-rust-bridge" native module ' +
+				'(Noise protocol handshake + session), which failed to load. Make sure it is installed: ' +
+				'npm install whatsapp-rust-bridge@0.5.4'
+		)
+	}
+
 	const session = new rb.NoiseSession(
 		publicKey instanceof Uint8Array ? publicKey : new Uint8Array(publicKey),
 		NOISE_HEADER instanceof Uint8Array ? NOISE_HEADER : new Uint8Array(NOISE_HEADER),
@@ -85,7 +93,7 @@ const makeNoiseHandler = ({
 				} else {
 					try {
 						frame = rustNodeToJs(item.toJSON())
-					} catch {
+					} catch (e) {
 						continue
 					}
 				}
@@ -140,20 +148,13 @@ const makeNoiseHandler = ({
 				throw new boom_1.Boom('certification match failed', { statusCode: 400 })
 			}
 
-			// Extract server static key from leaf cert — used to cache for NoiseIkSession (fast reconnect)
-			let serverStaticPub
-			try {
-				const leafDetails = index_js_1.proto.CertChain.NoiseCertificate.Details.decode(leaf.details)
-				if (leafDetails.key?.length === 32) serverStaticPub = Buffer.from(leafDetails.key)
-			} catch {}
-
 			// Encrypt our static key and do final ECDH
 			const keyEnc = session.processHandshakeFinish(
 				noiseKey.public instanceof Uint8Array ? noiseKey.public : new Uint8Array(noiseKey.public),
 				noiseKey.private instanceof Uint8Array ? noiseKey.private : new Uint8Array(noiseKey.private),
 				serverHello.ephemeral
 			)
-			return { keyEnc: Buffer.from(keyEnc), serverStaticPub }
+			return Buffer.from(keyEnc)
 		},
 		encodeFrame: data => {
 			const u8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
@@ -161,13 +162,14 @@ const makeNoiseHandler = ({
 		},
 		decodeFrame: async (newData, onFrame) => {
 			if (isWaitingForTransport) {
-				pendingBytes = pendingBytes ? Buffer.concat([pendingBytes, Buffer.from(newData)]) : Buffer.from(newData)
+				pendingBytes = pendingBytes
+					? Buffer.concat([pendingBytes, Buffer.from(newData)])
+					: Buffer.from(newData)
 				pendingOnFrame = onFrame
 				return
 			}
 
-			const u8 =
-				newData instanceof Uint8Array ? newData : new Uint8Array(newData.buffer, newData.byteOffset, newData.byteLength)
+			const u8 = newData instanceof Uint8Array ? newData : new Uint8Array(newData.buffer, newData.byteOffset, newData.byteLength)
 			const frames = session.decodeFrame(u8)
 
 			for (let i = 0; i < frames.length; i++) {

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

@@ -110,17 +110,14 @@ const cleanMessage = (message, meId, meLid) => {
 	}
 }
 exports.cleanMessage = cleanMessage
+// TODO: target:audit AUDIT THIS FUNCTION AGAIN
 const isRealMessage = message => {
-	// Stub-type system events (missed calls, participant-add) never carry message.message,
-	// so they must short-circuit here — gating them behind hasSomeContent below made this
-	// branch permanently dead (audited 2026-07-19).
-	if (REAL_MSG_STUB_TYPES.has(message.messageStubType) || REAL_MSG_REQ_ME_STUB_TYPES.has(message.messageStubType)) {
-		return true
-	}
 	const normalizedContent = (0, messages_1.normalizeMessageContent)(message.message)
 	const hasSomeContent = !!(0, messages_1.getContentType)(normalizedContent)
 	return (
-		!!normalizedContent &&
+		(!!normalizedContent ||
+			REAL_MSG_STUB_TYPES.has(message.messageStubType) ||
+			REAL_MSG_REQ_ME_STUB_TYPES.has(message.messageStubType)) &&
 		hasSomeContent &&
 		!normalizedContent?.protocolMessage &&
 		!normalizedContent?.reactionMessage &&
@@ -682,7 +679,7 @@ const processMessage = async (
 				{
 					id: jid,
 					...update,
-					author: message.key.participant,
+					author: message.key.participant ?? undefined,
 					authorPn: message.key.participantAlt,
 					authorUsername: message.key.participantUsername
 				}
@@ -763,7 +760,7 @@ const processMessage = async (
 				const approvalMode = message.messageStubParameters?.[0]
 				emitGroupUpdate({ joinApprovalMode: approvalMode === 'on' })
 				break
-			case Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD:
+			case Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD: // TODO: Add other events
 				const participant = JSON.parse(message.messageStubParameters?.[0])
 				const action = message.messageStubParameters?.[1]
 				const method = message.messageStubParameters?.[2]
@@ -995,51 +992,55 @@ const processMessage = async (
 				emitGroupUpdate({ hidden: true })
 				break
 		}
-	} else if (content?.pollUpdateMessage) {
-		const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey
-		const pollMsg = await getMessage(creationMsgKey)
-		if (pollMsg) {
-			// message may be wrapped in viewOnce or botInvoke — unwrap to find messageSecret
-			const inner = pollMsg.viewOnceMessage?.message || pollMsg.botInvokeMessage?.message || pollMsg
-			const pollEncKey = inner.messageContextInfo?.messageSecret || pollMsg.messageContextInfo?.messageSecret || null
-			if (!pollEncKey) {
-				logger?.warn({ creationMsgKey }, 'poll: messageSecret missing, cannot decrypt vote')
-			} else {
-				// prefer LID for pollCreatorJid; WA uses the addressing JID of the poll creator
-				const rawLid = creds.me?.lid
-				const meLidNorm = rawLid ? `${rawLid.split(':')[0]}@lid` : ''
-				const pollCreatorJid = meLidNorm || (0, WABinary_1.jidNormalizedUser)(meId)
-				// voterJid: use the primary addressing JID (LID or PN) from the update key
-				const voterJid = message.key.fromMe ? pollCreatorJid : message.key.participant || message.key.remoteJid
-				try {
-					const voteMsg = decryptPollVote(content.pollUpdateMessage.vote, {
-						pollEncKey,
-						pollCreatorJid,
-						pollMsgId: creationMsgKey.id,
-						voterJid
-					})
-					ev.emit('messages.update', [
-						{
-							key: creationMsgKey,
-							update: {
-								pollUpdates: [
-									{
-										pollUpdateMessageKey: message.key,
-										vote: voteMsg,
-										senderTimestampMs: (0, generics_1.toNumber)(content.pollUpdateMessage.senderTimestampMs)
-									}
-								]
-							}
-						}
-					])
-				} catch (err) {
-					logger?.warn({ err, creationMsgKey, pollCreatorJid, voterJid }, 'failed to decrypt poll vote')
-				}
-			}
-		} else {
-			logger?.warn({ creationMsgKey }, 'poll: creation message not found, cannot decrypt vote')
-		}
-	}
+	} /*  else if(content?.pollUpdateMessage) {
+        const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey!
+        // we need to fetch the poll creation message to get the poll enc key
+        // TODO: make standalone, remove getMessage reference
+        // TODO: Remove entirely
+        const pollMsg = await getMessage(creationMsgKey)
+        if(pollMsg) {
+            const meIdNormalised = jidNormalizedUser(meId)
+            const pollCreatorJid = getKeyAuthor(creationMsgKey, meIdNormalised)
+            const voterJid = getKeyAuthor(message.key, meIdNormalised)
+            const pollEncKey = pollMsg.messageContextInfo?.messageSecret!
+
+            try {
+                const voteMsg = decryptPollVote(
+                    content.pollUpdateMessage.vote!,
+                    {
+                        pollEncKey,
+                        pollCreatorJid,
+                        pollMsgId: creationMsgKey.id!,
+                        voterJid,
+                    }
+                )
+                ev.emit('messages.update', [
+                    {
+                        key: creationMsgKey,
+                        update: {
+                            pollUpdates: [
+                                {
+                                    pollUpdateMessageKey: message.key,
+                                    vote: voteMsg,
+                                    senderTimestampMs: (content.pollUpdateMessage.senderTimestampMs! as Long).toNumber(),
+                                }
+                            ]
+                        }
+                    }
+                ])
+            } catch(err) {
+                logger?.warn(
+                    { err, creationMsgKey },
+                    'failed to decrypt poll vote'
+                )
+            }
+        } else {
+            logger?.warn(
+                { creationMsgKey },
+                'poll creation message not found, cannot decrypt update'
+            )
+        }
+        } */
 	if (Object.keys(chat).length > 1) {
 		ev.emit('chats.update', [chat])
 	}

package/{src → lib}/Utils/reporting-utils.js

@@ -1,7 +1,7 @@
 'use strict'
 Object.defineProperty(exports, '__esModule', { value: true })
 exports.getMessageReportingToken = exports.shouldIncludeReportingToken = void 0
-const rb = require('whatsapp-rust-bridge-baron')
+const Crypto_1 = require('./crypto')
 const crypto_2 = require('./crypto')
 const reportingFields = [
 	{ f: 1 },
@@ -246,7 +246,7 @@ const getMessageReportingToken = async (msgProtobuf, message, key) => {
 	if (!content || content.length === 0) {
 		return null
 	}
-	const reportingToken = Buffer.from(rb.hmacSign(content, reportingSecret)).subarray(0, 16)
+	const reportingToken = Buffer.from(Crypto_1.hmacSign(content, reportingSecret)).subarray(0, 16)
 	return {
 		tag: 'reporting',
 		attrs: {},

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,94 @@
+'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