fix: replace magic numbers with RetryReason enum constants

Address remaining Copilot review comments on PR #306:

- Import RetryReason enum from Utils (already re-exported via Utils/index.ts)
- Replace all numeric literals (0/1/2/3/4/7) in retryErrorCode with the
  corresponding enum members (UnknownError / SignalErrorNoSession / etc.)
- Removes inline comments that were only needed to explain magic numbers
- If RetryReason values ever change, the compiler will surface the drift

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

WAProto/WAProto.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 package proto;
 
-/// WhatsApp Version: 2.3000.1035302375
+/// WhatsApp Version: 2.3000.1035484955
 
 message ADVDeviceIdentity {
     optional uint32 rawId = 1;
@@ -417,6 +417,7 @@ message BotCapabilityMetadata {
         JSON_PATCH_STREAMING = 58;
         AI_TAB_FORCE_CLIPPY = 59;
         UNIFIED_RESPONSE_EMBEDDED_SCREENS = 60;
+        AI_SUBSCRIPTION_ENABLED = 61;
     }
 }
 
@@ -1933,8 +1934,20 @@ message HandshakeMessage {
         optional bytes paddedBytes = 6;
         optional bool sendServerHelloPaddedBytes = 7;
         optional bool simulateXxkemFs = 8;
+        optional HandshakeMessage.HandshakePqMode pqMode = 9;
     }
     
+    enum HandshakePqMode {
+        HANDSHAKE_PQ_MODE_UNKNOWN = 0;
+        XXKEM = 1;
+        XXKEM_FS = 2;
+        WA_CLASSICAL = 3;
+        WA_PQ = 4;
+        IKKEM = 5;
+        IKKEM_FS = 6;
+        XXKEM_2 = 7;
+        IKKEM_2 = 8;
+    }
     message ServerHello {
         optional bytes ephemeral = 1;
         optional bytes static = 2;

WAProto/index.d.ts

@@ -1092,7 +1092,8 @@ export namespace proto {
             RICH_RESPONSE_UR_IMAGINE_VIDEO = 57,
             JSON_PATCH_STREAMING = 58,
             AI_TAB_FORCE_CLIPPY = 59,
-            UNIFIED_RESPONSE_EMBEDDED_SCREENS = 60
+            UNIFIED_RESPONSE_EMBEDDED_SCREENS = 60,
+            AI_SUBSCRIPTION_ENABLED = 61
         }
     }
 
@@ -4759,6 +4760,7 @@ export namespace proto {
             paddedBytes?: (Uint8Array|null);
             sendServerHelloPaddedBytes?: (boolean|null);
             simulateXxkemFs?: (boolean|null);
+            pqMode?: (proto.HandshakeMessage.HandshakePqMode|null);
         }
 
         class ClientHello implements IClientHello {
@@ -4771,6 +4773,7 @@ export namespace proto {
             public paddedBytes?: (Uint8Array|null);
             public sendServerHelloPaddedBytes?: (boolean|null);
             public simulateXxkemFs?: (boolean|null);
+            public pqMode?: (proto.HandshakeMessage.HandshakePqMode|null);
             public static create(properties?: proto.HandshakeMessage.IClientHello): proto.HandshakeMessage.ClientHello;
             public static encode(m: proto.HandshakeMessage.IClientHello, w?: $protobuf.Writer): $protobuf.Writer;
             public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): proto.HandshakeMessage.ClientHello;
@@ -4780,6 +4783,18 @@ export namespace proto {
             public static getTypeUrl(typeUrlPrefix?: string): string;
         }
 
+        enum HandshakePqMode {
+            HANDSHAKE_PQ_MODE_UNKNOWN = 0,
+            XXKEM = 1,
+            XXKEM_FS = 2,
+            WA_CLASSICAL = 3,
+            WA_PQ = 4,
+            IKKEM = 5,
+            IKKEM_FS = 6,
+            XXKEM_2 = 7,
+            IKKEM_2 = 8
+        }
+
         interface IServerHello {
             ephemeral?: (Uint8Array|null);
             "static"?: (Uint8Array|null);

WAProto/index.js

@@ -6897,6 +6897,10 @@ export const proto = $root.proto = (() => {
                     case 60:
                         m.capabilities[i] = 60;
                         break;
+                    case "AI_SUBSCRIPTION_ENABLED":
+                    case 61:
+                        m.capabilities[i] = 61;
+                        break;
                     }
                 }
             }
@@ -6993,6 +6997,7 @@ export const proto = $root.proto = (() => {
             values[valuesById[58] = "JSON_PATCH_STREAMING"] = 58;
             values[valuesById[59] = "AI_TAB_FORCE_CLIPPY"] = 59;
             values[valuesById[60] = "UNIFIED_RESPONSE_EMBEDDED_SCREENS"] = 60;
+            values[valuesById[61] = "AI_SUBSCRIPTION_ENABLED"] = 61;
             return values;
         })();
 
@@ -32585,6 +32590,7 @@ export const proto = $root.proto = (() => {
             ClientHello.prototype.paddedBytes = null;
             ClientHello.prototype.sendServerHelloPaddedBytes = null;
             ClientHello.prototype.simulateXxkemFs = null;
+            ClientHello.prototype.pqMode = null;
 
             let $oneOfFields;
 
@@ -32636,6 +32642,12 @@ export const proto = $root.proto = (() => {
                 set: $util.oneOfSetter($oneOfFields)
             });
 
+            // Virtual OneOf for proto3 optional field
+            Object.defineProperty(ClientHello.prototype, "_pqMode", {
+                get: $util.oneOfGetter($oneOfFields = ["pqMode"]),
+                set: $util.oneOfSetter($oneOfFields)
+            });
+
             ClientHello.create = function create(properties) {
                 return new ClientHello(properties);
             };
@@ -32659,6 +32671,8 @@ export const proto = $root.proto = (() => {
                     w.uint32(56).bool(m.sendServerHelloPaddedBytes);
                 if (m.simulateXxkemFs != null && Object.hasOwnProperty.call(m, "simulateXxkemFs"))
                     w.uint32(64).bool(m.simulateXxkemFs);
+                if (m.pqMode != null && Object.hasOwnProperty.call(m, "pqMode"))
+                    w.uint32(72).int32(m.pqMode);
                 return w;
             };
 
@@ -32703,6 +32717,10 @@ export const proto = $root.proto = (() => {
                             m.simulateXxkemFs = r.bool();
                             break;
                         }
+                    case 9: {
+                            m.pqMode = r.int32();
+                            break;
+                        }
                     default:
                         r.skipType(t & 7);
                         break;
@@ -32754,6 +32772,50 @@ export const proto = $root.proto = (() => {
                 if (d.simulateXxkemFs != null) {
                     m.simulateXxkemFs = Boolean(d.simulateXxkemFs);
                 }
+                switch (d.pqMode) {
+                default:
+                    if (typeof d.pqMode === "number") {
+                        m.pqMode = d.pqMode;
+                        break;
+                    }
+                    break;
+                case "HANDSHAKE_PQ_MODE_UNKNOWN":
+                case 0:
+                    m.pqMode = 0;
+                    break;
+                case "XXKEM":
+                case 1:
+                    m.pqMode = 1;
+                    break;
+                case "XXKEM_FS":
+                case 2:
+                    m.pqMode = 2;
+                    break;
+                case "WA_CLASSICAL":
+                case 3:
+                    m.pqMode = 3;
+                    break;
+                case "WA_PQ":
+                case 4:
+                    m.pqMode = 4;
+                    break;
+                case "IKKEM":
+                case 5:
+                    m.pqMode = 5;
+                    break;
+                case "IKKEM_FS":
+                case 6:
+                    m.pqMode = 6;
+                    break;
+                case "XXKEM_2":
+                case 7:
+                    m.pqMode = 7;
+                    break;
+                case "IKKEM_2":
+                case 8:
+                    m.pqMode = 8;
+                    break;
+                }
                 return m;
             };
 
@@ -32801,6 +32863,11 @@ export const proto = $root.proto = (() => {
                     if (o.oneofs)
                         d._simulateXxkemFs = "simulateXxkemFs";
                 }
+                if (m.pqMode != null && m.hasOwnProperty("pqMode")) {
+                    d.pqMode = o.enums === String ? $root.proto.HandshakeMessage.HandshakePqMode[m.pqMode] === undefined ? m.pqMode : $root.proto.HandshakeMessage.HandshakePqMode[m.pqMode] : m.pqMode;
+                    if (o.oneofs)
+                        d._pqMode = "pqMode";
+                }
                 return d;
             };
 
@@ -32818,6 +32885,20 @@ export const proto = $root.proto = (() => {
             return ClientHello;
         })();
 
+        HandshakeMessage.HandshakePqMode = (function() {
+            const valuesById = {}, values = Object.create(valuesById);
+            values[valuesById[0] = "HANDSHAKE_PQ_MODE_UNKNOWN"] = 0;
+            values[valuesById[1] = "XXKEM"] = 1;
+            values[valuesById[2] = "XXKEM_FS"] = 2;
+            values[valuesById[3] = "WA_CLASSICAL"] = 3;
+            values[valuesById[4] = "WA_PQ"] = 4;
+            values[valuesById[5] = "IKKEM"] = 5;
+            values[valuesById[6] = "IKKEM_FS"] = 6;
+            values[valuesById[7] = "XXKEM_2"] = 7;
+            values[valuesById[8] = "IKKEM_2"] = 8;
+            return values;
+        })();
+
         HandshakeMessage.ServerHello = (function() {
 
             function ServerHello(p) {

src/Defaults/baileys-version.json

@@ -1 +1 @@
-{"version":[2,3000,1035317910]}
+{"version":[2,3000,1035504971]}

src/Defaults/index.ts

@@ -188,10 +188,12 @@ export const MEDIA_KEYS = Object.keys(MEDIA_PATH_MAP) as MediaType[]
 /** 120s timeout for history sync stall detection, same as WA Web's handleChunkProgress / restartPausedTimer (g = 120) */
 export const HISTORY_SYNC_PAUSED_TIMEOUT_MS = 120_000
 
-export const MIN_PREKEY_COUNT = 5
+// Replenishment threshold: when server count drops below this, top-up back to INITIAL_PREKEY_COUNT
+export const MIN_PREKEY_COUNT = 200
 
-// Moderate prekey count (upstream uses 812, reduced to balance rate limiting and availability)
+// Initial pool size matching WA Business (CDP IDB capture: prekey-store = 812 on registration)
-export const INITIAL_PREKEY_COUNT = 200
+// Rounded to 800 for cleanliness; replenishment always tops up to this value
+export const INITIAL_PREKEY_COUNT = 800
 
 export const UPLOAD_TIMEOUT = 30000 // 30 seconds
 // Moderate upload interval to balance rate limiting and responsiveness (was 5000)

src/Signal/libsignal.ts

@@ -306,7 +306,7 @@ export function makeLibSignalRepository(
 	// 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> => {
+	const resolveCanonicalJid = async(jid: string): Promise<string> => {
 		if (isAnyLidUser(jid)) {
 			return jid
 		}

src/Socket/groups.ts

@@ -25,30 +25,28 @@ export const makeGroupsSocket = (config: SocketConfig) => {
 		const lidMapping = signalRepository.lidMapping
 
 		// Resolve all participant LIDs in parallel for better performance on large groups
-		await Promise.all(
+		await Promise.all(metadata.participants.map(async (p) => {
-			metadata.participants.map(async p => {
+			if (isLidUser(p.id)) {
-				if (isLidUser(p.id)) {
+				if (p.phoneNumber) {
-					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 = p.phoneNumber
+						p.id = resolved
-					} 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)
+				? (metadata.ownerPn || resolveLidToPn(metadata.owner, lidMapping, logger))
 				: null,
 			metadata.subjectOwner && isLidUser(metadata.subjectOwner)
-				? metadata.subjectOwnerPn || resolveLidToPn(metadata.subjectOwner, lidMapping, logger)
+				? (metadata.subjectOwnerPn || resolveLidToPn(metadata.subjectOwner, lidMapping, logger))
 				: null
 		])
 		if (resolvedOwner) metadata.owner = resolvedOwner
@@ -97,13 +95,11 @@ export const makeGroupsSocket = (config: SocketConfig) => {
 		if (groupsChild) {
 			const groups = getBinaryNodeChildren(groupsChild, 'group')
 			for (const groupNode of groups) {
-				const meta = await normalizeGroupMetadata(
+				const meta = await normalizeGroupMetadata(extractGroupMetadata({
-					extractGroupMetadata({
+					tag: 'result',
-						tag: 'result',
+					attrs: {},
-						attrs: {},
+					content: [groupNode]
-						content: [groupNode]
+				}))
-					})
-				)
 				data[meta.id] = meta
 			}
 		}

src/Socket/messages-recv.ts

@@ -7,6 +7,7 @@ import { proto } from '../../WAProto/index.js'
 import {
 	DEFAULT_CACHE_TTLS,
 	DEFAULT_SESSION_CLEANUP_CONFIG,
+	INITIAL_PREKEY_COUNT,
 	KEY_BUNDLE_TYPE,
 	MIN_PREKEY_COUNT,
 	PLACEHOLDER_MAX_AGE_SECONDS,
@@ -48,9 +49,12 @@ import {
 	getStatusFromReceiptType,
 	handleIdentityChange,
 	hkdf,
+	BAD_MAC_ERROR_TEXT,
+	DECRYPTION_RETRY_CONFIG,
 	MISSING_KEYS_ERROR_TEXT,
 	NACK_REASONS,
 	NO_MESSAGE_FOUND_ERROR_TEXT,
+	RetryReason,
 	normalizeKeyLidToPn,
 	normalizeMessageJids,
 	resolveLidToPn,
@@ -376,7 +380,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 				for (const update of updates) {
 					if (update.jid && update.user) {
 						const [resolvedAuthor, resolvedUser] = await Promise.all([
-							resolveLidToPn(node.attrs.from, signalRepository.lidMapping, logger),
+							resolveLidToPn(node.attrs.from!, signalRepository.lidMapping, logger),
 							resolveLidToPn(update.user, signalRepository.lidMapping, logger)
 						])
 						ev.emit('newsletter-participants.update', {
@@ -403,7 +407,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		const child = getAllBinaryNodeChildren(node)[0]!
 		const rawAuthor = node.attrs.participant!
 		// Resolve author LID→PN (participant is a user JID that could be LID)
-		const author = (await resolveLidToPn(rawAuthor, signalRepository.lidMapping, logger)) || rawAuthor
+		const author = await resolveLidToPn(rawAuthor, signalRepository.lidMapping, logger) || rawAuthor
 
 		logger.info({ from, child }, 'got newsletter notification')
 
@@ -430,8 +434,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 				break
 
 			case 'participant':
-				const resolvedParticipantUser =
+				const resolvedParticipantUser = await resolveLidToPn(child.attrs.jid!, signalRepository.lidMapping, logger) || child.attrs.jid!
-					(await resolveLidToPn(child.attrs.jid, signalRepository.lidMapping, logger)) || child.attrs.jid!
 				const participantUpdate = {
 					id: from,
 					author,
@@ -574,7 +577,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		const offerContent: BinaryNode[] = [
 			{ tag: 'privacy', attrs: {}, content: undefined },
 			{ tag: 'audio', attrs: { rate: '8000', enc: 'opus' }, content: undefined },
-			{ tag: 'audio', attrs: { rate: '16000', enc: 'opus' }, content: undefined }
+			{ tag: 'audio', attrs: { rate: '16000', enc: 'opus' }, content: undefined },
 		]
 
 		if (isVideo) {
@@ -595,31 +598,31 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			{ tag: 'net', attrs: { medium: '3' }, content: undefined },
 			{ tag: 'capability', attrs: { ver: '1' }, content: undefined },
 			{ tag: 'enc', attrs: { v: '2', type: isVideo ? 'msg' : 'pkmsg' }, content: undefined },
-			{ tag: 'encopt', attrs: { keygen: '2' }, content: undefined }
+			{ tag: 'encopt', attrs: { keygen: '2' }, content: undefined },
 		)
 
 		// Voice calls include device-identity (verified via Frida capture)
 		if (!isVideo) {
-			offerContent.push({ tag: 'device-identity', attrs: {}, content: undefined })
+			offerContent.push(
+				{ tag: 'device-identity', attrs: {}, content: undefined },
+			)
 		}
 
 		const stanza: BinaryNode = {
 			tag: 'call',
 			attrs: {
 				to: jid,
-				id: stanzaId
+				id: stanzaId,
 			},
-			content: [
+			content: [{
-				{
+				tag: 'offer',
-					tag: 'offer',
+				attrs: {
-					attrs: {
+					'call-creator': meId,
-						'call-creator': meId,
+					'call-id': callId,
-						'call-id': callId,
+					'device_class': '2013',
-						device_class: '2013'
+				},
-					},
+				content: offerContent
-					content: offerContent
+			}]
-				}
-			]
 		}
 
 		await query(stanza)
@@ -648,7 +651,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 
 		const terminateAttrs: Record<string, string> = {
 			'call-id': callId,
-			'call-creator': callCreator || meId
+			'call-creator': callCreator || meId,
 		}
 
 		if (reason) {
@@ -664,15 +667,13 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			tag: 'call',
 			attrs: {
 				to: callTo,
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'terminate',
-					tag: 'terminate',
+				attrs: terminateAttrs,
-					attrs: terminateAttrs,
+				content: undefined
-					content: undefined
+			}]
-				}
-			]
 		}
 
 		await query(stanza)
@@ -686,18 +687,24 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 	 * @param callFrom - JID of the caller (call-creator)
 	 * @param isVideo - true for video call
 	 */
-	const acceptCall = async (callId: string, callFrom: string, isVideo?: boolean) => {
+	const acceptCall = async (
+		callId: string,
+		callFrom: string,
+		isVideo?: boolean,
+	) => {
 		const meId = authState.creds.me?.id
 		if (!meId) throw new Boom('Not authenticated', { statusCode: 401 })
 
-		const acceptContent: BinaryNode[] = [{ tag: 'audio', attrs: { rate: '16000', enc: 'opus' }, content: undefined }]
+		const acceptContent: BinaryNode[] = [
+			{ tag: 'audio', attrs: { rate: '16000', enc: 'opus' }, content: undefined },
+		]
 
 		if (isVideo) {
 			acceptContent.push({
 				tag: 'video',
 				attrs: {
 					dec: 'H264,AV1',
-					device_orientation: '1'
+					device_orientation: '1',
 				},
 				content: undefined
 			})
@@ -705,7 +712,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 
 		acceptContent.push(
 			{ tag: 'net', attrs: { medium: '2' }, content: undefined },
-			{ tag: 'encopt', attrs: { keygen: '2' }, content: undefined }
+			{ tag: 'encopt', attrs: { keygen: '2' }, content: undefined },
 		)
 
 		const stanza: BinaryNode = {
@@ -713,18 +720,16 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			attrs: {
 				from: meId,
 				to: callFrom,
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'accept',
-					tag: 'accept',
+				attrs: {
-					attrs: {
+					'call-id': callId,
-						'call-id': callId,
+					'call-creator': callFrom,
-						'call-creator': callFrom
+				},
-					},
+				content: acceptContent
-					content: acceptContent
+			}]
-				}
-			]
 		}
 
 		await query(stanza)
@@ -739,8 +744,14 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 	 * @param callCreator - JID of the caller
 	 * @param isVideo - true for video call
 	 */
-	const preacceptCall = async (callId: string, callCreator: string, isVideo?: boolean) => {
+	const preacceptCall = async (
-		const preacceptContent: BinaryNode[] = [{ tag: 'audio', attrs: { rate: '16000', enc: 'opus' }, content: undefined }]
+		callId: string,
+		callCreator: string,
+		isVideo?: boolean,
+	) => {
+		const preacceptContent: BinaryNode[] = [
+			{ tag: 'audio', attrs: { rate: '16000', enc: 'opus' }, content: undefined },
+		]
 
 		if (isVideo) {
 			preacceptContent.push({
@@ -749,7 +760,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 					screen_width: '1080',
 					screen_height: '2400',
 					dec: 'H264,H265,AV1',
-					device_orientation: '0'
+					device_orientation: '0',
 				},
 				content: undefined
 			})
@@ -757,25 +768,23 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 
 		preacceptContent.push(
 			{ tag: 'encopt', attrs: { keygen: '2' }, content: undefined },
-			{ tag: 'capability', attrs: { ver: '1' }, content: undefined }
+			{ tag: 'capability', attrs: { ver: '1' }, content: undefined },
 		)
 
 		const stanza: BinaryNode = {
 			tag: 'call',
 			attrs: {
 				to: callCreator,
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'preaccept',
-					tag: 'preaccept',
+				attrs: {
-					attrs: {
+					'call-id': callId,
-						'call-id': callId,
+					'call-creator': callCreator,
-						'call-creator': callCreator
+				},
-					},
+				content: preacceptContent
-					content: preacceptContent
+			}]
-				}
-			]
 		}
 
 		await query(stanza)
@@ -801,11 +810,11 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			dlBw?: number
 			ulBw?: number
 		}>,
-		transactionId?: string
+		transactionId?: string,
 	) => {
 		const relayLatencyAttrs: Record<string, string> = {
 			'call-id': callId,
-			'call-creator': callCreator
+			'call-creator': callCreator,
 		}
 
 		if (transactionId) {
@@ -838,15 +847,13 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			tag: 'call',
 			attrs: {
 				to: callCreator,
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'relaylatency',
-					tag: 'relaylatency',
+				attrs: relayLatencyAttrs,
-					attrs: relayLatencyAttrs,
+				content: teChildren
-					content: teChildren
+			}]
-				}
-			]
 		}
 
 		await sendNode(stanza)
@@ -867,12 +874,12 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		callCreator: string,
 		to: string,
 		candidates: Array<{ priority: string; data?: Uint8Array }>,
-		round?: number
+		round?: number,
 	) => {
 		const transportAttrs: Record<string, string> = {
 			'call-id': callId,
 			'call-creator': callCreator,
-			'transport-message-type': '1'
+			'transport-message-type': '1',
 		}
 
 		if (round !== undefined) {
@@ -882,22 +889,20 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		const teChildren: BinaryNode[] = candidates.map(c => ({
 			tag: 'te',
 			attrs: { priority: c.priority },
-			content: c.data
+			content: c.data,
 		}))
 
 		const stanza: BinaryNode = {
 			tag: 'call',
 			attrs: {
 				to,
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'transport',
-					tag: 'transport',
+				attrs: transportAttrs,
-					attrs: transportAttrs,
+				content: teChildren
-					content: teChildren
+			}]
-				}
-			]
 		}
 
 		await sendNode(stanza)
@@ -918,27 +923,25 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		callCreator: string,
 		peer: string,
 		audioDuration: number,
-		callType = '1x1'
+		callType: string = '1x1',
 	) => {
 		const stanza: BinaryNode = {
 			tag: 'call',
 			attrs: {
 				to: 'call',
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'duration',
-					tag: 'duration',
+				attrs: {
-					attrs: {
+					'call-id': callId,
-						'call-id': callId,
+					'call-creator': callCreator,
-						'call-creator': callCreator,
+					peer,
-						peer,
+					audio_duration: String(audioDuration),
-						audio_duration: String(audioDuration),
+					type: callType,
-						type: callType
+				},
-					},
+				content: undefined
-					content: undefined
+			}]
-				}
-			]
 		}
 
 		await sendNode(stanza)
@@ -953,24 +956,27 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 	 * @param to - destination JID
 	 * @param muted - true to mute, false to unmute
 	 */
-	const muteCall = async (callId: string, callCreator: string, to: string, muted: boolean) => {
+	const muteCall = async (
+		callId: string,
+		callCreator: string,
+		to: string,
+		muted: boolean,
+	) => {
 		const stanza: BinaryNode = {
 			tag: 'call',
 			attrs: {
 				to,
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'mute_v2',
-					tag: 'mute_v2',
+				attrs: {
-					attrs: {
+					'mute-state': muted ? '1' : '0',
-						'mute-state': muted ? '1' : '0',
+					'call-id': callId,
-						'call-id': callId,
+					'call-creator': callCreator,
-						'call-creator': callCreator
+				},
-					},
+				content: undefined
-					content: undefined
+			}]
-				}
-			]
 		}
 
 		await sendNode(stanza)
@@ -983,23 +989,24 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 	 * @param callId - the call-id (also used as JID with @call)
 	 * @param callCreator - JID of the call creator
 	 */
-	const sendHeartbeat = async (callId: string, callCreator: string) => {
+	const sendHeartbeat = async (
+		callId: string,
+		callCreator: string,
+	) => {
 		const stanza: BinaryNode = {
 			tag: 'call',
 			attrs: {
 				to: `${callId}@call`,
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'heartbeat',
-					tag: 'heartbeat',
+				attrs: {
-					attrs: {
+					'call-id': callId,
-						'call-id': callId,
+					'call-creator': callCreator,
-						'call-creator': callCreator
+				},
-					},
+				content: undefined
-					content: undefined
+			}]
-				}
-			]
 		}
 
 		await sendNode(stanza)
@@ -1014,27 +1021,30 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 	 * @param to - destination JID
 	 * @param transactionId - transaction ID for the rekey
 	 */
-	const sendEncRekey = async (callId: string, callCreator: string, to: string, transactionId: string) => {
+	const sendEncRekey = async (
+		callId: string,
+		callCreator: string,
+		to: string,
+		transactionId: string,
+	) => {
 		const stanza: BinaryNode = {
 			tag: 'call',
 			attrs: {
 				to,
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'enc_rekey',
-					tag: 'enc_rekey',
+				attrs: {
-					attrs: {
+					'transaction-id': transactionId,
-						'transaction-id': transactionId,
+					'call-id': callId,
-						'call-id': callId,
+					'call-creator': callCreator,
-						'call-creator': callCreator
+				},
-					},
+				content: [
-					content: [
+					{ tag: 'encopt', attrs: { keygen: '2' }, content: undefined },
-						{ tag: 'encopt', attrs: { keygen: '2' }, content: undefined },
+					{ tag: 'enc', attrs: { v: '2', type: 'msg' }, content: undefined },
-						{ tag: 'enc', attrs: { v: '2', type: 'msg' }, content: undefined }
+				]
-					]
+			}]
-				}
-			]
 		}
 
 		await sendNode(stanza)
@@ -1055,26 +1065,24 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		callCreator: string,
 		to: string,
 		enabled: boolean,
-		orientation = '1'
+		orientation: string = '1',
 	) => {
 		const stanza: BinaryNode = {
 			tag: 'call',
 			attrs: {
 				to,
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'video',
-					tag: 'video',
+				attrs: {
-					attrs: {
+					'call-id': callId,
-						'call-id': callId,
+					'call-creator': callCreator,
-						'call-creator': callCreator,
+					state: enabled ? '1' : '0',
-						state: enabled ? '1' : '0',
+					device_orientation: orientation,
-						device_orientation: orientation
+				},
-					},
+				content: undefined
-					content: undefined
+			}]
-				}
-			]
 		}
 
 		await sendNode(stanza)
@@ -1096,17 +1104,15 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			tag: 'call',
 			attrs: {
 				to: 'call',
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'link_create',
-					tag: 'link_create',
+				attrs: { media },
-					attrs: { media },
+				content: event
-					content: event
+					? [{ tag: 'event', attrs: { start_time: String(event.startTime) }, content: undefined }]
-						? [{ tag: 'event', attrs: { start_time: String(event.startTime) }, content: undefined }]
+					: undefined
-						: undefined
+			}]
-				}
-			]
 		}
 
 		const response = await query(stanza, timeoutMs)
@@ -1134,7 +1140,9 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		}
 
 		// URL format verified via Frida capture: https://call.whatsapp.com/<token>
-		const url = token ? `https://call.whatsapp.com/${token}` : undefined
+		const url = token
+			? `https://call.whatsapp.com/${token}`
+			: undefined
 
 		return { token, url, response }
 	}
@@ -1152,15 +1160,13 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			tag: 'call',
 			attrs: {
 				to: 'call',
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'link_query',
-					tag: 'link_query',
+				attrs: { media, token },
-					attrs: { media, token },
+				content: undefined
-					content: undefined
+			}]
-				}
-			]
 		}
 
 		return await query(stanza)
@@ -1178,7 +1184,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		const joinContent: BinaryNode[] = [
 			{ tag: 'audio', attrs: { rate: '16000', enc: 'opus' }, content: undefined },
 			{ tag: 'net', attrs: { medium: '2' }, content: undefined },
-			{ tag: 'capability', attrs: { ver: '1' }, content: undefined }
+			{ tag: 'capability', attrs: { ver: '1' }, content: undefined },
 		]
 
 		if (media === 'video') {
@@ -1188,7 +1194,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 					screen_width: '1080',
 					screen_height: '2400',
 					dec: 'H264,H265,AV1',
-					device_orientation: '0'
+					device_orientation: '0',
 				},
 				content: undefined
 			})
@@ -1198,21 +1204,19 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			tag: 'call',
 			attrs: {
 				to: 'call',
-				id: randomBytes(16).toString('hex').toUpperCase()
+				id: randomBytes(16).toString('hex').toUpperCase(),
 			},
-			content: [
+			content: [{
-				{
+				tag: 'link_join',
-					tag: 'link_join',
+				attrs: { media, token },
-					attrs: { media, token },
+				content: joinContent
-					content: joinContent
+			}]
-				}
-			]
 		}
 
 		return await query(stanza)
 	}
 
-	const sendRetryRequest = async (node: BinaryNode, forceIncludeKeys = false) => {
+	const sendRetryRequest = async (node: BinaryNode, forceIncludeKeys = false, decryptionError?: string) => {
 		const { fullMessage } = decodeMessageNode(node, authState.creds.me!.id, authState.creds.me!.lid || '')
 		const { key: msgKey } = fullMessage
 		const msgId = msgKey.id!
@@ -1223,7 +1227,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		// For group messages, scope by participant (each participant has its own Signal session).
 		const retryDedupeJid = msgKey.participant
 			? jidNormalizedUser(msgKey.participant)
-			: jidNormalizedUser(node.attrs.from)
+			: jidNormalizedUser(node.attrs.from!)
 		if (retryRequestActiveJids.has(retryDedupeJid)) {
 			logger.debug(
 				{ fromJid: retryDedupeJid, msgId },
@@ -1246,9 +1250,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 				// this cleanup only runs as a last resort.
 				// For group messages, use participant JID (Signal sessions are per-participant, not per-group).
 				if (autoCleanCorrupted) {
-					const senderJid = msgKey.participant
+					const senderJid = msgKey.participant ? jidNormalizedUser(msgKey.participant) : jidNormalizedUser(node.attrs.from!)
-						? jidNormalizedUser(msgKey.participant)
-						: jidNormalizedUser(node.attrs.from)
 					try {
 						const decryptionJid = await getDecryptionJid(senderJid, signalRepository)
 						const deletedCount = await cleanupCorruptedSession(decryptionJid, signalRepository, logger)
@@ -1284,9 +1286,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 
 				// Safety net cleanup (same as new system above)
 				if (autoCleanCorrupted) {
-					const senderJid = msgKey.participant
+					const senderJid = msgKey.participant ? jidNormalizedUser(msgKey.participant) : jidNormalizedUser(node.attrs.from!)
-						? jidNormalizedUser(msgKey.participant)
-						: jidNormalizedUser(node.attrs.from)
 					try {
 						const decryptionJid = await getDecryptionJid(senderJid, signalRepository)
 						await cleanupCorruptedSession(decryptionJid, signalRepository, logger)
@@ -1314,39 +1314,39 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		const { account, signedPreKey, signedIdentityKey: identityKey } = authState.creds
 		const fromJid = node.attrs.from!
 
-		// Check if we should recreate the session
+		// Derive the Signal error code from the actual decryption failure message.
-		let shouldRecreateSession = false
+		// Sent in the retry receipt so the peer (even another InfiniteAPI instance)
-		let recreateReason = ''
+		// knows the exact failure type and can recreate the session immediately
-
+		// instead of falling back to the 1-hour timeout.
-		if (enableAutoSessionRecreation && messageRetryManager && retryCount >= 1) {
+		//
-			try {
+		// Codes mirror RetryReason enum in message-retry-manager.ts:
-				// Check if we have a session with this JID
+		//   0 = UnknownError | 1 = NoSession  | 2 = InvalidKey
-				const sessionId = signalRepository.jidToSignalProtocolAddress(fromJid)
+		//   3 = InvalidKeyId | 4 = InvalidMessage | 7 = BadMac
-				const hasSession = await signalRepository.validateSession(fromJid)
+		//
-
+		// Uses DECRYPTION_RETRY_CONFIG error lists (single source of truth in
-				// Extract error code from retry node if present (for MAC error detection)
+		// decode-wa-message.ts) so additions to those lists are picked up here
-				const retryNode = getBinaryNodeChild(node, 'retry')
+		// automatically.
-				const errorAttr = retryNode?.attrs?.error
+		//
-				const errorCode = messageRetryManager.parseRetryErrorCode(errorAttr)
+		// NOTE: We do NOT delete the session here (receiver side). The Signal Protocol
-
+		// recovers automatically when the sender's pkmsg arrives — it overwrites the
-				const result = messageRetryManager.shouldRecreateSession(fromJid, hasSession.exists, errorCode)
+		// corrupted session. Deleting prematurely creates a race window where no session
-				shouldRecreateSession = result.recreate
+		// exists, which can cause "No Session" errors on concurrent messages.
-				recreateReason = result.reason
+		const retryErrorCode = (() => {
-
+			if (!decryptionError) return RetryReason.UnknownError
-				if (shouldRecreateSession) {
+			// Bad MAC must be checked first — it is also in corruptedSessionErrors
-					logger.debug({ fromJid, retryCount, reason: recreateReason, errorCode }, 'recreating session for retry')
+			// but warrants the more specific code 7 over the generic code 4.
-					// Delete existing session to force recreation
+			if (decryptionError.includes(BAD_MAC_ERROR_TEXT)) return RetryReason.SignalErrorBadMac
-					// CRITICAL: Use same transaction key as encrypt/decrypt operations to prevent race
+			// MessageCounterError and other corrupted-session variants
-					// Using meId ensures this delete serializes with sendMessage() and other session operations
+			if (DECRYPTION_RETRY_CONFIG.corruptedSessionErrors.some(e => decryptionError.includes(e))) return RetryReason.SignalErrorInvalidMessage
-					await authState.keys.transaction(async () => {
+			// Missing / invalid session record
-						await authState.keys.set({ session: { [sessionId]: null } })
+			if (DECRYPTION_RETRY_CONFIG.sessionRecordErrors.some(e => decryptionError.includes(e)) ||
-					}, authState.creds.me?.id || 'session-operation')
+				/no\s+(open\s+)?sessions?/i.test(decryptionError)) return RetryReason.SignalErrorNoSession
-					forceIncludeKeys = true
+			// PreKey / key-id errors
-				}
+			if (/pre\s*key/i.test(decryptionError)) return RetryReason.SignalErrorInvalidKeyId
-			} catch (error) {
+			// Identity / key errors
-				logger.warn({ error, fromJid }, 'failed to check session recreation')
+			if (/invalid\s*key|untrusted\s*identity/i.test(decryptionError)) return RetryReason.SignalErrorInvalidKey
-			}
+			return RetryReason.UnknownError
-		}
+		})()
 
 		if (retryCount <= 2) {
 			// Use new retry manager for phone requests if available
@@ -1387,8 +1387,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 							id: node.attrs.id!,
 							t: node.attrs.t!,
 							v: '1',
-							// ADD ERROR FIELD
+							error: retryErrorCode.toString()
-							error: '0'
 						}
 					},
 					{
@@ -1407,7 +1406,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 				receipt.attrs.participant = node.attrs.participant
 			}
 
-			if (retryCount > 1 || forceIncludeKeys || shouldRecreateSession) {
+			if (retryCount > 1 || forceIncludeKeys) {
 				const { update, preKeys } = await getNextPreKeys(authState, 1)
 
 				const [keyId] = Object.keys(preKeys)
@@ -1444,7 +1443,8 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 
 			logger.debug({ count, shouldUploadMorePreKeys }, 'recv pre-key count')
 			if (shouldUploadMorePreKeys) {
-				await uploadPreKeys()
+				// Top-up back to INITIAL_PREKEY_COUNT so the pool is always restored to full size
+				await uploadPreKeys(Math.max(1, INITIAL_PREKEY_COUNT - count))
 			}
 		} else {
 			const result = await handleIdentityChange(node, {
@@ -1468,13 +1468,13 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 							const senderTs = unixTimestampSeconds()
 							logTcToken('reissue', { jid: normalizedJid, reason: 'session_refreshed' })
 							getPrivacyTokens([normalizedJid], senderTs)
-								.then(async iqResult => {
+								.then(async (iqResult) => {
 									await storeTcTokensFromIqResult({
 										result: iqResult,
 										fallbackJid: normalizedJid,
 										keys: authState.keys,
 										getLIDForPN,
-										onNewJidStored: storedJid => {
+										onNewJidStored: (storedJid) => {
 											tcTokenKnownJids.add(storedJid)
 											scheduleTcTokenIndexSave()
 										}
@@ -1520,20 +1520,16 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		const affectedParticipantPn = getBinaryNodeChild(child, 'participant')?.attrs?.phone_number || actingParticipantPn!
 
 		// Resolve acting participant to PN — prefer inline PN, fall back to LID→PN resolution
-		const actingParticipant = actingParticipantPn || (await resolveLidToPn(actingParticipantLid, lidMapping, logger))
+		const actingParticipant = actingParticipantPn
+			|| await resolveLidToPn(actingParticipantLid, lidMapping, logger)
 
 		// Resolve affected participant to PN
-		const affectedParticipant =
+		const affectedParticipant = affectedParticipantPn
-			affectedParticipantPn || (await resolveLidToPn(affectedParticipantLid, lidMapping, logger))
+			|| await resolveLidToPn(affectedParticipantLid, lidMapping, logger)
 
 		// Store LID↔PN mappings from notification attributes
 		const mappingsToStore: Array<{ lid: string; pn: string }> = []
-		if (
+		if (actingParticipantLid && actingParticipantPn && isLidUser(actingParticipantLid) && isPnUser(actingParticipantPn)) {
-			actingParticipantLid &&
-			actingParticipantPn &&
-			isLidUser(actingParticipantLid) &&
-			isPnUser(actingParticipantPn)
-		) {
 			mappingsToStore.push({ lid: actingParticipantLid, pn: actingParticipantPn })
 		}
 
@@ -1562,7 +1558,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 
 				// Resolve metadata owner to PN
 				if (metadata.owner && isLidUser(metadata.owner)) {
-					const resolvedOwner = metadata.ownerPn || (await resolveLidToPn(metadata.owner, lidMapping, logger))
+					const resolvedOwner = metadata.ownerPn || await resolveLidToPn(metadata.owner, lidMapping, logger)
 					if (resolvedOwner) metadata.owner = resolvedOwner
 				}
 
@@ -1596,7 +1592,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			case 'modify':
 				const oldNumbers = await Promise.all(
 					getBinaryNodeChildren(child, 'participant').map(async p => {
-						const resolved = await resolveLidToPn(p.attrs.jid, lidMapping, logger)
+						const resolved = await resolveLidToPn(p.attrs.jid!, lidMapping, logger)
 						return resolved || p.attrs.jid!
 					})
 				)
@@ -1778,7 +1774,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 
 				{
 					const rawPictureJid = jidNormalizedUser(node?.attrs?.from) || (setPicture || delPicture)?.attrs?.hash || ''
-					const pictureJid = (await resolveLidToPn(rawPictureJid, signalRepository.lidMapping, logger)) || rawPictureJid
+					const pictureJid = await resolveLidToPn(rawPictureJid, signalRepository.lidMapping, logger) || rawPictureJid
 					ev.emit('contacts.update', [
 						{
 							id: pictureJid,
@@ -1823,8 +1819,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 					const blocklists = getBinaryNodeChildren(child, 'item')
 
 					for (const { attrs } of blocklists) {
-						const resolvedBlockJid =
+						const resolvedBlockJid = await resolveLidToPn(attrs.jid!, signalRepository.lidMapping, logger) || attrs.jid!
-							(await resolveLidToPn(attrs.jid, signalRepository.lidMapping, logger)) || attrs.jid!
 						const blocklist = [resolvedBlockJid]
 						const type = attrs.action === 'block' ? 'add' : 'remove'
 						ev.emit('blocklist.update', { blocklist, type })
@@ -2155,8 +2150,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 							if (attrs.participant) {
 								const updateKey: keyof MessageUserReceipt =
 									status === proto.WebMessageInfo.Status.DELIVERY_ACK ? 'receiptTimestamp' : 'readTimestamp'
-								const resolvedReceiptUserJid =
+								const resolvedReceiptUserJid = await resolveLidToPn(attrs.participant, lidMapping, logger) || jidNormalizedUser(attrs.participant)
-									(await resolveLidToPn(attrs.participant, lidMapping, logger)) || jidNormalizedUser(attrs.participant)
 								ev.emit(
 									'message-receipt.update',
 									ids.map(id => ({
@@ -2269,7 +2263,13 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			category,
 			author,
 			decrypt
-		} = decryptMessageNode(node, authState.creds.me!.id, authState.creds.me!.lid || '', signalRepository, logger)
+		} = decryptMessageNode(
+			node,
+			authState.creds.me!.id,
+			authState.creds.me!.lid || '',
+			signalRepository,
+			logger,
+		)
 
 		const alt = msg.key.participantAlt || msg.key.remoteJidAlt
 		// Handle LID/PN mappings with hybrid approach:
@@ -2509,7 +2509,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 							}
 
 							const encNode = getBinaryNodeChild(node, 'enc')
-							await sendRetryRequest(node, !encNode)
+							await sendRetryRequest(node, !encNode, errorMessage)
 							if (retryRequestDelayMs) {
 								await delay(retryRequestDelayMs)
 							}
@@ -2518,7 +2518,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 							// Still attempt retry even if pre-key upload failed
 							try {
 								const encNode = getBinaryNodeChild(node, 'enc')
-								await sendRetryRequest(node, !encNode)
+								await sendRetryRequest(node, !encNode, errorMessage)
 							} catch (retryErr) {
 								logger.error({ retryErr }, 'Failed to send retry after error handling')
 							}
@@ -2684,7 +2684,7 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			jid: u.attrs.jid,
 			state: u.attrs.state,
 			userPn: u.attrs.user_pn,
-			type: u.attrs.type
+			type: u.attrs.type,
 		}))
 	}
 
@@ -2772,7 +2772,9 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 				const callSummary = getBinaryNodeChild(infoChild, 'call_summary')
 				if (callSummary) {
 					call.media = callSummary.attrs.media
-					call.duration = callSummary.attrs.call_duration ? Number(callSummary.attrs.call_duration) : undefined
+					call.duration = callSummary.attrs.call_duration
+						? Number(callSummary.attrs.call_duration)
+						: undefined
 					call.participants = extractParticipants(callSummary)
 				}
 			}
@@ -2816,14 +2818,12 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 			if (resolvedLinkCreator) call.linkCreator = resolvedLinkCreator
 			// Resolve participant JIDs in parallel
 			if (call.participants) {
-				await Promise.all(
+				await Promise.all(call.participants.map(async (p) => {
-					call.participants.map(async p => {
+					if (p.jid) {
-						if (p.jid) {
+						const resolved = p.userPn || await resolveLidToPn(p.jid, callLidMapping, logger)
-							const resolved = p.userPn || (await resolveLidToPn(p.jid, callLidMapping, logger))
+						if (resolved) p.jid = resolved
-							if (resolved) p.jid = resolved
+					}
-						}
+				}))
-					})
-				)
 			}
 
 			ev.emit('call', [call])
@@ -2861,22 +2861,20 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 				// WABA Android: error 463 triggers getPrivacyTokens() fire-and-forget
 				// to ensure token is available for the retry below
 				getPrivacyTokens([jid])
-					.then(async result => {
+					.then(async (result) => {
 						await storeTcTokensFromIqResult({
 							result,
 							fallbackJid: jid,
 							keys: authState.keys,
 							getLIDForPN,
-							onNewJidStored: storedJid => {
+							onNewJidStored: (storedJid) => {
 								tcTokenKnownJids.add(storedJid)
 								scheduleTcTokenIndexSave()
 							}
 						})
 						logTcToken('fetched', { jid, reason: 'error_463' })
 					})
-					.catch(() => {
+					.catch(() => { /* fire-and-forget */ })
-						/* fire-and-forget */
-					})
 
 				// Single-retry: wait 1.5s for the server's tctoken notification to arrive,
 				// then resend. A Set prevents infinite retry loops.
@@ -2917,22 +2915,20 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 				logTcToken('error_479', { jid: jid479, msgId: attrs.id })
 				// WABA Android: error 479 (SmaxInvalid) also triggers token re-fetch
 				getPrivacyTokens([jid479])
-					.then(async result => {
+					.then(async (result) => {
 						await storeTcTokensFromIqResult({
 							result,
 							fallbackJid: jid479,
 							keys: authState.keys,
 							getLIDForPN,
-							onNewJidStored: storedJid => {
+							onNewJidStored: (storedJid) => {
 								tcTokenKnownJids.add(storedJid)
 								scheduleTcTokenIndexSave()
 							}
 						})
 						logTcToken('fetched', { jid: jid479, reason: 'error_479' })
 					})
-					.catch(() => {
+					.catch(() => { /* fire-and-forget */ })
-						/* fire-and-forget */
-					})
 			} else {
 				logger.warn({ attrs }, 'received error in ack')
 			}
@@ -3066,20 +3062,24 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		// (call link relays may arrive without these attrs — just log them)
 		if (callId && rawCallCreator) {
 			// Resolve LID→PN for call creator
-			const callCreator = (await resolveLidToPn(rawCallCreator, signalRepository.lidMapping, logger)) || rawCallCreator
+			const callCreator = await resolveLidToPn(rawCallCreator, signalRepository.lidMapping, logger) || rawCallCreator
-			logger.debug({ callId, callCreator, uuid: node.attrs.uuid }, 'received relay info')
+			logger.debug(
-			ev.emit('call', [
+				{ callId, callCreator, uuid: node.attrs.uuid },
-				{
+				'received relay info'
-					chatId: callCreator,
+			)
-					from: callCreator,
+			ev.emit('call', [{
-					id: callId,
+				chatId: callCreator,
-					date: new Date(),
+				from: callCreator,
-					offline: false,
+				id: callId,
-					status: 'relay' as WACallUpdateType
+				date: new Date(),
-				}
+				offline: false,
-			])
+				status: 'relay' as WACallUpdateType,
+			}])
 		} else {
-			logger.debug({ attrs: node.attrs }, 'received relay stanza without call-id/call-creator')
+			logger.debug(
+				{ attrs: node.attrs },
+				'received relay stanza without call-id/call-creator'
+			)
 		}
 	})
 

src/Socket/messages-send.ts

@@ -1,6 +1,6 @@
+import { randomBytes } from 'crypto'
 import NodeCache from '@cacheable/node-cache'
 import { Boom } from '@hapi/boom'
-import { randomBytes } from 'crypto'
 import { proto } from '../../WAProto/index.js'
 import { DEFAULT_CACHE_TTLS, WA_DEFAULT_EPHEMERAL } from '../Defaults'
 import type {
@@ -9,6 +9,7 @@ import type {
 	AlbumMessageOptions,
 	AlbumSendResult,
 	AnyMessageContent,
+	LIDMapping,
 	MediaConnInfo,
 	MessageReceiptType,
 	MessageRelayOptions,
@@ -338,6 +339,33 @@ export const makeMessagesSocket = (config: SocketConfig) => {
 				}
 			}
 
+			// 4th LID→PN source: device-list entries sharing the same raw_id
+			// WA Business uses this for accounts where HistorySync sends zero phoneNumberToLidMappings
+			const allEntries = [...result.list, ...result.sideList]
+			const rawIdMap = new Map<number, { pn?: string; lid?: string }>()
+			for (const item of allEntries) {
+				if (typeof item.rawId !== 'number' || isNaN(item.rawId)) continue
+				const decoded = jidDecode(item.id)
+				if (!decoded) continue
+				const entry = rawIdMap.get(item.rawId) || {}
+				if (decoded.server === 'lid' || decoded.server === 'hosted.lid') {
+					entry.lid = item.id
+				} else if (decoded.server === 's.whatsapp.net' || decoded.server === 'c.us') {
+					entry.pn = item.id
+				}
+				rawIdMap.set(item.rawId, entry)
+			}
+			const rawIdMappings: LIDMapping[] = []
+			for (const { pn, lid } of rawIdMap.values()) {
+				if (pn && lid) {
+					rawIdMappings.push({ lid: jidNormalizedUser(lid), pn: jidNormalizedUser(pn) })
+				}
+			}
+			if (rawIdMappings.length > 0) {
+				await signalRepository.lidMapping.storeLIDPNMappings(rawIdMappings)
+				logger.debug({ count: rawIdMappings.length }, 'stored LID-PN mappings from raw_id pairing')
+			}
+
 			const meId = authState.creds.me?.id
 			if (!meId) throw new Boom('Not authenticated', { statusCode: 401 })
 			const meLid = authState.creds.me?.lid || ''
@@ -599,6 +627,57 @@ export const makeMessagesSocket = (config: SocketConfig) => {
 		return patchedMessage
 	}
 
+	const encryptPatchedMessageForRecipient = async ({
+		jid,
+		patchedMessage,
+		dsmMessage,
+		meId,
+		meLid,
+		meLidUser,
+		extraAttrs,
+		onPkmsg
+	}: {
+		jid: string
+		patchedMessage: proto.IMessage
+		dsmMessage: proto.IMessage | undefined
+		meId: string
+		meLid: string | undefined
+		meLidUser: string | null | undefined
+		extraAttrs: BinaryNode['attrs'] | undefined
+		onPkmsg: () => void
+	}) => {
+		if (!jid) return null
+
+		try {
+			const msgToEncrypt = resolveDsmMessageForRecipient(jid, patchedMessage, dsmMessage, meId, meLid, meLidUser)
+			const bytes = encodeWAMessage(msgToEncrypt)
+			const mutexKey = jid
+
+			return await encryptionMutex.mutex(mutexKey, async () => {
+				const { type, ciphertext } = await signalRepository.encryptMessage({ jid, data: bytes })
+
+				if (type === 'pkmsg') {
+					onPkmsg()
+				}
+
+				return {
+					tag: 'to',
+					attrs: { jid },
+					content: [
+						{
+							tag: 'enc',
+							attrs: { v: '2', type, ...(extraAttrs || {}) },
+							content: ciphertext
+						}
+					]
+				} as BinaryNode
+			})
+		} catch (err) {
+			logger.error({ jid, err }, 'Failed to encrypt for recipient')
+			return null
+		}
+	}
+
 	const createParticipantNodes = async (
 		recipientJids: string[],
 		message: proto.IMessage,
@@ -619,42 +698,22 @@ export const makeMessagesSocket = (config: SocketConfig) => {
 		if (!meId) throw new Boom('Not authenticated', { statusCode: 401 })
 		const meLid = authState.creds.me?.lid
 		const meLidUser = meLid ? (jidDecode(meLid)?.user ?? null) : null
+		const onPkmsg = () => {
+			shouldIncludeDeviceIdentity = true
+		}
 
 		const encryptionPromises = (patchedMessages as { recipientJid: string; message: proto.IMessage }[]).map(
-			async ({ recipientJid: jid, message: patchedMessage }: { recipientJid: string; message: proto.IMessage }) => {
+			({ recipientJid: jid, message: patchedMessage }: { recipientJid: string; message: proto.IMessage }) =>
-				try {
+				encryptPatchedMessageForRecipient({
-					if (!jid) return null
+					jid,
-
+					patchedMessage,
-					const msgToEncrypt = resolveDsmMessageForRecipient(jid, patchedMessage, dsmMessage, meId, meLid, meLidUser)
+					dsmMessage,
-					const bytes = encodeWAMessage(msgToEncrypt)
+					meId,
-					const mutexKey = jid
+					meLid,
-
+					meLidUser,
-					const node = await encryptionMutex.mutex(mutexKey, async () => {
+					extraAttrs,
-						const { type, ciphertext } = await signalRepository.encryptMessage({ jid, data: bytes })
+					onPkmsg
-
+				})
-						if (type === 'pkmsg') {
-							shouldIncludeDeviceIdentity = true
-						}
-
-						return {
-							tag: 'to',
-							attrs: { jid },
-							content: [
-								{
-									tag: 'enc',
-									attrs: { v: '2', type, ...(extraAttrs || {}) },
-									content: ciphertext
-								}
-							]
-						}
-					})
-
-					return node
-				} catch (err) {
-					logger.error({ jid, err }, 'Failed to encrypt for recipient')
-					return null
-				}
-			}
 		)
 
 		const nodes = (await Promise.all(encryptionPromises)).filter(node => node !== null) as BinaryNode[]

src/Socket/newsletter.ts

@@ -123,11 +123,11 @@ export const makeNewsletterSocket = (config: SocketConfig) => {
 		},
 
 		newsletterMute: (jid: string) => {
-			return executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.xwa2_newsletter_mute_v2)
+			return executeWMexQuery({ input: { newsletter_id: jid, type: 'MUTE_ADMIN_ACTIVITY', value: 'OFF' } }, QueryIds.MUTE, XWAPaths.xwa2_newsletter_mute_v2)
 		},
 
 		newsletterUnmute: (jid: string) => {
-			return executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.xwa2_newsletter_unmute_v2)
+			return executeWMexQuery({ input: { newsletter_id: jid, type: 'MUTE_ADMIN_ACTIVITY', value: 'ON' } }, QueryIds.UNMUTE, XWAPaths.xwa2_newsletter_unmute_v2)
 		},
 
 		newsletterUpdateName: async (jid: string, name: string) => {

src/Socket/socket.ts

@@ -701,10 +701,12 @@ export const makeSocket = (config: SocketConfig) => {
 			}
 		}
 
-		// Prevent multiple concurrent uploads
+		// Prevent multiple concurrent uploads — if one is already running, wait for it and return:
+		// the concurrent upload already replenished the pool, so there is nothing left to do.
 		if (uploadPreKeysPromise) {
 			logger.debug('Pre-key upload already in progress, waiting for completion')
 			await uploadPreKeysPromise
+			return
 		}
 
 		const uploadLogic = async () => {
@@ -784,14 +786,15 @@ export const makeSocket = (config: SocketConfig) => {
 		try {
 			let count = 0
 			const preKeyCount = await getAvailablePreKeysOnServer()
-			if (preKeyCount === 0) count = INITIAL_PREKEY_COUNT
+			// How many to upload: top-up to INITIAL_PREKEY_COUNT from whatever remains on server
-			else count = MIN_PREKEY_COUNT
+			count = Math.max(0, INITIAL_PREKEY_COUNT - preKeyCount)
 			const { exists: currentPreKeyExists, currentPreKeyId } = await verifyCurrentPreKeyExists()
 
 			logger.info(`${preKeyCount} pre-keys found on server`)
 			logger.info(`Current prekey ID: ${currentPreKeyId}, exists in storage: ${currentPreKeyExists}`)
 
-			const lowServerCount = preKeyCount <= count
+			// Trigger upload when below the replenishment threshold, not when count < topUp amount
+			const lowServerCount = preKeyCount < MIN_PREKEY_COUNT
 			const missingCurrentPreKey = !currentPreKeyExists && currentPreKeyId > 0
 
 			const shouldUpload = lowServerCount || missingCurrentPreKey
@@ -1151,7 +1154,7 @@ export const makeSocket = (config: SocketConfig) => {
 		// Decrement active connections
 		decrementActiveConnections()
 
-		clearInterval(keepAliveReq)
+		clearTimeout(keepAliveReq)
 		clearTimeout(qrTimer)
 
 		// Clear offline-buffer safety timer so its callback cannot call ev.flush()
@@ -1262,8 +1265,16 @@ export const makeSocket = (config: SocketConfig) => {
 		})
 	}
 
-	const startKeepAliveRequest = () =>
+	const startKeepAliveRequest = () => {
-		(keepAliveReq = setInterval(() => {
+		// Use recursive setTimeout with ±15% jitter to match WA Desktop behaviour
+		// (WA Business Desktop: ~25-30s intervals with natural variance)
+		const scheduleNextKeepAlive = () => {
+			const jitter = keepAliveIntervalMs * 0.15
+			const delay = keepAliveIntervalMs + Math.floor((Math.random() * 2 - 1) * jitter)
+			keepAliveReq = setTimeout(onKeepAliveTick, delay)
+		}
+
+		const onKeepAliveTick = () => {
 			if (!lastDateRecv) {
 				lastDateRecv = new Date()
 			}
@@ -1275,6 +1286,7 @@ export const makeSocket = (config: SocketConfig) => {
 			*/
 			if (diff > keepAliveIntervalMs + 5000) {
 				void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }))
+				return // connection closing — do not reschedule
 			} else if (ws.isOpen) {
 				// Send keep-alive ping via sendNode() (fire-and-forget) instead of query().
 				// query() wraps the ping in the query circuit breaker — when that breaker is
@@ -1297,7 +1309,15 @@ export const makeSocket = (config: SocketConfig) => {
 			} else {
 				logger.warn('keep alive called when WS not open')
 			}
-		}, keepAliveIntervalMs))
+
+			// Do not reschedule once shutdown has started (closed set by end() on any concurrent path)
+			if (!closed) {
+				scheduleNextKeepAlive()
+			}
+		}
+
+		scheduleNextKeepAlive()
+	}
 	/** i have no idea why this exists. pls enlighten me */
 	const sendPassiveIq = (tag: 'passive' | 'active') =>
 		query({
@@ -1361,16 +1381,13 @@ export const makeSocket = (config: SocketConfig) => {
 		const pairPlatformId = isAndroid ? getPlatformId('Chrome') : getPlatformId(browser[1])
 		const pairPlatformDisplay = isAndroid ? 'Chrome (Mac OS)' : `${browser[1]} (${browser[0]})`
 
-		logger.info(
+		logger.info({
-			{
+			pairCode: pairingCode,
-				pairCode: pairingCode,
+			jid: authState.creds.me.id,
-				jid: authState.creds.me.id,
+			companionPlatformId: pairPlatformId,
-				companionPlatformId: pairPlatformId,
+			companionPlatformDisplay: pairPlatformDisplay,
-				companionPlatformDisplay: pairPlatformDisplay,
+			isAndroid,
-				isAndroid
+		}, `pair code requested | companion: ${pairPlatformDisplay} | ${isAndroid ? 'android override -> Chrome' : 'native platform'}`)
-			},
-			`pair code requested | companion: ${pairPlatformDisplay} | ${isAndroid ? 'android override -> Chrome' : 'native platform'}`
-		)
 
 		ev.emit('creds.update', authState.creds)
 		await sendNode({
@@ -1541,9 +1558,7 @@ export const makeSocket = (config: SocketConfig) => {
 	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(
+		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'}`)
-			`${isAndroid ? '\uD83D\uDCF1' : '\uD83D\uDDA5\uFE0F'} Connected to WA | ${phoneId} | platform: ${isAndroid ? 'SMB_ANDROID' : 'MACOS'} | device: ${isAndroid ? 'Android' : 'Desktop'} | platformType: ${isAndroid ? 'ANDROID_PHONE' : 'CHROME'}`
-		)
 		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/Events.ts

@@ -27,6 +27,8 @@ export type BaileysEventMap = {
 		chats: Chat[]
 		contacts: Contact[]
 		messages: WAMessage[]
+		/** Past participants for group chats (people who left/were removed). userJid is always a phone number (PN), never a LID. */
+		pastParticipants?: proto.IPastParticipants[] | null
 		isLatest?: boolean
 		progress?: number | null
 		syncType?: proto.HistorySync.HistorySyncType | null
@@ -185,6 +187,8 @@ export type BufferedEventData = {
 		chats: { [jid: string]: Chat }
 		contacts: { [jid: string]: Contact }
 		messages: { [uqId: string]: WAMessage }
+		/** Keyed by groupJid for O(1) deduplication across chunks */
+		pastParticipants: { [groupJid: string]: proto.IPastParticipant[] }
 		empty: boolean
 		isLatest: boolean
 		progress?: number | null

src/Types/Newsletter.ts

@@ -4,10 +4,10 @@ export enum XWAPaths {
 	xwa2_newsletter_view = 'xwa2_newsletter_view',
 	xwa2_newsletter_metadata = 'xwa2_newsletter',
 	xwa2_newsletter_admin_count = 'xwa2_newsletter_admin',
-	xwa2_newsletter_mute_v2 = 'xwa2_newsletter_mute_v2',
+	xwa2_newsletter_mute_v2 = 'xwa2_newsletter_update_user_setting',
-	xwa2_newsletter_unmute_v2 = 'xwa2_newsletter_unmute_v2',
+	xwa2_newsletter_unmute_v2 = 'xwa2_newsletter_update_user_setting',
-	xwa2_newsletter_follow = 'xwa2_newsletter_follow',
+	xwa2_newsletter_follow = 'xwa2_newsletter_join_v2',
-	xwa2_newsletter_unfollow = 'xwa2_newsletter_unfollow',
+	xwa2_newsletter_unfollow = 'xwa2_newsletter_leave_v2',
 	xwa2_newsletter_change_owner = 'xwa2_newsletter_change_owner',
 	xwa2_newsletter_demote = 'xwa2_newsletter_demote',
 	xwa2_newsletter_delete_v2 = 'xwa2_newsletter_delete_v2'
@@ -17,10 +17,10 @@ export enum QueryIds {
 	UPDATE_METADATA = '24250201037901610',
 	METADATA = '6563316087068696',
 	SUBSCRIBERS = '9783111038412085',
-	FOLLOW = '7871414976211147',
+	FOLLOW = '24404358912487870',
-	UNFOLLOW = '7238632346214362',
+	UNFOLLOW = '9767147403369991',
-	MUTE = '29766401636284406',
+	MUTE = '31938993655691868',
-	UNMUTE = '9864994326891137',
+	UNMUTE = '31938993655691868',
 	ADMIN_COUNT = '7130823597031706',
 	CHANGE_OWNER = '7341777602580933',
 	DEMOTE = '6551828931592903',

src/Utils/circuit-breaker.ts

@@ -716,7 +716,7 @@ export function createConnectionCircuitBreaker(customOptions?: Partial<CircuitBr
 	const WS_LIFECYCLE_STATUS_CODES = new Set([
 		428, // connectionClosed
 		408, // connectionLost / timedOut
-		440 // connectionReplaced
+		440, // connectionReplaced
 	])
 
 	return new CircuitBreaker({

src/Utils/decode-wa-message.ts

@@ -13,7 +13,7 @@ import {
 	isJidNewsletter,
 	isJidStatusBroadcast,
 	isLidUser,
-	isPnUser
+	isPnUser,
 	//	transferDevice
 } from '../WABinary'
 import { unpadRandomMax16 } from './generics'
@@ -274,7 +274,7 @@ export const decryptMessageNode = (
 	meId: string,
 	meLid: string,
 	repository: SignalRepositoryWithLIDStore,
-	logger: ILogger
+	logger: ILogger,
 ) => {
 	const { fullMessage, author, sender } = decodeMessageNode(stanza, meId, meLid)
 	return {

src/Utils/event-buffer.ts

@@ -1,4 +1,5 @@
 import EventEmitter from 'events'
+import { proto } from '../../WAProto/index.js'
 import type {
 	BaileysEvent,
 	BaileysEventEmitter,
@@ -890,6 +891,7 @@ const makeBufferData = (): BufferedEventData => {
 			chats: {},
 			messages: {},
 			contacts: {},
+			pastParticipants: {},
 			isLatest: false,
 			empty: true
 		},
@@ -967,6 +969,28 @@ function append<E extends BufferableEvent>(
 				}
 			}
 
+			// Merge pastParticipants with deduplication by groupJid and by userJid within each group.
+			// Multiple HistorySync chunks can carry the same group -- we merge rather than concatenate
+			// to avoid duplicate entries in the final event delivered to the consumer.
+			for (const group of (eventData.pastParticipants ?? []) as proto.IPastParticipants[]) {
+				const groupJid = group.groupJid
+				if (!groupJid) continue
+
+				if (!data.historySets.pastParticipants[groupJid]) {
+					data.historySets.pastParticipants[groupJid] = []
+				}
+
+				const existing = data.historySets.pastParticipants[groupJid]
+				const seenJids = new Set(existing.map(p => p.userJid).filter(Boolean))
+
+				for (const participant of (group.pastParticipants ?? []) as proto.IPastParticipant[]) {
+					if (participant.userJid && !seenJids.has(participant.userJid)) {
+						existing.push(participant)
+						seenJids.add(participant.userJid)
+					}
+				}
+			}
+
 			data.historySets.empty = false
 			data.historySets.syncType = eventData.syncType
 			data.historySets.progress = eventData.progress
@@ -1292,6 +1316,10 @@ function consolidateEvents(data: BufferedEventData) {
 			chats: Object.values(data.historySets.chats),
 			messages: Object.values(data.historySets.messages),
 			contacts: Object.values(data.historySets.contacts),
+			// Convert dedup map back to array. Each entry has groupJid + participants (all unique userJids).
+			pastParticipants: Object.entries(data.historySets.pastParticipants).map(
+				([groupJid, participants]) => ({ groupJid, pastParticipants: participants })
+			),
 			syncType: data.historySets.syncType,
 			progress: data.historySets.progress,
 			isLatest: data.historySets.isLatest,

src/Utils/generics.ts

@@ -246,7 +246,6 @@ export const fetchLatestBaileysVersion = async (options: RequestInit & { timeout
 		} finally {
 			clearTimeout(timeout)
 		}
-
 		if (!response.ok) {
 			throw new Boom(`Failed to fetch latest Baileys version: ${response.statusText}`, { statusCode: response.status })
 		}

src/Utils/history.ts

@@ -15,7 +15,8 @@ import {
 import { toNumber } from './generics'
 import type { ILogger } from './logger.js'
 import { normalizeMessageContent } from './messages'
-import { downloadContentFromMessage } from './messages-media'
+import { DEFAULT_ORIGIN } from '../Defaults'
+import { downloadContentFromMessage, getUrlFromDirectPath } from './messages-media'
 
 const inflatePromise = promisify(inflate)
 
@@ -374,10 +375,25 @@ export const processHistoryMessage = (item: proto.IHistorySync, logger?: ILogger
 	// Convert Map back to array for return
 	const lidPnMappings = Array.from(lidPnMap.values())
 
+	// Normalize pastParticipants: resolve LID userJids → PN so the consumer always
+	// receives a phone number, never an opaque LID identifier.
+	// Uses the lidPnMap built above (populated from phoneNumberToLidMappings + conversations).
+	// If a LID cannot be resolved, the original value is kept rather than dropping the participant.
+	const pastParticipants: proto.IPastParticipants[] = (item.pastParticipants ?? []).map(group => ({
+		groupJid: group.groupJid,
+		pastParticipants: (group.pastParticipants ?? []).map(participant => {
+			const userJid = participant.userJid
+			if (!userJid || !isAnyLidUser(userJid)) return participant
+			const mapping = lidPnMap.get(jidNormalizedUser(userJid))
+			return mapping?.pn ? { ...participant, userJid: mapping.pn } : participant
+		})
+	}))
+
 	return {
 		chats,
 		contacts,
 		messages,
+		pastParticipants,
 		lidPnMappings,
 		syncType: item.syncType,
 		progress: item.progress
@@ -408,7 +424,23 @@ export const downloadAndProcessHistorySyncNotification = async (
 		historyMsg = await downloadHistory(msg, options)
 	}
 
-	return processHistoryMessage(historyMsg, logger)
+	const result = processHistoryMessage(historyMsg, logger)
+
+	// Mirror WA Desktop behaviour: DELETE the CDN blob only after processing succeeds.
+	// Doing this earlier (e.g. inside downloadHistory) risks permanent history loss if
+	// processing throws — the server copy would be gone and retry after reconnect would fail.
+	if (msg.directPath) {
+		const cdnUrl = getUrlFromDirectPath(msg.directPath)
+		fetch(cdnUrl, {
+			...options,
+			method: 'DELETE',
+			headers: { ...((options as RequestInit).headers ?? {}), Origin: DEFAULT_ORIGIN }
+		}).catch(() => {
+			// non-fatal — server will expire it anyway
+		})
+	}
+
+	return result
 }
 
 /**

src/Utils/messages.ts

@@ -45,8 +45,8 @@ import {
 	generateThumbnail,
 	getAudioDuration,
 	getAudioWaveform,
-	getRawMediaUploadData,
 	getStream,
+	getRawMediaUploadData,
 	type MediaDownloadOptions
 } from './messages-media'
 import { shouldIncludeReportingToken } from './reporting-utils'
@@ -635,6 +635,59 @@ export const generateCarouselMessage = async (
 		)
 	}
 
+	const recoverCarouselImageMetadata = async (
+		imageMessage: proto.Message.IImageMessage | null | undefined,
+		cardImage: WAMediaUpload,
+		cardTitle: string | undefined,
+		uploadOptions: MessageContentGenerationOptions
+	) => {
+		if (!imageMessage) {
+			return
+		}
+
+		const missingThumbnail = !imageMessage.jpegThumbnail
+		const missingWidth = !imageMessage.width
+		const missingHeight = !imageMessage.height
+		if (!missingThumbnail && !missingWidth && !missingHeight) {
+			return
+		}
+
+		try {
+			const { stream } = await getStream(cardImage, uploadOptions.options)
+			const { buffer, original } = await extractImageThumb(stream)
+
+			if (missingThumbnail) {
+				imageMessage.jpegThumbnail = buffer.toString('base64')
+			}
+
+			if (missingWidth && original.width) {
+				imageMessage.width = original.width
+			}
+
+			if (missingHeight && original.height) {
+				imageMessage.height = original.height
+			}
+
+			uploadOptions.logger?.info(
+				{
+					cardTitle,
+					recoveredThumbnail: !!imageMessage.jpegThumbnail,
+					width: imageMessage.width,
+					height: imageMessage.height
+				},
+				'[CAROUSEL] Recovered image metadata from source media'
+			)
+		} catch (error) {
+			uploadOptions.logger?.warn(
+				{
+					cardTitle,
+					trace: error instanceof Error ? error.stack : String(error)
+				},
+				'[CAROUSEL] Failed source-media thumbnail fallback'
+			)
+		}
+	}
+
 	// Map cards to the carousel format (processing media)
 	const carouselCards = await Promise.all(
 		cards.map(async card => {
@@ -653,45 +706,7 @@ export const generateCarouselMessage = async (
 
 					// Mirror the working Pastorini-style result: every carousel image card should
 					// carry a jpegThumbnail and dimensions before it reaches the Web live renderer.
-					if (imageMessage && (!imageMessage.jpegThumbnail || !imageMessage.height || !imageMessage.width)) {
+					await recoverCarouselImageMetadata(imageMessage, card.image, card.title, mediaOptions)
-						try {
-							const { stream } = await getStream(card.image, mediaOptions.options)
-							const { buffer, original } = await extractImageThumb(stream)
-
-							// eslint-disable-next-line max-depth
-							if (!imageMessage.jpegThumbnail) {
-								imageMessage.jpegThumbnail = buffer.toString('base64')
-							}
-
-							// eslint-disable-next-line max-depth
-							if (!imageMessage.width && original.width) {
-								imageMessage.width = original.width
-							}
-
-							// eslint-disable-next-line max-depth
-							if (!imageMessage.height && original.height) {
-								imageMessage.height = original.height
-							}
-
-							mediaOptions.logger?.info(
-								{
-									cardTitle: card.title,
-									recoveredThumbnail: !!imageMessage.jpegThumbnail,
-									width: imageMessage.width,
-									height: imageMessage.height
-								},
-								'[CAROUSEL] Recovered image metadata from source media'
-							)
-						} catch (error) {
-							mediaOptions.logger?.warn(
-								{
-									cardTitle: card.title,
-									trace: error instanceof Error ? error.stack : String(error)
-								},
-								'[CAROUSEL] Failed source-media thumbnail fallback'
-							)
-						}
-					}
 
 					// Validate image fields needed for WhatsApp rendering
 					if (imageMessage && !imageMessage.jpegThumbnail) {

src/Utils/process-message.ts

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import Long from 'long'
 import { proto } from '../../WAProto/index.js'
-import type { LIDMappingStore } from '../Signal/lid-mapping'
 import type {
 	AuthenticationCreds,
 	BaileysEventEmitter,
@@ -20,6 +19,7 @@ import type {
 	WAMessage,
 	WAMessageKey
 } from '../Types'
+import type { LIDMappingStore } from '../Signal/lid-mapping'
 import { WAMessageStubType } from '../Types'
 import { getContentType, normalizeMessageContent } from '../Utils/messages'
 import {
@@ -784,8 +784,7 @@ const processMessage = async (
 			})
 		}
 
-		const participantsIncludesMe = () =>
+		const participantsIncludesMe = () => participants.find(p => areJidsSameUser(meId, p.id) || areJidsSameUser(meId, p.phoneNumber))
-			participants.find(p => areJidsSameUser(meId, p.id) || areJidsSameUser(meId, p.phoneNumber))
 
 		switch (message.messageStubType) {
 			case WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER:

src/Utils/sticker-pack.ts

@@ -2,7 +2,7 @@ import { Boom } from '@hapi/boom'
 import { createHash } from 'crypto'
 import { zipSync } from 'fflate'
 import { promises as fs } from 'fs'
-import { gunzipSync, gzipSync } from 'zlib'
+import { gzipSync, gunzipSync } from 'zlib'
 import { proto } from '../../WAProto/index.js'
 import type { MediaType } from '../Defaults/index.js'
 import type { StickerPack, WAMediaUpload, WAMediaUploadFunction } from '../Types/Message.js'
@@ -728,9 +728,10 @@ export const prepareStickerPackMessage = async (
 		// Tray icon uses PNG format, 96x96 pixels (official client standard)
 		const lib = await getImageProcessingLibrary()
 		if (!lib?.sharp) {
-			throw new Boom('Sharp library is required for cover/tray icon processing. Install with: yarn add sharp', {
+			throw new Boom(
-				statusCode: 400
+				'Sharp library is required for cover/tray icon processing. Install with: yarn add sharp',
-			})
+				{ statusCode: 400 }
+			)
 		}
 
 		coverWebP = await lib.sharp

src/WAUSync/USyncQuery.ts

@@ -10,7 +10,7 @@ import {
 } from './Protocols'
 import { USyncUser } from './USyncUser'
 
-export type USyncQueryResultList = { [protocol: string]: unknown; id: string }
+export type USyncQueryResultList = { [protocol: string]: unknown; id: string; rawId?: number }
 
 export type USyncQueryResult = {
 	list: USyncQueryResultList[]
@@ -68,10 +68,8 @@ export class USyncQuery {
 		//TODO: see if there are any errors in the result node
 		//const resultNode = getBinaryNodeChild(usyncNode, 'result')
 
-		const listNode = usyncNode ? getBinaryNodeChild(usyncNode, 'list') : undefined
+		const parseNodeList = (content: BinaryNode[]): USyncQueryResultList[] =>
-
+			content.reduce((acc: USyncQueryResultList[], node) => {
-		if (listNode?.content && Array.isArray(listNode.content)) {
-			queryResult.list = listNode.content.reduce((acc: USyncQueryResultList[], node) => {
 				const id = node?.attrs.jid
 				if (id) {
 					const data = Array.isArray(node?.content)
@@ -89,15 +87,24 @@ export class USyncQuery {
 									.filter(([, b]) => b !== null) as [string, unknown][]
 							)
 						: {}
-					acc.push({ ...data, id })
+					const rawIdAttr = node?.attrs?.['raw_id']
+					const rawId = rawIdAttr !== undefined ? Number(rawIdAttr) : undefined
+					acc.push({ ...data, id, ...(rawId !== undefined && !isNaN(rawId) ? { rawId } : {}) })
 				}
 
 				return acc
 			}, [])
+
+		const listNode = usyncNode ? getBinaryNodeChild(usyncNode, 'list') : undefined
+		if (listNode?.content && Array.isArray(listNode.content)) {
+			queryResult.list = parseNodeList(listNode.content)
+		}
+
+		const sideListNode = usyncNode ? getBinaryNodeChild(usyncNode, 'side_list') : undefined
+		if (sideListNode?.content && Array.isArray(sideListNode.content)) {
+			queryResult.sideList = parseNodeList(sideListNode.content)
 		}
 
-		//TODO: implement side list
-		//const sideListNode = getBinaryNodeChild(usyncNode, 'side_list')
 		return queryResult
 	}