fix: address PR review — stale comments, mutex key normalization, test sync

- Update stale comments in event-buffer.ts (15s→3s) and socket.ts (5s→2s)
  to reflect actual timeout values
- Normalize mutex keys with jidNormalizedUser() for receiptMutex and
  notificationMutex to handle device suffix variants (e.g. user:5@s.whatsapp.net)
- Update offline-buffer-timeout.test.ts to match new 2s timeout value
  (was hardcoded at 5s, causing test/source divergence)
- Rejected suggestion to use attrs.id as fallback (false positive — attrs.id
  is a message ID, not a chat identifier; 'unknown' is the correct catch-all)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

WAProto/WAProto.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 package proto;
 
-/// WhatsApp Version: 2.3000.1034302344
+/// WhatsApp Version: 2.3000.1034238531
 
 message ADVDeviceIdentity {
     optional uint32 rawId = 1;

src/Defaults/baileys-version.json

@@ -1 +1 @@
-{"version":[2,3000,1034382497]}
+{"version":[2,3000,1034258243]}

src/Defaults/index.ts

@@ -56,33 +56,10 @@ export const PROCESSABLE_HISTORY_TYPES = [
 // 6 hours in milliseconds
 const SIX_HOURS_MS = 6 * 60 * 60 * 1000
 
-/**
- * Resolves the default browser tuple from the BAILEYS_BROWSER env var.
- * Default: Android companion (SMB_ANDROID) — matches upstream PR #2201.
- * Pair code auto-detects Android and falls back to Chrome in socket.ts.
- *
- *   unset / 'android'    → Browsers.android('14')
- *   'android:15'         → Browsers.android('15')
- *   'chrome' / 'macos'   → Browsers.macOS('Chrome')
- */
-const resolveDefaultBrowser = (): [string, string, string] => {
-	const env = process.env.BAILEYS_BROWSER?.trim().toLowerCase()
-	if (env === 'chrome' || env === 'macos') {
-		return Browsers.macOS('Chrome')
-	}
-
-	if (env?.startsWith('android:')) {
-		const apiLevel = env.split(':')[1] || '14'
-		return Browsers.android(apiLevel)
-	}
-
-	return Browsers.android('14')
-}
-
 export const DEFAULT_CONNECTION_CONFIG: SocketConfig = {
 	version: version as WAVersion,
 	versionCheckIntervalMs: SIX_HOURS_MS,
-	browser: resolveDefaultBrowser(),
+	browser: Browsers.macOS('Chrome'),
 	waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
 	connectTimeoutMs: 20_000,
 	keepAliveIntervalMs: 15_000,

src/Signal/libsignal.ts

@@ -302,25 +302,6 @@ export function makeLibSignalRepository(
 	// Promise instead of each spawning their own DB transactions.
 	const migrationInFlight = new Map<string, Promise<{ migrated: number; skipped: number; total: number }>>()
 
-	// Resolve PN JID to its canonical LID JID for transaction locking.
-	// This prevents PN/LID race conditions where concurrent operations for the
-	// same logical contact acquire different mutex locks because one uses PN
-	// and the other uses LID. (Aligned with WABA behavior — all operations use LID internally.)
-	const resolveCanonicalJid = async(jid: string): Promise<string> => {
-		if (isAnyLidUser(jid)) {
-			return jid
-		}
-
-		if (isAnyPnUser(jid)) {
-			const lid = await lidMapping.getLIDForPN(jid)
-			if (lid) {
-				return lid
-			}
-		}
-
-		return jid
-	}
-
 	const repository: SignalRepositoryWithLIDStore = {
 		decryptGroupMessage({ group, authorJid, msg }) {
 			const senderName = jidToSignalSenderKeyName(group, authorJid)
@@ -415,24 +396,23 @@ export function makeLibSignalRepository(
 				return result
 			}
 
-			// Use canonical JID (PN→LID resolved) as transaction key to prevent
-			// PN/LID race conditions on the same logical session.
-			const canonicalJid = await resolveCanonicalJid(jid)
+			// If it's not a sync message, we need to ensure atomicity
+			// For regular messages, we use a transaction to ensure atomicity
 			return parsedKeys.transaction(async () => {
 				return await doDecrypt()
-			}, canonicalJid)
+			}, jid)
 		},
 
 		async encryptMessage({ jid, data }) {
 			const addr = jidToSignalProtocolAddress(jid)
 			const cipher = new libsignal.SessionCipher(storage, addr)
 
-			const canonicalJid = await resolveCanonicalJid(jid)
+			// Use transaction to ensure atomicity
 			return parsedKeys.transaction(async () => {
 				const { type: sigType, body } = await cipher.encrypt(data)
 				const type = sigType === 3 ? 'pkmsg' : 'msg'
 				return { type, ciphertext: Buffer.from(body, 'binary') }
-			}, canonicalJid)
+			}, jid)
 		},
 
 		async encryptGroupMessage({ group, meId, data }) {
@@ -674,10 +654,9 @@ export function makeLibSignalRepository(
 								// Session exists (guaranteed from device discovery)
 								const fromSession = libsignal.SessionRecord.deserialize(pnSession)
 								if (fromSession.haveOpenSession()) {
-									// Queue for bulk update: copy to LID, retain PN session.
-									// WABA retains both PN and LID sessions during migration to avoid
-									// No Session errors if messages arrive via PN before migration completes.
+									// Queue for bulk update: copy to LID, delete from PN
 									sessionUpdates[lidAddrStr] = fromSession.serialize()
+									sessionUpdates[pnAddrStr] = null
 
 									migratedCount++
 								}
@@ -797,13 +776,6 @@ function signalStorage(
 		return id
 	}
 
-	// Delayed PreKey deletion: grace period to handle race conditions
-	// where two pkmsg with the same preKeyId arrive nearly simultaneously.
-	// WABA deletes immediately (33ms), but we add a 5-min grace period
-	// because we can't handle "Invalid PreKey ID" errors at the native level.
-	const PREKEY_GRACE_PERIOD_MS = 5 * 60 * 1000 // 5 minutes
-	const pendingPreKeyDeletions = new Map<string, ReturnType<typeof setTimeout>>()
-
 	return {
 		loadSession: async (id: string) => {
 			try {
@@ -836,26 +808,7 @@ function signalStorage(
 				}
 			}
 		},
-		removePreKey: (id: number) => {
-			const keyId = id.toString()
-			// Clear any existing timer for this key
-			const existing = pendingPreKeyDeletions.get(keyId)
-			if (existing) {
-				clearTimeout(existing)
-			}
-
-			// Schedule deletion after grace period
-			const timer = setTimeout(async () => {
-				pendingPreKeyDeletions.delete(keyId)
-				try {
-					await keys.set({ 'pre-key': { [id]: null } })
-				} catch {
-					// Keystore may be destroyed if connection closed — safe to ignore
-				}
-			}, PREKEY_GRACE_PERIOD_MS)
-
-			pendingPreKeyDeletions.set(keyId, timer)
-		},
+		removePreKey: (id: number) => keys.set({ 'pre-key': { [id]: null } }),
 		loadSignedPreKey: () => {
 			const key = creds.signedPreKey
 			return {
@@ -945,24 +898,14 @@ function signalStorage(
 					// IDENTITY KEY CHANGED - contact reinstalled WhatsApp or switched devices
 					const previousFingerprint = generateKeyFingerprint(existingKey)
 
-					// Delete old session and save new identity key atomically.
-					// Store identity in BOTH LID and PN addresses (WABA stores in both
-					// recipient_account_type=0 and type=1 with CONFLICT_REPLACE).
-					const identityUpdates: Record<string, Uint8Array> = { [wireJid]: identityKey }
-					if (wireJid !== id) {
-						identityUpdates[id] = identityKey
-					}
-
+					// Delete old session and save new identity key atomically
 					await keys.set({
 						session: { [wireJid]: null },
-						'identity-key': identityUpdates
+						'identity-key': { [wireJid]: identityKey }
 					})
 
-					// Update cache for both addresses
+					// Update cache
 					identityKeyCache.set(wireJid, identityKey)
-					if (wireJid !== id) {
-						identityKeyCache.set(id, identityKey)
-					}
 
 					// Record metrics
 					metrics.signalIdentityChanges?.inc({ type: 'changed' })
@@ -998,19 +941,10 @@ function signalStorage(
 
 				if (!existingKey) {
 					// NEW CONTACT - Trust On First Use (TOFU)
-					// Store in both LID and PN addresses (aligned with WABA dual identity storage)
-					const identityUpdates: Record<string, Uint8Array> = { [wireJid]: identityKey }
-					if (wireJid !== id) {
-						identityUpdates[id] = identityKey
-					}
+					await keys.set({ 'identity-key': { [wireJid]: identityKey } })
 
-					await keys.set({ 'identity-key': identityUpdates })
-
-					// Update cache for both addresses
+					// Update cache
 					identityKeyCache.set(wireJid, identityKey)
-					if (wireJid !== id) {
-						identityKeyCache.set(id, identityKey)
-					}
 
 					// Record metrics
 					metrics.signalIdentityChanges?.inc({ type: 'new' })

src/Socket/chats.ts

@@ -50,8 +50,7 @@ import {
 	isMissingKeyError,
 	MAX_SYNC_ATTEMPTS,
 	newLTHashState,
-	processSyncAction,
-	resolveLidToPn
+	processSyncAction
 } from '../Utils'
 import { makeKeyedMutex, makeMutex } from '../Utils/make-mutex'
 import processMessage from '../Utils/process-message'
@@ -758,16 +757,9 @@ export const makeChatsSocket = (config: SocketConfig) => {
 			}, authState?.creds?.me?.id || 'resync-app-state')
 
 			const { onMutation } = newAppStateChunkHandler(isInitialSync)
-			const lidMapping = signalRepository.lidMapping
 			for (const key in globalMutationMap) {
 				const mutation = globalMutationMap[key]
 				if (!mutation) continue
-				// Normalize LID→PN in sync action index[1] (chat/contact ID)
-				if (mutation.index[1] && isAnyLidUser(mutation.index[1])) {
-					const resolved = await resolveLidToPn(mutation.index[1], lidMapping, logger)
-					if (resolved) mutation.index[1] = resolved
-				}
-
 				onMutation(mutation)
 			}
 		}
@@ -920,16 +912,16 @@ export const makeChatsSocket = (config: SocketConfig) => {
 		})
 	}
 
-	const handlePresenceUpdate = async ({ tag, attrs, content }: BinaryNode) => {
+	const handlePresenceUpdate = ({ tag, attrs, content }: BinaryNode) => {
 		let presence: PresenceData | undefined
-		const rawJid = attrs.from
-		const rawParticipant = attrs.participant || attrs.from
-		if (!rawJid) {
+		const jid = attrs.from
+		const participant = attrs.participant || attrs.from
+		if (!jid) {
 			logger.warn({ attrs }, 'handlePresenceUpdate: jid (attrs.from) is missing, skipping')
 			return
 		}
 
-		if (shouldIgnoreJid(rawJid) && rawJid !== S_WHATSAPP_NET) {
+		if (shouldIgnoreJid(jid) && jid !== S_WHATSAPP_NET) {
 			return
 		}
 
@@ -941,7 +933,7 @@ export const makeChatsSocket = (config: SocketConfig) => {
 		} else if (Array.isArray(content)) {
 			const [firstChild] = content
 			if (!firstChild) {
-				logger.warn({ jid: rawJid }, 'handlePresenceUpdate: firstChild content is empty, skipping')
+				logger.warn({ jid }, 'handlePresenceUpdate: firstChild content is empty, skipping')
 				return
 			}
 
@@ -960,19 +952,12 @@ export const makeChatsSocket = (config: SocketConfig) => {
 		}
 
 		if (presence) {
-			if (!rawParticipant) {
-				logger.warn({ jid: rawJid }, 'handlePresenceUpdate: participant is missing, skipping')
+			if (!participant) {
+				logger.warn({ jid }, 'handlePresenceUpdate: participant is missing, skipping')
 				return
 			}
 
-			// Resolve LID→PN so consumers always see phone-number JIDs
-			const lidMapping = signalRepository.lidMapping
-			const [jid, participant] = await Promise.all([
-				resolveLidToPn(rawJid, lidMapping, logger),
-				resolveLidToPn(rawParticipant, lidMapping, logger)
-			])
-
-			ev.emit('presence.update', { id: jid!, presences: { [participant!]: presence } })
+			ev.emit('presence.update', { id: jid, presences: { [participant]: presence } })
 		}
 	}
 
@@ -1046,16 +1031,8 @@ export const makeChatsSocket = (config: SocketConfig) => {
 				undefined,
 				logger
 			)
-			const lidMapping = signalRepository.lidMapping
 			for (const key in mutationMap) {
-				const mutation = mutationMap[key]!
-				// Normalize LID→PN in sync action index[1] (chat/contact ID)
-				if (mutation.index[1] && isAnyLidUser(mutation.index[1])) {
-					const resolved = await resolveLidToPn(mutation.index[1], lidMapping, logger)
-					if (resolved) mutation.index[1] = resolved
-				}
-
-				onMutation(mutation)
+				onMutation(mutationMap[key]!)
 			}
 		}
 	}
@@ -1399,12 +1376,8 @@ export const makeChatsSocket = (config: SocketConfig) => {
 		}
 	})
 
-	ws.on('CB:presence', (node: BinaryNode) => {
-		handlePresenceUpdate(node).catch(err => onUnexpectedError(err, 'handling presence update'))
-	})
-	ws.on('CB:chatstate', (node: BinaryNode) => {
-		handlePresenceUpdate(node).catch(err => onUnexpectedError(err, 'handling chatstate update'))
-	})
+	ws.on('CB:presence', handlePresenceUpdate)
+	ws.on('CB:chatstate', handlePresenceUpdate)
 
 	ws.on('CB:ib,,dirty', async (node: BinaryNode) => {
 		const { attrs } = getBinaryNodeChild(node, 'dirty')!

src/Socket/groups.ts

@@ -1,7 +1,7 @@
 import { proto } from '../../WAProto/index.js'
 import type { GroupMetadata, GroupParticipant, ParticipantAction, SocketConfig, WAMessageKey } from '../Types'
 import { WAMessageAddressingMode, WAMessageStubType } from '../Types'
-import { generateMessageIDV2, resolveLidToPn, unixTimestampSeconds } from '../Utils'
+import { generateMessageIDV2, unixTimestampSeconds } from '../Utils'
 import {
 	type BinaryNode,
 	getBinaryNodeChild,
@@ -17,43 +17,6 @@ import { makeChatsSocket } from './chats'
 export const makeGroupsSocket = (config: SocketConfig) => {
 	const sock = makeChatsSocket(config)
 	const { authState, ev, query, upsertMessage } = sock
-	const { signalRepository } = sock
-	const { logger } = config
-
-	/** Normalize group metadata participant IDs from LID to PN */
-	const normalizeGroupMetadata = async (metadata: GroupMetadata): Promise<GroupMetadata> => {
-		const lidMapping = signalRepository.lidMapping
-
-		// Resolve all participant LIDs in parallel for better performance on large groups
-		await Promise.all(metadata.participants.map(async (p) => {
-			if (isLidUser(p.id)) {
-				if (p.phoneNumber) {
-					p.lid = p.id
-					p.id = p.phoneNumber
-				} else {
-					const resolved = await resolveLidToPn(p.id, lidMapping, logger)
-					if (resolved && resolved !== p.id) {
-						p.lid = p.id
-						p.id = resolved
-					}
-				}
-			}
-		}))
-
-		// Normalize owner/subjectOwner if LID (parallel)
-		const [resolvedOwner, resolvedSubjectOwner] = await Promise.all([
-			metadata.owner && isLidUser(metadata.owner)
-				? (metadata.ownerPn || resolveLidToPn(metadata.owner, lidMapping, logger))
-				: null,
-			metadata.subjectOwner && isLidUser(metadata.subjectOwner)
-				? (metadata.subjectOwnerPn || resolveLidToPn(metadata.subjectOwner, lidMapping, logger))
-				: null
-		])
-		if (resolvedOwner) metadata.owner = resolvedOwner
-		if (resolvedSubjectOwner) metadata.subjectOwner = resolvedSubjectOwner
-
-		return metadata
-	}
 
 	const groupQuery = async (jid: string, type: 'get' | 'set', content: BinaryNode[]) =>
 		query({
@@ -68,7 +31,7 @@ export const makeGroupsSocket = (config: SocketConfig) => {
 
 	const groupMetadata = async (jid: string) => {
 		const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }])
-		return normalizeGroupMetadata(extractGroupMetadata(result))
+		return extractGroupMetadata(result)
 	}
 
 	const groupFetchAllParticipating = async () => {
@@ -95,15 +58,16 @@ export const makeGroupsSocket = (config: SocketConfig) => {
 		if (groupsChild) {
 			const groups = getBinaryNodeChildren(groupsChild, 'group')
 			for (const groupNode of groups) {
-				const meta = await normalizeGroupMetadata(extractGroupMetadata({
+				const meta = extractGroupMetadata({
 					tag: 'result',
 					attrs: {},
 					content: [groupNode]
-				}))
+				})
 				data[meta.id] = meta
 			}
 		}
 
+		// TODO: properly parse LID / PN DATA
 		sock.ev.emit('groups.update', Object.values(data))
 
 		return data
@@ -137,7 +101,7 @@ export const makeGroupsSocket = (config: SocketConfig) => {
 					}))
 				}
 			])
-			return normalizeGroupMetadata(extractGroupMetadata(result))
+			return extractGroupMetadata(result)
 		},
 		groupLeave: async (id: string) => {
 			await groupQuery('@g.us', 'set', [
@@ -313,7 +277,7 @@ export const makeGroupsSocket = (config: SocketConfig) => {
 		),
 		groupGetInviteInfo: async (code: string) => {
 			const results = await groupQuery('@g.us', 'get', [{ tag: 'invite', attrs: { code } }])
-			return normalizeGroupMetadata(extractGroupMetadata(results))
+			return extractGroupMetadata(results)
 		},
 		groupToggleEphemeral: async (jid: string, ephemeralExpiration: number) => {
 			const content: BinaryNode = ephemeralExpiration

src/Socket/messages-send.ts

@@ -1611,8 +1611,6 @@ export const makeMessagesSocket = (config: SocketConfig) => {
 
 						// Persist senderTimestamp unconditionally — WA Web stores it in the chat table
 						// regardless of whether a token exists. Spread preserves token+timestamp if present.
-						// WABA Android: INSERT INTO wa_trusted_contacts_send (jid, sent_tc_token_timestamp, real_issue_timestamp)
-						// VALUES (?, ?, 0) — realIssueTimestamp=0 means issued but not yet confirmed by server
 						const currentData = await authState.keys.get('tctoken', [tcTokenJid])
 						const currentEntry = currentData[tcTokenJid]
 						await authState.keys.set({
@@ -1620,8 +1618,7 @@ export const makeMessagesSocket = (config: SocketConfig) => {
 								[tcTokenJid]: {
 									...currentEntry,
 									token: currentEntry?.token ?? Buffer.alloc(0),
-									senderTimestamp: issueTimestamp,
-									realIssueTimestamp: 0
+									senderTimestamp: issueTimestamp
 								}
 							}
 						})

src/Socket/socket.ts

@@ -38,7 +38,7 @@ import {
 	signedKeyPair,
 	xmppSignedPreKey
 } from '../Utils'
-import { getPlatformId, isAndroidBrowser } from '../Utils/browser-utils'
+import { getPlatformId } from '../Utils/browser-utils'
 import {
 	CircuitBreaker,
 	CircuitOpenError,
@@ -634,6 +634,8 @@ export const makeSocket = (config: SocketConfig) => {
 		}
 		helloMsg = proto.HandshakeMessage.fromObject(helloMsg)
 
+		logger.info({ browser, helloMsg }, 'connected to WA')
+
 		const init = proto.HandshakeMessage.encode(helloMsg).finish()
 
 		const result = await awaitNextMessage<Uint8Array>(init)
@@ -1350,25 +1352,6 @@ export const makeSocket = (config: SocketConfig) => {
 			id: jidEncode(phoneNumber, 's.whatsapp.net'),
 			name: '~'
 		}
-
-		// Pair code companion_platform_id must be Chrome (1) when using Android
-		// browser preset. ANDROID_PHONE (16) causes silent timeout (server ignores),
-		// UWP (21) causes "cannot connect device" rejection. Only Chrome (1) works
-		// for pair code via web protocol (WA\x06\x03). The device still appears as
-		// "Android" in linked devices because DeviceProps.platformType=ANDROID_PHONE
-		// is set separately in the registration node.
-		const isAndroid = isAndroidBrowser(browser)
-		const pairPlatformId = isAndroid ? getPlatformId('Chrome') : getPlatformId(browser[1])
-		const pairPlatformDisplay = isAndroid ? 'Chrome (Mac OS)' : `${browser[1]} (${browser[0]})`
-
-		logger.info({
-			pairCode: pairingCode,
-			jid: authState.creds.me.id,
-			companionPlatformId: pairPlatformId,
-			companionPlatformDisplay: pairPlatformDisplay,
-			isAndroid,
-		}, `pair code requested | companion: ${pairPlatformDisplay} | ${isAndroid ? 'android override -> Chrome' : 'native platform'}`)
-
 		ev.emit('creds.update', authState.creds)
 		await sendNode({
 			tag: 'iq',
@@ -1401,12 +1384,12 @@ export const makeSocket = (config: SocketConfig) => {
 						{
 							tag: 'companion_platform_id',
 							attrs: {},
-							content: pairPlatformId
+							content: getPlatformId(browser[1])
 						},
 						{
 							tag: 'companion_platform_display',
 							attrs: {},
-							content: pairPlatformDisplay
+							content: `${browser[1]} (${browser[0]})`
 						},
 						{
 							tag: 'link_code_pairing_nonce',
@@ -1536,9 +1519,7 @@ export const makeSocket = (config: SocketConfig) => {
 	})
 	// login complete
 	ws.on('CB:success', async (node: BinaryNode) => {
-		const isAndroid = isAndroidBrowser(browser)
-		const phoneId = authState.creds.me?.id?.split(':')[0]?.split('@')[0] || 'new session'
-		logger.info(`${isAndroid ? '\uD83D\uDCF1' : '\uD83D\uDDA5\uFE0F'} Connected to WA | ${phoneId} | platform: ${isAndroid ? 'SMB_ANDROID' : 'MACOS'} | device: ${isAndroid ? 'Android' : 'Desktop'} | platformType: ${isAndroid ? 'ANDROID_PHONE' : 'CHROME'}`)
+		logger.info('opened connection to WA')
 		clearTimeout(qrTimer) // will never happen in all likelyhood -- but just in case WA sends success on first try
 
 		ev.emit('creds.update', { me: { ...authState.creds.me!, lid: node.attrs.lid } })

src/Types/Auth.ts

@@ -80,7 +80,7 @@ export type SignalDataTypeMap = {
 	'app-state-sync-version': LTHashState
 	'lid-mapping': string
 	'device-list': string[]
-	tctoken: { token: Buffer; timestamp?: string; senderTimestamp?: number; realIssueTimestamp?: number | null }
+	tctoken: { token: Buffer; timestamp?: string; senderTimestamp?: number }
 	/** Identity key for Signal Protocol - used for detecting contact reinstalls */
 	'identity-key': Uint8Array
 }

src/Types/Call.ts

@@ -1,30 +1,4 @@
-export type WACallUpdateType =
-	| 'offer'
-	| 'ringing'
-	| 'timeout'
-	| 'reject'
-	| 'accept'
-	| 'terminate'
-	| 'preaccept'
-	| 'transport'
-	| 'relaylatency'
-	| 'group_update'
-	| 'reminder'
-	| 'heartbeat'
-	| 'mute_v2'
-	| 'enc_rekey'
-	| 'video'
-	| 'relay'
-
-export type WACallParticipant = {
-	jid?: string
-	/** 'connected' | 'invited' | 'left' etc. */
-	state?: string
-	/** Phone number in s.whatsapp.net format */
-	userPn?: string
-	/** 'admin' for group call link creator */
-	type?: string
-}
+export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept' | 'terminate'
 
 export type WACallEvent = {
 	chatId: string
@@ -39,20 +13,4 @@ export type WACallEvent = {
 	latencyMs?: number
 	/** Phone number of the caller (sanitized to fix Brazilian landline bug) */
 	callerPn?: string
-	/** Call link token (forms URL: https://call.whatsapp.com/video/<token>) */
-	linkToken?: string
-	/** JID of who created the call link */
-	linkCreator?: string
-	/** Phone number of link creator */
-	linkCreatorPn?: string
-	/** Media type: 'video' or 'audio' */
-	media?: string
-	/** Max participants for group/link calls */
-	connectedLimit?: number
-	/** Participants in a group/link call */
-	participants?: WACallParticipant[]
-	/** Call duration in ms (from terminate/call_summary) */
-	duration?: number
-	/** Terminate reason (e.g. 'group_call_ended', 'accepted_elsewhere', 'timeout') */
-	terminateReason?: string
 }

src/Types/index.ts

@@ -23,7 +23,6 @@ export type BrowsersMap = {
 	baileys(browser: string): [string, string, string]
 	windows(browser: string): [string, string, string]
 	appropriate(browser: string): [string, string, string]
-	android(apiLevel: string): [string, string, string]
 }
 
 export enum DisconnectReason {

src/Utils/browser-utils.ts

@@ -94,13 +94,7 @@ const BROWSER_TO_PLATFORM_ID: ReadonlyMap<string, string> = (() => {
 		}
 	}
 
-	const map = new Map(entries)
-	// ANDROID → ANDROID_PHONE alias (DeviceProps.PlatformType has ANDROID_PHONE but not ANDROID)
-	if (!map.has('ANDROID') && map.has('ANDROID_PHONE')) {
-		map.set('ANDROID', map.get('ANDROID_PHONE')!)
-	}
-
-	return map
+	return new Map(entries)
 })()
 
 // ============================================================
@@ -337,8 +331,7 @@ export const Browsers: BrowsersMap = {
 	macOS: (browser: string): [string, string, string] => ['Mac OS', browser, OS_VERSIONS.macOS],
 	windows: (browser: string): [string, string, string] => ['Windows', browser, OS_VERSIONS.windows],
 	baileys: (browser: string): [string, string, string] => ['Baileys', browser, OS_VERSIONS.baileys],
-	appropriate: (browser: string): [string, string, string] => [getPlatformName(), browser, getAppropriateVersion()],
-	android: (apiLevel: string): [string, string, string] => [apiLevel, 'Android', '']
+	appropriate: (browser: string): [string, string, string] => [getPlatformName(), browser, getAppropriateVersion()]
 } as const
 
 /**
@@ -385,7 +378,7 @@ export const getPlatformId = (browser: unknown): string => {
  * properties like 'toString' or 'constructor'.
  *
  * @param value - Value to check
- * @returns True if value is a valid browser preset key ('ubuntu', 'macOS', 'windows', 'baileys', 'appropriate', 'android')
+ * @returns True if value is a valid browser preset key ('ubuntu', 'macOS', 'windows', 'baileys', 'appropriate')
  *
  * @example
  * isValidBrowserPreset('ubuntu')      // true
@@ -398,16 +391,6 @@ export const getPlatformId = (browser: unknown): string => {
  *   const config = Browsers[userInput]('MyApp')
  * }
  */
-/**
- * Checks if the browser tuple represents an Android companion device.
- *
- * @param browser - Browser tuple [os, platform, version]
- * @returns True if platform is 'Android' (case-insensitive)
- */
-export const isAndroidBrowser = (browser: [string, string, string]): boolean => {
-	return browser[1]?.toUpperCase() === 'ANDROID'
-}
-
 export const isValidBrowserPreset = (value: unknown): value is keyof BrowsersMap => {
 	return typeof value === 'string' && Object.prototype.hasOwnProperty.call(Browsers, value)
 }

src/Utils/decode-wa-message.ts

@@ -14,6 +14,7 @@ import {
 	isJidStatusBroadcast,
 	isLidUser,
 	isPnUser,
+	jidDecode
 	//	transferDevice
 } from '../WABinary'
 import { unpadRandomMax16 } from './generics'
@@ -275,6 +276,7 @@ export const decryptMessageNode = (
 	meLid: string,
 	repository: SignalRepositoryWithLIDStore,
 	logger: ILogger,
+	autoCleanCorrupted = true
 ) => {
 	const { fullMessage, author, sender } = decodeMessageNode(stanza, meId, meLid)
 	return {
@@ -420,19 +422,34 @@ export const decryptMessageNode = (
 							if (isRetryExhausted) {
 								logger.error(
 									errorContext,
-									`⚠️ Session corrupted after ${err.attempts} attempts. Retry+pkmsg flow will recover.`
+									`⚠️ Session corrupted and recovery failed after ${err.attempts} attempts. Auto-cleanup will attempt to recover.`
 								)
 							} else {
 								// First occurrence - log as warning since auto-recovery will attempt
 								logger.warn(errorContext, '⚠️ Corrupted session detected - attempting auto-recovery')
 							}
 
-							// Session cleanup is deferred to retry exhaustion (safety net).
-							// The Signal Protocol handles recovery naturally via retry+pkmsg:
-							// Bad MAC -> retry receipt -> sender re-sends as pkmsg -> new session.
-							// Deleting sessions here (hot path) causes cascading failures when
-							// multiple messages from the same contact arrive simultaneously.
-							// See: messages-recv.ts sendRetryRequest() for deferred cleanup.
+							// Automatic cleanup of corrupted session (if enabled)
+							// eslint-disable-next-line max-depth
+							if (autoCleanCorrupted) {
+								// eslint-disable-next-line max-depth
+								try {
+									const deletedCount = await cleanupCorruptedSession(decryptionJid, repository, logger)
+
+									// Mask only user portion of JID for privacy (preserve domain info)
+									const { user, server } = jidDecode(decryptionJid) || {}
+									const maskedUser =
+										user && user.length > 8 ? `${user.substring(0, 4)}****${user.substring(user.length - 4)}` : user
+									const maskedJid = maskedUser && server ? `${maskedUser}@${server}` : decryptionJid
+
+									logger.info(
+										{ jid: decryptionJid, maskedJid, targetedDevices: deletedCount },
+										`🔄 Session Reset | JID: ${maskedJid} | Targeted: ${deletedCount} devices | Will recreate on next message`
+									)
+								} catch (cleanupErr) {
+									logger.error({ decryptionJid, err: cleanupErr }, '❌ Failed to cleanup corrupted session')
+								}
+							}
 						} else if (isSessionRecord) {
 							// Session record errors are transient - retry should handle them
 							// eslint-disable-next-line max-depth
@@ -487,20 +504,53 @@ export function isCorruptedSessionError(error: any): boolean {
 }
 
 /**
- * Clean up corrupted session for a specific device JID.
- * WABA behavior: DELETE sessions WHERE recipient_id=? AND device_id=?
- * Only deletes the exact device that was corrupted, not all devices.
- *
- * NOTE: This should NOT be called on every Bad MAC error (hot path).
- * Instead, let the retry+pkmsg flow handle recovery naturally (like WhatsApp does).
- * Only call this as a safety net when retries are exhausted.
+ * Clean up corrupted session by deleting all device sessions for a JID
+ * Signal Protocol will automatically recreate the session on next message
  */
-export async function cleanupCorruptedSession(
+async function cleanupCorruptedSession(
 	jid: string,
 	repository: SignalRepositoryWithLIDStore,
 	logger: ILogger
 ): Promise<number> {
-	await repository.deleteSession([jid])
-	logger.info({ jid }, 'Cleaned up corrupted session for specific device')
-	return 1
+	const { user, device } = jidDecode(jid) || {}
+	if (!user) {
+		logger.warn({ jid }, 'Cannot cleanup session - invalid JID')
+		return 0
+	}
+
+	// Build list of JIDs to delete (primary + secondary devices)
+	const jidsToDelete: string[] = []
+
+	// Determine domain type correctly (handle hosted JIDs)
+	// JID formats:
+	//   - PN: user@s.whatsapp.net
+	//   - LID: user@lid
+	//   - Hosted PN: user@hosted
+	//   - Hosted LID: user@hosted.lid
+	const isLID = jid.endsWith('@lid') || jid.endsWith('@hosted.lid')
+	const isHosted = jid.includes('@hosted')
+
+	let domain: string
+	if (isLID) {
+		domain = isHosted ? 'hosted.lid' : 'lid'
+	} else {
+		domain = isHosted ? 'hosted' : 's.whatsapp.net'
+	}
+
+	// Primary device (0)
+	jidsToDelete.push(`${user}@${domain}`)
+
+	// Secondary devices (1-5 common range for Web/Desktop/etc)
+	for (let i = 1; i <= 5; i++) {
+		jidsToDelete.push(`${user}:${i}@${domain}`)
+	}
+
+	// If specific device was identified and > 5, ensure it's included
+	if (device !== undefined && device > 5) {
+		jidsToDelete.push(`${user}:${device}@${domain}`)
+	}
+
+	await repository.deleteSession(jidsToDelete)
+
+	return jidsToDelete.length
 }

src/Utils/generics.ts

@@ -230,22 +230,14 @@ export const bindWaitForConnectionUpdate = (ev: BaileysEventEmitter) => bindWait
  * utility that fetches latest baileys version from the master branch.
  * Use to ensure your WA connection is always on the latest version
  */
-export const fetchLatestBaileysVersion = async (options: RequestInit & { timeout?: number } = {}) => {
+export const fetchLatestBaileysVersion = async (options: RequestInit = {}) => {
 	const URL = 'https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/index.ts'
 	try {
-		const controller = new AbortController()
-		const timeout = setTimeout(() => controller.abort(), options.timeout ?? 5000)
-		let response: Response
-		try {
-			response = await fetch(URL, {
-				dispatcher: options.dispatcher,
-				method: 'GET',
-				headers: options.headers,
-				signal: controller.signal
-			})
-		} finally {
-			clearTimeout(timeout)
-		}
+		const response = await fetch(URL, {
+			dispatcher: options.dispatcher,
+			method: 'GET',
+			headers: options.headers
+		})
 		if (!response.ok) {
 			throw new Boom(`Failed to fetch latest Baileys version: ${response.statusText}`, { statusCode: response.status })
 		}
@@ -429,36 +421,6 @@ export const getCallStatusFromNode = ({ tag, attrs }: BinaryNode) => {
 		case 'accept':
 			status = 'accept'
 			break
-		case 'preaccept':
-			status = 'preaccept'
-			break
-		case 'transport':
-			status = 'transport'
-			break
-		case 'relaylatency':
-			status = 'relaylatency'
-			break
-		case 'group_update':
-			status = 'group_update'
-			break
-		case 'reminder':
-			status = 'reminder'
-			break
-		case 'heartbeat':
-			status = 'heartbeat'
-			break
-		case 'mute_v2':
-			status = 'mute_v2'
-			break
-		case 'enc_rekey':
-			status = 'enc_rekey'
-			break
-		case 'video':
-			status = 'video'
-			break
-		case 'relay':
-			status = 'relay'
-			break
 		default:
 			status = 'ringing'
 			break

src/Utils/message-retry-manager.ts

@@ -211,33 +211,15 @@ export class MessageRetryManager {
 			}
 		}
 
-		// MAC errors require session recreation, but rate-limited to prevent loops.
-		// When multiple messages fail with Bad MAC simultaneously, only the first
-		// should trigger recreation; subsequent ones within the cooldown window
-		// piggyback on the same new session established by the retry+pkmsg flow.
+		// MAC errors require IMMEDIATE session recreation regardless of history
+		// This handles the case where contact reinstalled WhatsApp (identity key changed)
 		if (errorCode !== undefined && MAC_ERROR_CODES.has(errorCode)) {
-			const now = Date.now()
-			const prevTime = this.sessionRecreateHistory.get(jid)
-			const MAC_ERROR_COOLDOWN_MS = 1_000 // 1 second — WABA recovers faster
-
-			if (prevTime && now - prevTime < MAC_ERROR_COOLDOWN_MS) {
-				const reasonName = RetryReason[errorCode] || `code_${errorCode}`
-				this.logger.debug(
-					{ jid, errorCode: reasonName, msSinceLast: now - prevTime },
-					'MAC error session recreation skipped — cooldown active'
-				)
-				return {
-					reason: '',
-					recreate: false
-				}
-			}
-
-			this.sessionRecreateHistory.set(jid, now)
+			this.sessionRecreateHistory.set(jid, Date.now())
 			this.statistics.sessionRecreations++
 			const reasonName = RetryReason[errorCode] || `code_${errorCode}`
 			metrics.signalMacErrors?.inc({ action: 'session_recreation' })
 			metrics.signalSessionRecreations?.inc({ reason: 'mac_error' })
-			this.logger.warn({ jid, errorCode: reasonName }, 'MAC error detected, recreating session')
+			this.logger.warn({ jid, errorCode: reasonName }, 'MAC error detected, forcing immediate session recreation')
 			return {
 				reason: `MAC error (${reasonName}) - contact may have reinstalled WhatsApp`,
 				recreate: true

src/Utils/process-message.ts

@@ -19,13 +19,10 @@ import type {
 	WAMessage,
 	WAMessageKey
 } from '../Types'
-import type { LIDMappingStore } from '../Signal/lid-mapping'
 import { WAMessageStubType } from '../Types'
 import { getContentType, normalizeMessageContent } from '../Utils/messages'
 import {
 	areJidsSameUser,
-	isAnyLidUser,
-	isAnyPnUser,
 	isHostedLidUser,
 	isHostedPnUser,
 	isJidBroadcast,
@@ -116,106 +113,46 @@ export const cleanMessage = (message: WAMessage, meId: string, meLid: string) =>
 			msgKey.remoteJid = message.key.remoteJid
 			// set participant of the message
 			msgKey.participant = msgKey.participant || message.key.participant
-		} else {
-			// fromMe reactions/polls: normalise remoteJid to match the chat JID
-			// ensures DM reaction keys are consistent with group behavior
-			msgKey.remoteJid = message.key.remoteJid
-			// in groups, normalise participant for own messages too
-			if (message.key.participant) {
-				msgKey.participant = msgKey.participant || message.key.participant
-			}
 		}
 	}
 }
 
-/**
- * Resolves a LID JID to its PN equivalent using the LID mapping store.
- * Returns the original JID if it's not a LID or if no mapping is found.
- * Safe to call with any JID type (group, newsletter, PN, etc.).
- */
-export const resolveLidToPn = async (
-	jid: string | undefined | null,
-	lidMapping: LIDMappingStore,
-	logger?: ILogger
-): Promise<string | undefined> => {
-	if (!jid) {
-		return undefined
-	}
-
-	if (isAnyLidUser(jid)) {
-		const pn = await lidMapping.getPNForLID(jid)
-		if (pn) {
-			logger?.debug({ lid: jid, pn }, 'Resolved LID to PN')
-		}
-
-		return pn || jid
-	}
-
-	return jid
-}
-
-/**
- * Normalizes a WAMessageKey by resolving LID→PN for remoteJid and participant.
- */
-export const normalizeKeyLidToPn = async (
-	key: WAMessageKey,
-	lidMapping: LIDMappingStore,
-	logger?: ILogger
-): Promise<void> => {
-	const [resolvedRemoteJid, resolvedParticipant] = await Promise.all([
-		resolveLidToPn(key.remoteJid, lidMapping, logger),
-		resolveLidToPn(key.participant, lidMapping, logger)
-	])
-	if (resolvedRemoteJid) {
-		key.remoteJid = resolvedRemoteJid
-	}
-
-	if (resolvedParticipant) {
-		key.participant = resolvedParticipant
-	}
-}
-
 export const normalizeMessageJids = async (
 	message: WAMessage,
 	signalRepository: SignalRepositoryWithLIDStore,
 	logger?: ILogger
 ): Promise<void> => {
-	const lidMapping = signalRepository.lidMapping
-	const key = message.key
-
-	// FAST PATH: Use alt JIDs directly when available (avoids LIDMappingStore race condition).
-	// The stanza always carries both formats (LID + PN) in the attributes.
-	// When addressing_mode=lid, remoteJid is LID and remoteJidAlt is PN.
-	// When addressing_mode=pn, remoteJid is already PN (no conversion needed).
-	if (key.remoteJid && isAnyLidUser(key.remoteJid) && key.remoteJidAlt && isAnyPnUser(key.remoteJidAlt)) {
-		logger?.debug({ lid: key.remoteJid, pn: key.remoteJidAlt }, 'Resolved remoteJid LID→PN via alt (fast path)')
-		key.remoteJid = key.remoteJidAlt
-	}
-
-	if (key.participant && isAnyLidUser(key.participant) && key.participantAlt && isAnyPnUser(key.participantAlt)) {
-		logger?.debug({ lid: key.participant, pn: key.participantAlt }, 'Resolved participant LID→PN via alt (fast path)')
-		key.participant = key.participantAlt
-	}
-
-	// SLOW PATH: Resolve any remaining LIDs via LIDMappingStore lookup
-	await normalizeKeyLidToPn(key, lidMapping, logger)
-
-	// Also normalize participantAlt (the alternative JID format — can be LID when addressing_mode=pn)
-	if (key.participantAlt && isAnyLidUser(key.participantAlt)) {
-		const resolved = await resolveLidToPn(key.participantAlt, lidMapping, logger)
-		if (resolved) {
-			key.participantAlt = resolved
+	const resolveLidToPn = async (jid: string | undefined | null): Promise<string | undefined> => {
+		if (!jid) {
+			return undefined
 		}
+
+		if (isLidUser(jid) || isHostedLidUser(jid)) {
+			const pn = await signalRepository.lidMapping.getPNForLID(jid)
+			if (pn) {
+				logger?.debug({ lid: jid, pn }, 'Resolved LID to PN for inbound message')
+			} else {
+				logger?.debug({ lid: jid }, 'PN not found for inbound LID, keeping LID')
+			}
+
+			return pn || jid
+		}
+
+		return jid
 	}
 
-	// Normalize nested message keys (reaction, poll) that may contain LID JIDs
-	const content = normalizeMessageContent(message.message)
-	if (content?.reactionMessage?.key) {
-		await normalizeKeyLidToPn(content.reactionMessage.key, lidMapping, logger)
+	// Execute both lookups in parallel instead of sequentially to reduce latency
+	const [resolvedRemoteJid, resolvedParticipant] = await Promise.all([
+		resolveLidToPn(message.key.remoteJid),
+		resolveLidToPn(message.key.participant)
+	])
+
+	if (resolvedRemoteJid) {
+		message.key.remoteJid = resolvedRemoteJid
 	}
 
-	if (content?.pollUpdateMessage?.pollCreationMessageKey) {
-		await normalizeKeyLidToPn(content.pollUpdateMessage.pollCreationMessageKey, lidMapping, logger)
+	if (resolvedParticipant) {
+		message.key.participant = resolvedParticipant
 	}
 }
 
@@ -589,12 +526,6 @@ const processMessage = async (
 								'CTWA: Successfully recovered message via placeholder resend'
 							)
 
-							// Normalize LID→PN in PDO-recovered message key before emitting
-							// eslint-disable-next-line max-depth
-							if (webMessageInfo.key && signalRepository) {
-								await normalizeKeyLidToPn(webMessageInfo.key as WAMessageKey, signalRepository.lidMapping, logger)
-							}
-
 							// wait till another upsert event is available, don't want it to be part of the PDO response message
 							// TODO: parse through proper message handling utilities (to add relevant key fields)
 							ev.emit('messages.upsert', {
@@ -735,13 +666,9 @@ const processMessage = async (
 						response: responseMsg
 					}
 
-					// Normalize creationMsgKey JIDs for the emitted event
-					const normalizedCreationKey = { ...creationMsgKey }
-					await normalizeKeyLidToPn(normalizedCreationKey, signalRepository.lidMapping, logger)
-
 					ev.emit('messages.update', [
 						{
-							key: normalizedCreationKey,
+							key: creationMsgKey,
 							update: {
 								eventResponses: [eventResponse]
 							}
@@ -784,7 +711,7 @@ const processMessage = async (
 			})
 		}
 
-		const participantsIncludesMe = () => participants.find(p => areJidsSameUser(meId, p.id) || areJidsSameUser(meId, p.phoneNumber))
+		const participantsIncludesMe = () => participants.find(jid => areJidsSameUser(meId, jid.phoneNumber)) // ADD SUPPORT FOR LID
 
 		switch (message.messageStubType) {
 			case WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER:

src/Utils/tc-token-utils.ts

@@ -159,10 +159,7 @@ export async function storeTcTokensFromIqResult({
 				[storageJid]: {
 					...existingEntry,
 					token: Buffer.from(tokenNode.content),
-					timestamp: tokenNode.attrs.t,
-					// WABA Android: resets real_issue_timestamp to null when storing a new token
-					// (UPDATE wa_trusted_contacts_send SET real_issue_timestamp=null)
-					realIssueTimestamp: null
+					timestamp: tokenNode.attrs.t
 				}
 			}
 		})

src/Utils/validate-connection.ts

@@ -14,24 +14,19 @@ import { encodeBigEndian } from './generics'
 import { createSignalIdentity } from './signal'
 
 const getUserAgent = (config: SocketConfig): proto.ClientPayload.IUserAgent => {
-	// Always use MACOS/Desktop identity for UserAgent — we connect via web
-	// protocol (WA\x06\x03) so the server expects a web-like UserAgent.
-	// Using SMB_ANDROID here causes pair code registration to fail with
-	// "não é possível conectar" even though the phone shows the confirmation.
-	// Android identity is only set in DeviceProps (registration node) which
-	// determines the display name in "Linked Devices".
 	return {
 		appVersion: {
 			primary: config.version[0],
 			secondary: config.version[1],
 			tertiary: config.version[2]
 		},
-		platform: proto.ClientPayload.UserAgent.Platform.MACOS,
+		platform: proto.ClientPayload.UserAgent.Platform.WEB,
 		releaseChannel: proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
 		osVersion: '0.1',
 		device: 'Desktop',
 		osBuildNumber: '0.1',
 		localeLanguageIso6391: 'en',
+
 		mnc: '000',
 		mcc: '000',
 		localeCountryIso31661Alpha2: config.countryCode
@@ -60,10 +55,11 @@ const getClientPayload = (config: SocketConfig) => {
 	const payload: proto.IClientPayload = {
 		connectType: proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
 		connectReason: proto.ClientPayload.ConnectReason.USER_ACTIVATED,
-		userAgent: getUserAgent(config),
-		webInfo: getWebInfo(config)
+		userAgent: getUserAgent(config)
 	}
 
+	payload.webInfo = getWebInfo(config)
+
 	return payload
 }
 
@@ -88,10 +84,6 @@ export const generateLoginNode = (userJid: string, config: SocketConfig): proto.
 
 const getPlatformType = (platform: string): proto.DeviceProps.PlatformType => {
 	const platformType = platform.toUpperCase()
-	if (platformType === 'ANDROID') {
-		return proto.DeviceProps.PlatformType.ANDROID_PHONE
-	}
-
 	return (
 		proto.DeviceProps.PlatformType[platformType as keyof typeof proto.DeviceProps.PlatformType] ||
 		proto.DeviceProps.PlatformType.CHROME