@badzz88/baileys 8.5.6 → 8.5.7

package/lib/Socket/messages-recv.js

@@ -0,0 +1,2442 @@
+'use strict'
+var __importDefault =
+	(this && this.__importDefault) ||
+	function (mod) {
+		return mod && mod.__esModule ? mod : { default: mod }
+	}
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.makeMessagesRecvSocket = void 0
+const node_cache_1 = __importDefault(require('@cacheable/node-cache'))
+const boom_1 = require('@hapi/boom')
+const crypto_1 = require('crypto')
+const index_js_1 = require('../../WAProto/index.js')
+const Defaults_1 = require('../Defaults')
+const Types_1 = require('../Types')
+const Utils_1 = require('../Utils')
+const jid_display_normalization_1 = require('../Utils/jid-display-normalization')
+const make_mutex_1 = require('../Utils/make-mutex')
+const offline_node_processor_1 = require('../Utils/offline-node-processor')
+const stanza_ack_1 = require('../Utils/stanza-ack')
+const tc_token_utils_1 = require('../Utils/tc-token-utils')
+const WABinary_1 = require('../WABinary')
+const groups_1 = require('./groups')
+const aigroup_1 = require('./aigroups')
+const messages_send_1 = require('./messages-send')
+
+const makeMessagesRecvSocket = config => {
+	const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid, enableAutoSessionRecreation } =
+		config
+	const sock = (0, messages_send_1.makeMessagesSocket)(config)
+	const {
+		ev,
+		authState,
+		ws,
+		messageMutex,
+		notificationMutex,
+		receiptMutex,
+		signalRepository,
+		query,
+		upsertMessage,
+		getUSyncDevices,
+		createParticipantNodes,
+		resyncAppState,
+		onUnexpectedError,
+		assertSessions,
+		sendNode,
+		relayMessage,
+		sendReceipt,
+		uploadPreKeys,
+		sendPeerDataOperationMessage,
+		messageRetryManager,
+		issuePrivacyTokens
+	} = sock
+	const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping)
+	// Track when the socket fully opens so pending pre-connect messages are treated as history
+	const socketCreatedAt = Math.floor(Date.now() / 1000)
+	let isConnected = false
+	/** this mutex ensures that each retryRequest will wait for the previous one to finish */
+	const retryMutex = (0, make_mutex_1.makeMutex)()
+	const msgRetryCache =
+		config.msgRetryCounterCache ||
+		new node_cache_1.default({
+			stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
+			useClones: false
+		})
+	const callOfferCache =
+		config.callOfferCache ||
+		new node_cache_1.default({
+			stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.CALL_OFFER, // 5 mins
+			useClones: false
+		})
+	const placeholderResendCache =
+		config.placeholderResendCache ||
+		new node_cache_1.default({
+			stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
+			useClones: false
+		})
+	// Debounce identity-change session refreshes per JID to avoid bursts
+	const identityAssertDebounce = new node_cache_1.default({ stdTTL: 5, useClones: false })
+	let sendActiveReceipts = false
+	const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
+		if (!authState.creds.me?.id) {
+			throw new boom_1.Boom('Not authenticated')
+		}
+		const pdoMessage = {
+			historySyncOnDemandRequest: {
+				chatJid: oldestMsgKey.remoteJid,
+				oldestMsgFromMe: oldestMsgKey.fromMe,
+				oldestMsgId: oldestMsgKey.id,
+				oldestMsgTimestampMs: oldestMsgTimestamp,
+				onDemandMsgCount: count
+			},
+			peerDataOperationRequestType: index_js_1.proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND
+		}
+		return sendPeerDataOperationMessage(pdoMessage)
+	}
+	const requestPlaceholderResend = async (messageKey, msgData) => {
+		if (!authState.creds.me?.id) {
+			throw new boom_1.Boom('Not authenticated')
+		}
+		if (await placeholderResendCache.get(messageKey?.id)) {
+			logger.debug({ messageKey }, 'already requested resend')
+			return
+		} else {
+			// Store original message data so PDO response handler can preserve
+			// metadata (LID details, timestamps, etc.) that the phone may omit
+			await placeholderResendCache.set(messageKey?.id, msgData || true)
+		}
+		await (0, Utils_1.delay)(2000)
+		if (!(await placeholderResendCache.get(messageKey?.id))) {
+			logger.debug({ messageKey }, 'message received while resend requested')
+			return 'RESOLVED'
+		}
+		const pdoMessage = {
+			placeholderMessageResendRequest: [
+				{
+					messageKey
+				}
+			],
+			peerDataOperationRequestType: index_js_1.proto.Message.PeerDataOperationRequestType.PLACEHOLDER_MESSAGE_RESEND
+		}
+		setTimeout(async () => {
+			if (await placeholderResendCache.get(messageKey?.id)) {
+				logger.debug({ messageKey }, 'PDO message without response after 8 seconds. Phone possibly offline')
+				await placeholderResendCache.del(messageKey?.id)
+			}
+		}, 8000)
+		return sendPeerDataOperationMessage(pdoMessage)
+	}
+	/**
+	 * Request a Waffle (Meta-account) linking nonce from the paired phone.
+	 * The phone responds via a PeerDataOperationRequestResponseMessage containing
+	 * a WaffleNonceFetchResponse with the nonce needed for Meta account linking.
+	 */
+	const requestWaffleNonce = async () => {
+		if (!authState.creds.me?.id) {
+			throw new boom_1.Boom('Not authenticated')
+		}
+		return sendPeerDataOperationMessage({
+			peerDataOperationRequestType: index_js_1.proto.Message.PeerDataOperationRequestType.WAFFLE_LINKING_NONCE_FETCH
+		})
+	}
+	/**
+	 * Request a Companion Canonical User nonce from the paired phone.
+	 * Used during companion linking to canonicalize the user identity across devices.
+	 * The phone responds with a CompanionCanonicalUserNonceFetchResponse (nonce + waFbid).
+	 *
+	 * @param {string} [registrationTraceId] - Optional trace ID for this registration attempt.
+	 */
+	const requestCompanionCanonicalNonce = async (registrationTraceId) => {
+		if (!authState.creds.me?.id) {
+			throw new boom_1.Boom('Not authenticated')
+		}
+		return sendPeerDataOperationMessage({
+			companionCanonicalUserNonceFetchRequest: registrationTraceId ? { registrationTraceId } : {},
+			peerDataOperationRequestType: index_js_1.proto.Message.PeerDataOperationRequestType.COMPANION_CANONICAL_USER_NONCE_FETCH
+		})
+	}
+	/**
+	 * Request a Companion Meta nonce from the paired phone.
+	 * Used during Meta-account companion linking flow.
+	 * The phone responds with a CompanionMetaNonceFetchResponse (nonce).
+	 */
+	const requestCompanionMetaNonce = async () => {
+		if (!authState.creds.me?.id) {
+			throw new boom_1.Boom('Not authenticated')
+		}
+		return sendPeerDataOperationMessage({
+			peerDataOperationRequestType: index_js_1.proto.Message.PeerDataOperationRequestType.COMPANION_META_NONCE_FETCH
+		})
+	}
+	// Handles mex newsletter notifications
+	const handleMexNewsletterNotification = async node => {
+		const mexNode = (0, WABinary_1.getBinaryNodeChild)(node, 'mex')
+		if (!mexNode?.content) {
+			logger.warn({ node }, 'Invalid mex newsletter notification')
+			return
+		}
+		let data
+		try {
+			data = JSON.parse(mexNode.content.toString())
+		} catch (error) {
+			logger.error({ err: error, node }, 'Failed to parse mex newsletter notification')
+			return
+		}
+		const operation = data?.operation
+		const updates = data?.updates
+		if (!updates || !operation) {
+			logger.warn({ data }, 'Invalid mex newsletter notification content')
+			return
+		}
+		logger.info({ operation, updates }, 'got mex newsletter notification')
+		switch (operation) {
+			case 'NotificationNewsletterUpdate':
+				for (const update of updates) {
+					if (update.jid && update.settings && Object.keys(update.settings).length > 0) {
+						ev.emit('newsletter-settings.update', {
+							id: update.jid,
+							update: update.settings
+						})
+					}
+				}
+				break
+			case 'NotificationNewsletterAdminPromote':
+				for (const update of updates) {
+					if (update.jid && update.user) {
+						ev.emit('newsletter-participants.update', {
+							id: update.jid,
+							author: node.attrs.from,
+							user: update.user,
+							new_role: 'ADMIN',
+							action: 'promote'
+						})
+					}
+				}
+				break
+			default:
+				logger.info({ operation, data }, 'Unhandled mex newsletter notification')
+				break
+		}
+	}
+	// Handles newsletter notifications
+	const handleNewsletterNotification = async node => {
+		const from = node.attrs.from
+		const child = (0, WABinary_1.getAllBinaryNodeChildren)(node)[0]
+		const author = node.attrs.participant
+		logger.info({ from, child }, 'got newsletter notification')
+		switch (child.tag) {
+			case 'reaction':
+				const reactionUpdate = {
+					id: from,
+					server_id: child.attrs.message_id,
+					reaction: {
+						code: (0, WABinary_1.getBinaryNodeChildString)(child, 'reaction'),
+						count: 1
+					}
+				}
+				ev.emit('newsletter.reaction', reactionUpdate)
+				break
+			case 'view':
+				const viewUpdate = {
+					id: from,
+					server_id: child.attrs.message_id,
+					count: parseInt(child.content?.toString() || '0', 10)
+				}
+				ev.emit('newsletter.view', viewUpdate)
+				break
+			case 'participant':
+				const participantUpdate = {
+					id: from,
+					author,
+					user: child.attrs.jid,
+					action: child.attrs.action,
+					new_role: child.attrs.role
+				}
+				ev.emit('newsletter-participants.update', participantUpdate)
+				break
+			case 'update':
+				const settingsNode = (0, WABinary_1.getBinaryNodeChild)(child, 'settings')
+				if (settingsNode) {
+					const update = {}
+					const nameNode = (0, WABinary_1.getBinaryNodeChild)(settingsNode, 'name')
+					if (nameNode?.content) update.name = nameNode.content.toString()
+					const descriptionNode = (0, WABinary_1.getBinaryNodeChild)(settingsNode, 'description')
+					if (descriptionNode?.content) update.description = descriptionNode.content.toString()
+					ev.emit('newsletter-settings.update', {
+						id: from,
+						update
+					})
+				}
+				break
+			case 'message':
+				const plaintextNode = (0, WABinary_1.getBinaryNodeChild)(child, 'plaintext')
+				if (plaintextNode?.content) {
+					try {
+						const contentBuf =
+							typeof plaintextNode.content === 'string'
+								? Buffer.from(plaintextNode.content, 'binary')
+								: Buffer.from(plaintextNode.content)
+						const messageProto = index_js_1.proto.Message.decode(contentBuf).toJSON()
+						const fullMessage = index_js_1.proto.WebMessageInfo.fromObject({
+							key: {
+								remoteJid: from,
+								id: child.attrs.message_id || child.attrs.server_id,
+								fromMe: false // TODO: is this really true though
+							},
+							message: messageProto,
+							messageTimestamp: +child.attrs.t
+						}).toJSON()
+						await upsertMessage(fullMessage, 'append')
+						logger.info('Processed plaintext newsletter message')
+					} catch (error) {
+						logger.error({ error }, 'Failed to decode plaintext newsletter message')
+					}
+				}
+				break
+			case 'live_updates':
+				// Live view count / engagement update
+				const liveCount = parseInt(child.attrs.count || child.content?.toString() || '0', 10)
+				ev.emit('newsletter.live-update', {
+					id: from,
+					server_id: child.attrs.message_id || child.attrs.server_id,
+					liveViewers: liveCount,
+					timestamp: child.attrs.t ? +child.attrs.t : undefined
+				})
+				break
+			case 'pin':
+				ev.emit('newsletter.pin', {
+					id: from,
+					server_id: child.attrs.message_id || child.attrs.server_id,
+					pinned: child.attrs.action !== 'unpin'
+				})
+				break
+			case 'category':
+				ev.emit('newsletter-settings.update', {
+					id: from,
+					update: { category: child.attrs.value || child.content?.toString() }
+				})
+				break
+			case 'invite':
+				ev.emit('newsletter.invite', {
+					id: from,
+					inviteCode: child.attrs.code,
+					inviter: child.attrs.jid || author,
+					role: child.attrs.role || 'SUBSCRIBER'
+				})
+				break
+			default:
+				logger.warn({ node }, 'Unknown newsletter notification')
+				break
+		}
+	}
+	const sendMessageAck = async (node, errorCode) => {
+		const stanza = (0, stanza_ack_1.buildAckStanza)(node, errorCode, authState.creds.me.id)
+		logger.debug({ recv: { tag: node.tag, attrs: node.attrs }, sent: stanza.attrs }, 'sent ack')
+		await sendNode(stanza)
+	}
+
+	const offerCall = async (toJid, isVideo = false) => {
+		const callId = crypto_1.randomBytes(16).toString('hex').toUpperCase().substring(0, 64)
+		const offerContent = []
+		offerContent.push({
+			tag: 'audio',
+			attrs: { enc: 'opus', rate: '16000' },
+			content: undefined
+		})
+		offerContent.push({
+			tag: 'audio',
+			attrs: { enc: 'opus', rate: '8000' },
+			content: undefined
+		})
+
+		if (isVideo) {
+			offerContent.push({
+				tag: 'video',
+				attrs: {
+					enc: 'vp8',
+					dec: 'vp8',
+					orientation: '0',
+					screen_width: '1920',
+					screen_height: '1080',
+					device_orientation: '0'
+				},
+				content: undefined
+			})
+		}
+		offerContent.push({
+			tag: 'net',
+			attrs: { medium: '3' },
+			content: undefined
+		})
+		offerContent.push({
+			tag: 'capability',
+			attrs: { ver: '1' },
+			content: new Uint8Array([1, 4, 255, 131, 207, 4])
+		})
+		offerContent.push({
+			tag: 'encopt',
+			attrs: { keygen: '2' },
+			content: undefined
+		})
+
+		const encKey = crypto_1.randomBytes(32)
+		const devices = (await getUSyncDevices([toJid], true, false)).map(({ user, device }) =>
+			WABinary_1.jidEncode(user, 's.whatsapp.net', device)
+		)
+		await assertSessions(devices, true)
+
+		const { nodes: destinations, shouldIncludeDeviceIdentity } = await createParticipantNodes(
+			devices,
+			{
+				call: {
+					callKey: new Uint8Array(encKey)
+				}
+			},
+			{ count: '0' }
+		)
+		offerContent.push({ tag: 'destination', attrs: {}, content: destinations })
+
+		if (shouldIncludeDeviceIdentity) {
+			offerContent.push({
+				tag: 'device-identity',
+				attrs: {},
+				content: Utils_1.encodeSignedDeviceIdentity(authState.creds.account, true)
+			})
+		}
+
+		const stanza = {
+			tag: 'call',
+			attrs: {
+				id: Utils_1.generateMessageID(),
+				to: toJid
+			},
+			content: [
+				{
+					tag: 'offer',
+					attrs: {
+						'call-id': callId,
+						'call-creator': authState.creds.me.id
+					},
+					content: offerContent
+				}
+			]
+		}
+
+		await query(stanza)
+
+		return {
+			id: callId,
+			to: toJid
+		}
+	}
+
+	const rejectCall = async (callId, callFrom) => {
+		const stanza = {
+			tag: 'call',
+			attrs: {
+				from: authState.creds.me.id,
+				to: callFrom
+			},
+			content: [
+				{
+					tag: 'reject',
+					attrs: {
+						'call-id': callId,
+						'call-creator': callFrom,
+						count: '0'
+					},
+					content: undefined
+				}
+			]
+		}
+		await query(stanza)
+	}
+
+	const acceptCall = async (callId, callFrom) => {
+		const stanza = {
+			tag: 'call',
+			attrs: {
+				from: authState.creds.me.id,
+				to: callFrom
+			},
+			content: [
+				{
+					tag: 'accept',
+					attrs: {
+						'call-id': callId,
+						'call-creator': callFrom,
+						count: '0'
+					},
+					content: undefined
+				}
+			]
+		}
+		await query(stanza)
+	}
+
+	const terminateCall = async (callId, callFrom) => {
+		const stanza = {
+			tag: 'call',
+			attrs: {
+				from: authState.creds.me.id,
+				to: callFrom
+			},
+			content: [
+				{
+					tag: 'terminate',
+					attrs: {
+						'call-id': callId,
+						'call-creator': callFrom,
+						reason: 'user-terminated',
+						count: '0'
+					},
+					content: undefined
+				}
+			]
+		}
+		await query(stanza)
+	}
+
+	/**
+	 * Re-encrypt call key for a device that reconnected mid-call.
+	 * Source: OutgoingSignalingHandler.java enc_rekey / rekeyEncryptionTask
+	 *
+	 * @param {string} callId - Active call ID
+	 * @param {string} callFrom - JID of the call creator
+	 * @param {Buffer} encryptedKeyBytes - Re-encrypted call session key bytes
+	 * @param {number} [count=0] - Retry counter (0–4)
+	 */
+	const rekeyCall = async (callId, callFrom, encryptedKeyBytes, count = 0) => {
+		const stanza = {
+			tag: 'call',
+			attrs: {
+				from: authState.creds.me.id,
+				to: callFrom
+			},
+			content: [
+				{
+					tag: 'enc_rekey',
+					attrs: {
+						'call-id': callId,
+						'call-creator': callFrom,
+						count: count.toString()
+					},
+					content: [
+						{
+							tag: 'enc',
+							attrs: { v: '2', type: 'msg' },
+							content: encryptedKeyBytes
+						}
+					]
+				}
+			]
+		}
+		await query(stanza)
+	}
+
+	/**
+	 * Join a call via an invite link.
+	 * Source: OutgoingSignalingHandler.java link_join tag
+	 *
+	 * @param {string} callId - Call ID from the link
+	 * @param {string} callCreator - JID of the call creator
+	 * @param {string} linkToken - Token from the call link
+	 */
+	const joinCallLink = async (callId, callCreator, linkToken) => {
+		const stanza = {
+			tag: 'call',
+			attrs: {
+				from: authState.creds.me.id,
+				to: callCreator
+			},
+			content: [
+				{
+					tag: 'link_join',
+					attrs: {
+						'call-id': callId,
+						'call-creator': callCreator,
+						token: linkToken
+					},
+					content: undefined
+				}
+			]
+		}
+		await query(stanza)
+	}
+
+	/**
+	 * Query info about a call link before joining.
+	 * Source: OutgoingSignalingHandler.java link_query tag
+	 *
+	 * @param {string} callLinkCode - The call link code to query
+	 * @param {string} to - JID to send the query to
+	 */
+	const queryCallLink = async (callLinkCode, to) => {
+		const stanza = {
+			tag: 'call',
+			attrs: {
+				from: authState.creds.me.id,
+				to
+			},
+			content: [
+				{
+					tag: 'link_query',
+					attrs: { code: callLinkCode },
+					content: undefined
+				}
+			]
+		}
+		return query(stanza)
+	}
+	const sendRetryRequest = async (node, forceIncludeKeys = false) => {
+		const { fullMessage } = (0, Utils_1.decodeMessageNode)(node, authState.creds.me.id, authState.creds.me.lid || '')
+		const { key: msgKey } = fullMessage
+		const msgId = msgKey.id
+		if (messageRetryManager) {
+			// Check if we've exceeded max retries using the new system
+			if (messageRetryManager.hasExceededMaxRetries(msgId)) {
+				logger.debug({ msgId }, 'reached retry limit with new retry manager, clearing')
+				messageRetryManager.markRetryFailed(msgId)
+				return
+			}
+			// Increment retry count using new system
+			const retryCount = messageRetryManager.incrementRetryCount(msgId)
+			// Use the new retry count for the rest of the logic
+			const key = `${msgId}:${msgKey?.participant}`
+			await msgRetryCache.set(key, retryCount)
+		} else {
+			// Fallback to old system
+			const key = `${msgId}:${msgKey?.participant}`
+			let retryCount = (await msgRetryCache.get(key)) || 0
+			if (retryCount >= maxMsgRetryCount) {
+				logger.debug({ retryCount, msgId }, 'reached retry limit, clearing')
+				await msgRetryCache.del(key)
+				return
+			}
+			retryCount += 1
+			await msgRetryCache.set(key, retryCount)
+		}
+		const key = `${msgId}:${msgKey?.participant}`
+		const retryCount = (await msgRetryCache.get(key)) || 1
+		const { account, signedPreKey, signedIdentityKey: identityKey } = authState.creds
+		const fromJid = node.attrs.from
+		// Check if we should recreate the session
+		let shouldRecreateSession = false
+		let recreateReason = ''
+		if (enableAutoSessionRecreation && messageRetryManager && retryCount > 1) {
+			try {
+				// Check if we have a session with this JID
+				const sessionId = signalRepository.jidToSignalProtocolAddress(fromJid)
+				const hasSession = await signalRepository.validateSession(fromJid)
+				const result = messageRetryManager.shouldRecreateSession(fromJid, hasSession.exists)
+				shouldRecreateSession = result.recreate
+				recreateReason = result.reason
+				if (shouldRecreateSession) {
+					logger.debug({ fromJid, retryCount, reason: recreateReason }, 'recreating session for retry')
+					// Delete existing session to force recreation
+					await authState.keys.set({ session: { [sessionId]: null } })
+					forceIncludeKeys = true
+				}
+			} catch (error) {
+				logger.warn({ error, fromJid }, 'failed to check session recreation')
+			}
+		}
+		if (retryCount <= 2) {
+			// Use new retry manager for phone requests if available
+			if (messageRetryManager) {
+				// Schedule phone request with delay (like whatsmeow)
+				messageRetryManager.schedulePhoneRequest(msgId, async () => {
+					try {
+						const requestId = await requestPlaceholderResend(msgKey)
+						logger.debug(
+							`sendRetryRequest: requested placeholder resend (${requestId}) for message ${msgId} (scheduled)`
+						)
+					} catch (error) {
+						logger.warn({ error, msgId }, 'failed to send scheduled phone request')
+					}
+				})
+			} else {
+				// Fallback to immediate request
+				const msgId = await requestPlaceholderResend(msgKey)
+				logger.debug(`sendRetryRequest: requested placeholder resend for message ${msgId}`)
+			}
+		}
+		const deviceIdentity = (0, Utils_1.encodeSignedDeviceIdentity)(account, true)
+		await authState.keys.transaction(async () => {
+			const receipt = {
+				tag: 'receipt',
+				attrs: {
+					id: msgId,
+					type: 'retry',
+					to: node.attrs.from
+				},
+				content: [
+					{
+						tag: 'retry',
+						attrs: {
+							count: retryCount.toString(),
+							id: node.attrs.id,
+							t: node.attrs.t,
+							v: '1',
+							// ADD ERROR FIELD
+							error: '0'
+						}
+					},
+					{
+						tag: 'registration',
+						attrs: {},
+						content: (0, Utils_1.encodeBigEndian)(authState.creds.registrationId)
+					}
+				]
+			}
+			if (node.attrs.recipient) {
+				receipt.attrs.recipient = node.attrs.recipient
+			}
+			if (node.attrs.participant) {
+				receipt.attrs.participant = node.attrs.participant
+			}
+			if (retryCount > 1 || forceIncludeKeys || shouldRecreateSession) {
+				const { update, preKeys } = await (0, Utils_1.getNextPreKeys)(authState, 1)
+				const [keyId] = Object.keys(preKeys)
+				const key = preKeys[+keyId]
+				const content = receipt.content
+				content.push({
+					tag: 'keys',
+					attrs: {},
+					content: [
+						{ tag: 'type', attrs: {}, content: Buffer.from(Defaults_1.KEY_BUNDLE_TYPE) },
+						{ tag: 'identity', attrs: {}, content: identityKey.public },
+						(0, Utils_1.xmppPreKey)(key, +keyId),
+						(0, Utils_1.xmppSignedPreKey)(signedPreKey),
+						{ tag: 'device-identity', attrs: {}, content: deviceIdentity }
+					]
+				})
+				ev.emit('creds.update', update)
+			}
+			await sendNode(receipt)
+			logger.info({ msgAttrs: node.attrs, retryCount }, 'sent retry receipt')
+		}, authState?.creds?.me?.id || 'sendRetryRequest')
+	}
+	/**
+	 * Fire-and-forget tctoken re-issuance after a peer's device identity changed.
+	 * Runs in parallel with the session refresh (not after it).
+	 */
+	const reissueTcTokenAfterIdentityChange = from => {
+		void (async () => {
+			const normalizedJid = (0, WABinary_1.jidNormalizedUser)(from)
+			const tcJid = await (0, tc_token_utils_1.resolveTcTokenJid)(normalizedJid, getLIDForPN)
+			const tcTokenData = await authState.keys.get('tctoken', [tcJid])
+			const senderTs = tcTokenData?.[tcJid]?.senderTimestamp
+			if (senderTs === null || senderTs === undefined || (0, tc_token_utils_1.isTcTokenExpired)(senderTs)) {
+				return
+			}
+			logger.debug({ jid: normalizedJid, senderTimestamp: senderTs }, 'identity changed, re-issuing tctoken')
+			const getPNForLID = signalRepository.lidMapping.getPNForLID.bind(signalRepository.lidMapping)
+			const issueJid = await (0, tc_token_utils_1.resolveIssuanceJid)(
+				normalizedJid,
+				sock.serverProps.lidTrustedTokenIssueToLid,
+				getLIDForPN,
+				getPNForLID
+			)
+			const result = await issuePrivacyTokens([issueJid], senderTs)
+			await (0, tc_token_utils_1.storeTcTokensFromIqResult)({
+				result,
+				fallbackJid: tcJid,
+				keys: authState.keys,
+				getLIDForPN,
+				onNewJidStored: trackTcTokenJid
+			})
+		})().catch(err => {
+			logger.debug({ jid: from, err: err?.message }, 'failed to re-issue tctoken after identity change')
+		})
+	}
+	const handleEncryptNotification = async node => {
+		const from = node.attrs.from
+		if (from === WABinary_1.S_WHATSAPP_NET) {
+			const countChild = (0, WABinary_1.getBinaryNodeChild)(node, 'count')
+			const count = +countChild.attrs.value
+			const shouldUploadMorePreKeys = count < Defaults_1.MIN_PREKEY_COUNT
+			logger.debug({ count, shouldUploadMorePreKeys }, 'recv pre-key count')
+			if (shouldUploadMorePreKeys) {
+				await uploadPreKeys()
+			}
+		} else {
+			const result = await (0, Utils_1.handleIdentityChange)(node, {
+				meId: authState.creds.me?.id,
+				meLid: authState.creds.me?.lid,
+				validateSession: signalRepository.validateSession,
+				assertSessions,
+				debounceCache: identityAssertDebounce,
+				logger,
+				onBeforeSessionRefresh: reissueTcTokenAfterIdentityChange
+			})
+			if (result.action === 'no_identity_node') {
+				logger.info({ node }, 'unknown encrypt notification')
+			}
+		}
+	}
+	const handleGroupNotification = (fullNode, child, msg) => {
+		// TODO: Support PN/LID (Here is only LID now)
+		const actingParticipantLid = fullNode.attrs.participant
+		const actingParticipantPn = fullNode.attrs.participant_pn
+		const actingParticipantUsername = fullNode.attrs.participant_username
+		const affectedParticipantLid =
+			(0, WABinary_1.getBinaryNodeChild)(child, 'participant')?.attrs?.jid || actingParticipantLid
+		const affectedParticipantPn =
+			(0, WABinary_1.getBinaryNodeChild)(child, 'participant')?.attrs?.phone_number || actingParticipantPn
+		switch (child?.tag) {
+			case 'create':
+				const metadata = (0, groups_1.extractGroupMetadata)(child)
+				msg.messageStubType = Types_1.WAMessageStubType.GROUP_CREATE
+				msg.messageStubParameters = [metadata.subject]
+				msg.key = { participant: metadata.owner, participantAlt: metadata.ownerPn }
+				ev.emit('chats.upsert', [
+					{
+						id: metadata.id,
+						name: metadata.subject,
+						conversationTimestamp: metadata.creation
+					}
+				])
+				ev.emit('groups.upsert', [
+					{
+						...metadata,
+						author: actingParticipantLid,
+						authorPn: actingParticipantPn,
+						authorUsername: actingParticipantUsername
+					}
+				])
+				break
+			case 'ephemeral':
+			case 'not_ephemeral':
+				msg.message = {
+					protocolMessage: {
+						type: index_js_1.proto.Message.ProtocolMessage.Type.EPHEMERAL_SETTING,
+						ephemeralExpiration: +(child.attrs.expiration || 0)
+					}
+				}
+				break
+			case 'modify':
+				const oldNumber = (0, WABinary_1.getBinaryNodeChildren)(child, 'participant').map(p => p.attrs.jid)
+				msg.messageStubParameters = oldNumber || []
+				msg.messageStubType = Types_1.WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER
+				break
+			case 'promote':
+			case 'demote':
+			case 'remove':
+			case 'add':
+			case 'leave':
+				const stubType = `GROUP_PARTICIPANT_${child.tag.toUpperCase()}`
+				msg.messageStubType = Types_1.WAMessageStubType[stubType]
+				const participants = (0, WABinary_1.getBinaryNodeChildren)(child, 'participant').map(({ attrs }) => {
+					// TODO: Store LID MAPPINGS
+					return {
+						id: attrs.jid,
+						phoneNumber:
+							(0, WABinary_1.isLidUser)(attrs.jid) && (0, WABinary_1.isPnUser)(attrs.phone_number)
+								? attrs.phone_number
+								: undefined,
+						lid: (0, WABinary_1.isPnUser)(attrs.jid) && (0, WABinary_1.isLidUser)(attrs.lid) ? attrs.lid : undefined,
+						username: attrs.participant_username || attrs.username || undefined,
+						admin: attrs.type || null
+					}
+				})
+				if (
+					participants.length === 1 &&
+					// if recv. "remove" message and sender removed themselves
+					// mark as left
+					((0, WABinary_1.areJidsSameUser)(participants[0].id, actingParticipantLid) ||
+						(0, WABinary_1.areJidsSameUser)(participants[0].id, actingParticipantPn)) &&
+					child.tag === 'remove'
+				) {
+					msg.messageStubType = Types_1.WAMessageStubType.GROUP_PARTICIPANT_LEAVE
+				}
+				msg.messageStubParameters = participants.map(a => JSON.stringify(a))
+				break
+			case 'subject':
+				msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_SUBJECT
+				msg.messageStubParameters = [child.attrs.subject]
+				break
+			case 'description':
+				const description = (0, WABinary_1.getBinaryNodeChild)(child, 'body')?.content?.toString()
+				msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_DESCRIPTION
+				msg.messageStubParameters = description ? [description] : undefined
+				break
+			case 'announcement':
+			case 'not_announcement':
+				msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_ANNOUNCE
+				msg.messageStubParameters = [child.tag === 'announcement' ? 'on' : 'off']
+				break
+			case 'locked':
+			case 'unlocked':
+				msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_RESTRICT
+				msg.messageStubParameters = [child.tag === 'locked' ? 'on' : 'off']
+				break
+			case 'invite':
+				msg.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_INVITE_LINK
+				msg.messageStubParameters = [child.attrs.code]
+				break
+			case 'member_add_mode':
+				const addMode = child.content
+				if (addMode) {
+					msg.messageStubType = Types_1.WAMessageStubType.GROUP_MEMBER_ADD_MODE
+					msg.messageStubParameters = [addMode.toString()]
+				}
+				break
+			case 'membership_approval_mode':
+				const approvalMode = (0, WABinary_1.getBinaryNodeChild)(child, 'group_join')
+				if (approvalMode) {
+					msg.messageStubType = Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_MODE
+					msg.messageStubParameters = [approvalMode.attrs.state]
+				}
+				break
+			case 'created_membership_requests':
+				msg.messageStubType = Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD
+				msg.messageStubParameters = [
+					JSON.stringify({ lid: affectedParticipantLid, pn: affectedParticipantPn }),
+					'created',
+					child.attrs.request_method
+				]
+				break
+			case 'revoked_membership_requests':
+				const isDenied = (0, WABinary_1.areJidsSameUser)(affectedParticipantLid, actingParticipantLid)
+				// TODO: LIDMAPPING SUPPORT
+				msg.messageStubType = Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD
+				msg.messageStubParameters = [
+					JSON.stringify({ lid: affectedParticipantLid, pn: affectedParticipantPn }),
+					isDenied ? 'revoked' : 'rejected'
+				]
+				break
+		}
+	}
+	const normalizeNotificationParticipant = async (jid, groupData) => {
+		if (!jid || typeof jid !== 'string') {
+			return jid
+		}
+		if (!(0, WABinary_1.isLidUser)(jid) && !(0, WABinary_1.isHostedLidUser)(jid)) {
+			return jid
+		}
+		const normalized = await (0, jid_display_normalization_1.normalizeMentionedJidsForSend)(
+			[jid],
+			groupData,
+			signalRepository,
+			logger
+		)
+		return normalized?.[0] || jid
+	}
+	const normalizeNotificationParticipantsArray = async (participants, groupData) => {
+		if (!Array.isArray(participants)) {
+			return participants
+		}
+		return Promise.all(participants.map(jid => normalizeNotificationParticipant(jid, groupData)))
+	}
+	const getNotificationGroupData = async node => {
+		const groupJid = (0, WABinary_1.jidNormalizedUser)(node?.attrs?.from)
+		if (!(0, WABinary_1.isJidGroup)(groupJid)) {
+			return undefined
+		}
+		try {
+			return (
+				(config.useCachedGroupMetadata && config.cachedGroupMetadata
+					? await config.cachedGroupMetadata(groupJid)
+					: undefined) || (await sock.groupMetadata(groupJid))
+			)
+		} catch (error) {
+			logger.debug({ error, groupJid }, 'failed to fetch group metadata for notification normalization')
+			return undefined
+		}
+	}
+	const normalizeNotificationStubParameters = async (stubParameters, groupData) => {
+		if (!Array.isArray(stubParameters)) {
+			return stubParameters
+		}
+		const normalized = []
+		for (const entry of stubParameters) {
+			if (typeof entry !== 'string') {
+				normalized.push(entry)
+				continue
+			}
+			if ((0, WABinary_1.isLidUser)(entry) || (0, WABinary_1.isHostedLidUser)(entry)) {
+				normalized.push(await normalizeNotificationParticipant(entry, groupData))
+				continue
+			}
+			if (entry.startsWith('{') && entry.includes('"id"')) {
+				try {
+					const parsed = JSON.parse(entry)
+					const explicitPn =
+						typeof parsed?.phoneNumber === 'string'
+							? parsed.phoneNumber
+							: typeof parsed?.pn === 'string'
+								? parsed.pn
+								: undefined
+					if ((0, WABinary_1.isPnUser)(explicitPn) || (0, WABinary_1.isHostedPnUser)(explicitPn)) {
+						parsed.id = explicitPn
+						parsed.pn = explicitPn
+						normalized.push(JSON.stringify(parsed))
+						continue
+					}
+					if (parsed?.id) {
+						parsed.id = await normalizeNotificationParticipant(parsed.id, groupData)
+					}
+					if (parsed?.lid && !parsed?.pn) {
+						parsed.pn = await normalizeNotificationParticipant(parsed.lid, groupData)
+					}
+					normalized.push(JSON.stringify(parsed))
+					continue
+				} catch (err) {
+					logger.debug({ err, entry }, 'failed to normalize stub parameter JSON')
+				}
+			}
+			normalized.push(entry)
+		}
+		return normalized
+	}
+	const normalizeCallEventJids = async (call, infoChild) => {
+		if (!call) {
+			return call
+		}
+		const callContextGroupJid = call.groupJid || ((0, WABinary_1.isJidGroup)(call.chatId) ? call.chatId : undefined)
+		let groupData
+		if (callContextGroupJid) {
+			try {
+				groupData =
+					(config.useCachedGroupMetadata && config.cachedGroupMetadata
+						? await config.cachedGroupMetadata(callContextGroupJid)
+						: undefined) || (await sock.groupMetadata(callContextGroupJid))
+			} catch (error) {
+				logger.debug({ error, groupJid: callContextGroupJid }, 'failed to fetch group metadata for call normalization')
+			}
+		}
+		if (call.chatId && !call.isGroup) {
+			call.chatId = await normalizeNotificationParticipant(call.chatId, groupData)
+		}
+		if (call.from) {
+			call.from = await normalizeNotificationParticipant(call.from, groupData)
+		}
+		if (call.groupJid) {
+			call.groupJid = await normalizeNotificationParticipant(call.groupJid, groupData)
+		}
+		if (!call.callerPn && infoChild?.attrs?.caller_lid) {
+			call.callerPn = await normalizeNotificationParticipant(infoChild.attrs.caller_lid, groupData)
+		}
+		if (!call.callerPn && call.from) {
+			call.callerPn = call.from
+		}
+		return call
+	}
+	const normalizeNotificationResult = async (node, result, groupData) => {
+		const groupJid = (0, WABinary_1.jidNormalizedUser)(node?.attrs?.from)
+		if (!(0, WABinary_1.isJidGroup)(groupJid)) {
+			return
+		}
+		if (result?.key?.participant) {
+			result.key.participant = await normalizeNotificationParticipant(result.key.participant, groupData)
+		}
+		if (result?.participant) {
+			result.participant = await normalizeNotificationParticipant(result.participant, groupData)
+		}
+		if (Array.isArray(result?.messageStubParameters)) {
+			result.messageStubParameters = await normalizeNotificationStubParameters(result.messageStubParameters, groupData)
+		}
+	}
+
+	/**
+	 * Handle incoming interop notifications (type="interop").
+	 *
+	 * The APK emits these for:
+	 *  - stella_interop_enabled / stella_ios_enabled  → feature-flag toggles
+	 *  - ig_professional / ig_handle / followers       → Instagram profile data updates
+	 *  - fbid:thread / fbid:devices                   → Meta thread/device association
+	 *  - peer_device_presence                         → interop contact online/offline
+	 *  - group membership changes in interop groups   → add/remove/promote events
+	 */
+	const handleInteropNotification = (node, child) => {
+		const childTag = child?.tag
+		const attrs = child?.attrs || {}
+
+		// Feature flag: server toggled stella_interop_enabled or stella_ios_enabled
+		if (childTag === 'feature') {
+			const feature = attrs.name
+			const enabled = attrs.value === 'true' || attrs.value === '1'
+			logger.info({ feature, enabled }, '[interop] feature flag update')
+			ev.emit('interop.feature-update', { feature, enabled })
+			return
+		}
+
+		// Instagram profile data pushed for an interop contact
+		if (childTag === 'ig_profile') {
+			const contactUpdate = {
+				id: (0, WABinary_1.jidNormalizedUser)(node.attrs.from),
+				...(attrs.ig_handle ? { igHandle: attrs.ig_handle } : {}),
+				...(attrs.ig_professional !== undefined ? { igProfessional: attrs.ig_professional === 'true' } : {}),
+				...(attrs.followers !== undefined ? { igFollowers: parseInt(attrs.followers, 10) } : {})
+			}
+			logger.debug({ contactUpdate }, '[interop] ig_profile update')
+			ev.emit('contacts.update', [contactUpdate])
+			return
+		}
+
+		// peer_device_presence — interop contact came online or went offline
+		if (childTag === 'peer_device_presence') {
+			const jid = attrs.jid || (0, WABinary_1.jidNormalizedUser)(node.attrs.from)
+			const presence = attrs.type === 'unavailable' ? 'unavailable' : 'available'
+			logger.debug({ jid, presence }, '[interop] peer_device_presence')
+			ev.emit('presence.update', { id: jid, presences: { [jid]: { lastKnownPresence: presence } } })
+			return
+		}
+
+		// fbid:thread / fbid:devices — Meta thread or device list association
+		if (childTag === 'fbid_thread' || childTag === 'fbid_devices') {
+			logger.debug({ childTag, attrs, from: node.attrs.from }, '[interop] fbid association update')
+			ev.emit('interop.fbid-update', { type: childTag, jid: node.attrs.from, attrs })
+			return
+		}
+
+		// Interop group membership changes (add / remove / promote / demote)
+		if (childTag === 'participants') {
+			const groupJid = node.attrs.from
+			const action = attrs.type // 'add' | 'remove' | 'promote' | 'demote'
+			const participants = (0, WABinary_1.getBinaryNodeChildren)(child, 'participant').map(p => p.attrs.jid)
+			logger.info({ groupJid, action, participants }, '[interop] group participants update')
+			ev.emit('group-participants.update', { id: groupJid, participants, action })
+			return
+		}
+
+		logger.debug({ childTag, from: node.attrs.from }, '[interop] unhandled interop notification subtype')
+	}
+
+	const processNotification = async node => {
+		const result = {}
+		const [child] = (0, WABinary_1.getAllBinaryNodeChildren)(node)
+		const nodeType = node.attrs.type
+		const from = (0, WABinary_1.jidNormalizedUser)(node.attrs.from)
+		switch (nodeType) {
+			case 'newsletter':
+				await handleNewsletterNotification(node)
+				break
+			case 'mex':
+				await handleMexNewsletterNotification(node)
+				break
+			case 'w:gp2':
+				// TODO: HANDLE PARTICIPANT_PN
+				const groupData = await getNotificationGroupData(node)
+				handleGroupNotification(node, child, result)
+
+				await normalizeNotificationResult(node, result, groupData)
+				break
+			case 'mediaretry':
+				const event = (0, Utils_1.decodeMediaRetryNode)(node)
+				ev.emit('messages.media-update', [event])
+				break
+			case 'encrypt':
+				await handleEncryptNotification(node)
+				break
+			case 'devices':
+				const devices = (0, WABinary_1.getBinaryNodeChildren)(child, 'device')
+				const deviceOwnerJid = child.attrs.jid || child.attrs.lid
+				const deviceData = devices.map(d => ({
+					id: d.attrs.jid,
+					lid: d.attrs.lid,
+					keyIndex: d.attrs.key_index ? +d.attrs.key_index : undefined,
+					platform: d.attrs.platform || undefined,
+					isCompanion: d.attrs.companion === 'true' || undefined
+				}))
+				if (
+					(0, WABinary_1.areJidsSameUser)(child.attrs.jid, authState.creds.me.id) ||
+					(0, WABinary_1.areJidsSameUser)(child.attrs.lid, authState.creds.me.lid)
+				) {
+					logger.info({ deviceData }, 'my own devices changed')
+					ev.emit('devices.update', { id: deviceOwnerJid, devices: deviceData, isSelf: true })
+				} else if (deviceOwnerJid) {
+					ev.emit('devices.update', { id: deviceOwnerJid, devices: deviceData, isSelf: false })
+				}
+				break
+			case 'server_sync':
+				const update = (0, WABinary_1.getBinaryNodeChild)(node, 'collection')
+				if (update) {
+					const name = update.attrs.name
+					await resyncAppState([name], false)
+				}
+				break
+			case 'picture':
+				const setPicture = (0, WABinary_1.getBinaryNodeChild)(node, 'set')
+				const delPicture = (0, WABinary_1.getBinaryNodeChild)(node, 'delete')
+				// TODO: WAJIDHASH stuff proper support inhouse
+				ev.emit('contacts.update', [
+					{
+						id: (0, WABinary_1.jidNormalizedUser)(node?.attrs?.from) || (setPicture || delPicture)?.attrs?.hash || '',
+						imgUrl: setPicture ? 'changed' : 'removed'
+					}
+				])
+				if ((0, WABinary_1.isJidGroup)(from)) {
+					const node = setPicture || delPicture
+					result.messageStubType = Types_1.WAMessageStubType.GROUP_CHANGE_ICON
+					if (setPicture) {
+						result.messageStubParameters = [setPicture.attrs.id]
+					}
+					result.participant = node?.attrs.author
+					result.key = {
+						...(result.key || {}),
+						participant: setPicture?.attrs.author
+					}
+				}
+				break
+			case 'account_sync':
+				if (child.tag === 'disappearing_mode') {
+					const newDuration = +child.attrs.duration
+					const timestamp = +child.attrs.t
+					logger.info({ newDuration }, 'updated account disappearing mode')
+					ev.emit('creds.update', {
+						accountSettings: {
+							...authState.creds.accountSettings,
+							defaultDisappearingMode: {
+								ephemeralExpiration: newDuration,
+								ephemeralSettingTimestamp: timestamp
+							}
+						}
+					})
+				} else if (child.tag === 'blocklist') {
+					const blocklists = (0, WABinary_1.getBinaryNodeChildren)(child, 'item')
+					for (const { attrs } of blocklists) {
+						const blocklist = [attrs.jid]
+						const type = attrs.action === 'block' ? 'add' : 'remove'
+						ev.emit('blocklist.update', { blocklist, type })
+					}
+				}
+				break
+			case 'business':
+				// SMB privacy / data-sharing settings sync push
+				// (WhatsApp Web: WASmaxInBizSettingsSyncPrivacySettingRequest)
+				if (child?.tag === 'privacy') {
+					ev.emit('business.privacy-settings-sync', {
+						jid: from,
+						categories: (0, WABinary_1.getBinaryNodeChildren)(child, 'category').map(c => ({
+							name: c.attrs.name,
+							value: c.attrs.value
+						})),
+						attrs: child.attrs
+					})
+				}
+				break
+			case 'hosted':
+				// Coexistence (WhatsApp <-> Messenger/Instagram) onboarding/offboarding push
+				// (WhatsApp Web: WASmaxInCoexistenceOnboarding/OffboardingNotification)
+				if (child?.tag === 'onboarding_status') {
+					ev.emit('coexistence.update', {
+						jid: from,
+						kind: 'onboarding',
+						status: child.attrs.status,
+						productSurface: child.attrs['product_surface']
+					})
+				} else if (child?.tag === 'offboarding') {
+					ev.emit('coexistence.update', {
+						jid: from,
+						kind: 'offboarding',
+						productSurface: child.attrs['product_surface']
+					})
+				}
+				break
+			case 'link_code_companion_reg':
+				const linkCodeCompanionReg = (0, WABinary_1.getBinaryNodeChild)(node, 'link_code_companion_reg')
+				const ref = toRequiredBuffer(
+					(0, WABinary_1.getBinaryNodeChildBuffer)(linkCodeCompanionReg, 'link_code_pairing_ref')
+				)
+				const primaryIdentityPublicKey = toRequiredBuffer(
+					(0, WABinary_1.getBinaryNodeChildBuffer)(linkCodeCompanionReg, 'primary_identity_pub')
+				)
+				const primaryEphemeralPublicKeyWrapped = toRequiredBuffer(
+					(0, WABinary_1.getBinaryNodeChildBuffer)(
+						linkCodeCompanionReg,
+						'link_code_pairing_wrapped_primary_ephemeral_pub'
+					)
+				)
+				const codePairingPublicKey = await decipherLinkPublicKey(primaryEphemeralPublicKeyWrapped)
+				const companionSharedKey = Utils_1.Curve.sharedKey(
+					authState.creds.pairingEphemeralKeyPair.private,
+					codePairingPublicKey
+				)
+				const random = (0, crypto_1.randomBytes)(32)
+				const linkCodeSalt = (0, crypto_1.randomBytes)(32)
+				const linkCodePairingExpanded = (0, Utils_1.hkdf)(companionSharedKey, 32, {
+					salt: linkCodeSalt,
+					info: 'link_code_pairing_key_bundle_encryption_key'
+				})
+				const encryptPayload = Buffer.concat([
+					Buffer.from(authState.creds.signedIdentityKey.public),
+					primaryIdentityPublicKey,
+					random
+				])
+				const encryptIv = (0, crypto_1.randomBytes)(12)
+				const encrypted = (0, Utils_1.aesEncryptGCM)(
+					encryptPayload,
+					linkCodePairingExpanded,
+					encryptIv,
+					Buffer.alloc(0)
+				)
+				const encryptedPayload = Buffer.concat([linkCodeSalt, encryptIv, encrypted])
+				const identitySharedKey = Utils_1.Curve.sharedKey(
+					authState.creds.signedIdentityKey.private,
+					primaryIdentityPublicKey
+				)
+				const identityPayload = Buffer.concat([companionSharedKey, identitySharedKey, random])
+				authState.creds.advSecretKey = Buffer.from(
+					(0, Utils_1.hkdf)(identityPayload, 32, { info: 'adv_secret' })
+				).toString('base64')
+				await query({
+					tag: 'iq',
+					attrs: {
+						to: WABinary_1.S_WHATSAPP_NET,
+						type: 'set',
+						id: sock.generateMessageTag(),
+						xmlns: 'md'
+					},
+					content: [
+						{
+							tag: 'link_code_companion_reg',
+							attrs: {
+								jid: authState.creds.me.id,
+								stage: 'companion_finish'
+							},
+							content: [
+								{
+									tag: 'link_code_pairing_wrapped_key_bundle',
+									attrs: {},
+									content: encryptedPayload
+								},
+								{
+									tag: 'companion_identity_public',
+									attrs: {},
+									content: authState.creds.signedIdentityKey.public
+								},
+								{
+									tag: 'link_code_pairing_ref',
+									attrs: {},
+									content: ref
+								}
+							]
+						}
+					]
+				})
+				authState.creds.registered = true
+				ev.emit('creds.update', authState.creds)
+				break
+			case 'privacy_token':
+				await handlePrivacyTokenNotification(node)
+				break
+			case 'security':
+				// Security notifications (compromised session, location change alerts)
+				const securityType = child?.tag || node.attrs.type
+				const securityData = {
+					type: securityType,
+					jid: from,
+					timestamp: node.attrs.t ? +node.attrs.t : Math.floor(Date.now() / 1000),
+					details: child?.attrs || {}
+				}
+				logger.warn({ securityData }, 'received security notification')
+				ev.emit('security.alert', securityData)
+				break
+			case 'identity':
+				// Identity change notifications — peer changed their identity key
+				const identityJid = node.attrs.from
+				const identityNewKey = child?.content ? Buffer.from(child.content) : undefined
+				ev.emit('identity.update', {
+					jid: (0, WABinary_1.jidNormalizedUser)(identityJid),
+					newIdentityKey: identityNewKey,
+					timestamp: node.attrs.t ? +node.attrs.t : Math.floor(Date.now() / 1000)
+				})
+				break
+			case 'server':
+				// Server-issued notifications (config changes, client config refresh)
+				const serverTag = child?.tag
+				if (serverTag === 'config') {
+					const configData = {}
+					for (const attr of Object.keys(child?.attrs || {})) {
+						configData[attr] = child.attrs[attr]
+					}
+					ev.emit('server.config', configData)
+				} else if (serverTag === 'app_state_key') {
+					// Server pushed a new app-state key — trigger resync
+					logger.info('server pushed app state key update')
+					await resyncAppState(['critical_block', 'regular_high', 'regular_low'], false)
+				} else {
+					logger.debug({ node }, 'unhandled server notification')
+				}
+				break
+			case 'status':
+				// Contact status (about) change notification
+				const statusOwner = node.attrs.from
+				const statusText = child?.content ? child.content.toString() : undefined
+				if (statusOwner && statusText !== undefined) {
+					ev.emit('contacts.update', [
+						{
+							id: (0, WABinary_1.jidNormalizedUser)(statusOwner),
+							status: statusText
+						}
+					])
+				}
+				break
+			case 'usync':
+				// USync result push from server
+				const usyncResults = (0, WABinary_1.getBinaryNodeChildren)(child || node, 'user')
+				if (usyncResults.length) {
+					const updates = usyncResults
+						.map(u => ({
+							id: (0, WABinary_1.jidNormalizedUser)(u.attrs.jid),
+							...(u.attrs.lid ? { lid: u.attrs.lid } : {}),
+							...(u.attrs.username ? { username: u.attrs.username } : {}),
+							...(u.attrs.status ? { status: u.attrs.status } : {})
+						}))
+						.filter(u => u.id)
+					if (updates.length) {
+						ev.emit('contacts.update', updates)
+					}
+				}
+				break
+			case 'interop':
+				// Interop-related server notifications — covers:
+				//   stella_interop_enabled / stella_ios_enabled feature flags
+				//   ig_professional / ig_handle / followers (Instagram account data)
+				//   fbid:thread / fbid:devices (Meta thread/device references)
+				//   peer_device_presence updates
+				//   group membership changes in interop groups
+				handleInteropNotification(node, child)
+				break
+		}
+		if (Object.keys(result).length) {
+			return result
+		}
+	}
+	/**
+	 * In-memory cache of storage JIDs with stored tctokens, seeded from the persisted index.
+	 * Used to coalesce writes during a session; pruning always re-reads the persisted index.
+	 */
+	const tcTokenKnownJids = new Set()
+	const tcTokenIndexLoaded = (async () => {
+		try {
+			const jids = await (0, tc_token_utils_1.readTcTokenIndex)(authState.keys)
+			for (const jid of jids) tcTokenKnownJids.add(jid)
+			logger.debug({ count: tcTokenKnownJids.size }, 'loaded tctoken index')
+		} catch (err) {
+			logger.warn({ err: err?.message }, 'failed to load tctoken index')
+		}
+	})()
+	let tcTokenIndexTimer
+	async function flushTcTokenIndex() {
+		if (tcTokenIndexTimer) {
+			clearTimeout(tcTokenIndexTimer)
+			tcTokenIndexTimer = undefined
+		}
+		const write = await (0, tc_token_utils_1.buildMergedTcTokenIndexWrite)(authState.keys, tcTokenKnownJids)
+		return authState.keys.set({ tctoken: write })
+	}
+	function scheduleTcTokenIndexSave() {
+		if (tcTokenIndexTimer) {
+			clearTimeout(tcTokenIndexTimer)
+		}
+		tcTokenIndexTimer = setTimeout(() => {
+			tcTokenIndexTimer = undefined
+			flushTcTokenIndex().catch(err => {
+				logger.warn({ err: err?.message }, 'failed to save tctoken index')
+			})
+		}, 5000)
+	}
+	function trackTcTokenJid(jid) {
+		if (jid && jid !== tc_token_utils_1.TC_TOKEN_INDEX_KEY && !tcTokenKnownJids.has(jid)) {
+			tcTokenKnownJids.add(jid)
+			scheduleTcTokenIndexSave()
+		}
+	}
+	const handlePrivacyTokenNotification = async node => {
+		const tokensNode = (0, WABinary_1.getBinaryNodeChild)(node, 'tokens')
+		if (!tokensNode) return
+		const from = (0, WABinary_1.jidNormalizedUser)(node.attrs.from)
+		// WA Web uses: senderLid ?? toLid(from) for the storage key
+		const senderLid =
+			node.attrs.sender_lid && (0, WABinary_1.isLidUser)((0, WABinary_1.jidNormalizedUser)(node.attrs.sender_lid))
+				? (0, WABinary_1.jidNormalizedUser)(node.attrs.sender_lid)
+				: undefined
+		const fallbackJid = senderLid ?? (await (0, tc_token_utils_1.resolveTcTokenJid)(from, getLIDForPN))
+		logger.debug({ from, storageJid: fallbackJid }, 'processing privacy token notification')
+		await (0, tc_token_utils_1.storeTcTokensFromIqResult)({
+			result: node,
+			fallbackJid,
+			keys: authState.keys,
+			getLIDForPN,
+			onNewJidStored: trackTcTokenJid
+		})
+	}
+	async function decipherLinkPublicKey(data) {
+		const buffer = toRequiredBuffer(data)
+		const salt = buffer.slice(0, 32)
+		const secretKey = await (0, Utils_1.derivePairingCodeKey)(authState.creds.pairingCode, salt)
+		const iv = buffer.slice(32, 48)
+		const payload = buffer.slice(48, 80)
+		return (0, Utils_1.aesDecryptCTR)(payload, secretKey, iv)
+	}
+	function toRequiredBuffer(data) {
+		if (data === undefined) {
+			throw new boom_1.Boom('Invalid buffer', { statusCode: 400 })
+		}
+		return data instanceof Buffer ? data : Buffer.from(data)
+	}
+	const willSendMessageAgain = async (id, participant) => {
+		const key = `${id}:${participant}`
+		const retryCount = (await msgRetryCache.get(key)) || 0
+		return retryCount < maxMsgRetryCount
+	}
+	const updateSendMessageAgainCount = async (id, participant) => {
+		const key = `${id}:${participant}`
+		const newValue = ((await msgRetryCache.get(key)) || 0) + 1
+		await msgRetryCache.set(key, newValue)
+	}
+	const sendMessagesAgain = async (key, ids, retryNode, receiptNode) => {
+		const remoteJid = key.remoteJid
+		const participant = key.participant || remoteJid
+		const retryCount = +retryNode.attrs.count || 1
+		const msgId = ids[0]
+		// Try to get messages from cache first, then fallback to getMessage
+		const msgs = []
+		for (const id of ids) {
+			let msg
+			// Try to get from retry cache first if enabled
+			if (messageRetryManager) {
+				const cachedMsg = messageRetryManager.getRecentMessage(remoteJid, id)
+				if (cachedMsg) {
+					msg = cachedMsg.message
+					logger.debug({ jid: remoteJid, id }, 'found message in retry cache')
+					// Mark retry as successful since we found the message
+					messageRetryManager.markRetrySuccess(id)
+				}
+			}
+			// Fallback to getMessage if not found in cache
+			if (!msg) {
+				msg = await getMessage({ ...key, id })
+				if (msg) {
+					logger.debug({ jid: remoteJid, id }, 'found message via getMessage')
+					// Also mark as successful if found via getMessage
+					if (messageRetryManager) {
+						messageRetryManager.markRetrySuccess(id)
+					}
+				}
+			}
+			msgs.push(msg)
+		}
+		// if it's the primary jid sending the request
+		// just re-send the message to everyone
+		// prevents the first message decryption failure
+		const sendToAll = !(0, WABinary_1.jidDecode)(participant)?.device
+		const sessionId = signalRepository.jidToSignalProtocolAddress(participant)
+		let injectedFromBundle = false
+		if (typeof signalRepository.injectE2ESession === 'function' && typeof Utils_1.extractE2ESessionFromRetryReceipt === 'function') {
+			const bundle = Utils_1.extractE2ESessionFromRetryReceipt(receiptNode)
+			if (bundle) {
+				try {
+					await signalRepository.injectE2ESession({ jid: participant, session: bundle })
+					injectedFromBundle = true
+					logger.debug({ participant, retryCount }, 'injected session from retry receipt key bundle')
+				} catch (error) {
+					logger.warn({ error, participant }, 'failed to inject session from retry receipt')
+				}
+			}
+		}
+		if (!injectedFromBundle && signalRepository.getSessionInfo) {
+			const receivedRegId = (0, WABinary_1.getBinaryNodeChildUInt)(receiptNode, 'registration', 4)
+			if (typeof receivedRegId === 'number' && Number.isInteger(receivedRegId)) {
+				const info = await signalRepository.getSessionInfo(participant)
+				if (info && info.registrationId !== 0 && info.registrationId !== receivedRegId) {
+					logger.info(
+						{ participant, stored: info.registrationId, received: receivedRegId },
+						'reg id mismatch on retry without bundle, deleting session'
+					)
+					await authState.keys.set({ session: { [sessionId]: null } })
+				}
+			}
+		}
+		const BASE_KEY_CHECK_RETRY = 2
+		if (msgId && messageRetryManager && signalRepository.getSessionInfo) {
+			const info = await signalRepository.getSessionInfo(participant)
+			if (info) {
+				if (retryCount === BASE_KEY_CHECK_RETRY) {
+					messageRetryManager.saveBaseKey(sessionId, msgId, info.baseKey)
+				} else if (retryCount > BASE_KEY_CHECK_RETRY) {
+					if (messageRetryManager.hasSameBaseKey(sessionId, msgId, info.baseKey)) {
+						logger.warn({ participant, retryCount }, 'base key collision on retry, forcing fresh session')
+						await authState.keys.set({ session: { [sessionId]: null } })
+					}
+					messageRetryManager.deleteBaseKey(sessionId, msgId)
+				}
+			}
+		}
+		// Check if we should recreate session for this retry
+		let shouldRecreateSession = false
+		let recreateReason = ''
+		if (enableAutoSessionRecreation && messageRetryManager && retryCount > 1 && !injectedFromBundle) {
+			try {
+				const hasSession = await signalRepository.validateSession(participant)
+				const result = messageRetryManager.shouldRecreateSession(participant, hasSession.exists)
+				shouldRecreateSession = result.recreate
+				recreateReason = result.reason
+				if (shouldRecreateSession) {
+					logger.debug({ participant, retryCount, reason: recreateReason }, 'recreating session for outgoing retry')
+					await authState.keys.set({ session: { [sessionId]: null } })
+				}
+			} catch (error) {
+				logger.warn({ error, participant }, 'failed to check session recreation for outgoing retry')
+			}
+		}
+		if (!injectedFromBundle) {
+			await assertSessions([participant], true)
+		}
+		if ((0, WABinary_1.isJidGroup)(remoteJid)) {
+			await authState.keys.set({ 'sender-key-memory': { [remoteJid]: null } })
+		}
+		logger.debug({ participant, sendToAll, shouldRecreateSession, recreateReason }, 'forced new session for retry recp')
+		for (const [i, msg] of msgs.entries()) {
+			if (!ids[i]) continue
+			if (msg && (await willSendMessageAgain(ids[i], participant))) {
+				await updateSendMessageAgainCount(ids[i], participant)
+				const msgRelayOpts = { messageId: ids[i] }
+				if (sendToAll) {
+					msgRelayOpts.useUserDevicesCache = false
+				} else {
+					msgRelayOpts.participant = {
+						jid: participant,
+						count: +retryNode.attrs.count
+					}
+				}
+				await relayMessage(key.remoteJid, msg, msgRelayOpts)
+			} else {
+				logger.debug({ jid: key.remoteJid, id: ids[i] }, 'recv retry request, but message not available')
+			}
+		}
+	}
+	const handleReceipt = async node => {
+		const { attrs, content } = node
+		const isLid = attrs.from.includes('lid')
+		const isNodeFromMe = (0, WABinary_1.areJidsSameUser)(
+			attrs.participant || attrs.from,
+			isLid ? authState.creds.me?.lid : authState.creds.me?.id
+		)
+		const remoteJid = !isNodeFromMe || (0, WABinary_1.isJidGroup)(attrs.from) ? attrs.from : attrs.recipient
+		const fromMe = !attrs.recipient || ((attrs.type === 'retry' || attrs.type === 'sender') && isNodeFromMe)
+		const key = {
+			remoteJid,
+			id: '',
+			fromMe,
+			participant: attrs.participant
+		}
+		if (shouldIgnoreJid(remoteJid) && remoteJid !== WABinary_1.S_WHATSAPP_NET) {
+			logger.debug({ remoteJid }, 'ignoring receipt from jid')
+			await sendMessageAck(node)
+			return
+		}
+		const ids = [attrs.id]
+		if (Array.isArray(content)) {
+			const items = (0, WABinary_1.getBinaryNodeChildren)(content[0], 'item')
+			ids.push(...items.map(i => i.attrs.id))
+		}
+		try {
+			await Promise.all([
+				receiptMutex.mutex(async () => {
+					const status = (0, Utils_1.getStatusFromReceiptType)(attrs.type)
+					if (
+						typeof status !== 'undefined' &&
+						// basically, we only want to know when a message from us has been delivered to/read by the other person
+						// or another device of ours has read some messages
+						(status >= index_js_1.proto.WebMessageInfo.Status.SERVER_ACK || !isNodeFromMe)
+					) {
+						if ((0, WABinary_1.isJidGroup)(remoteJid) || (0, WABinary_1.isJidStatusBroadcast)(remoteJid)) {
+							if (attrs.participant) {
+								const updateKey =
+									status === index_js_1.proto.WebMessageInfo.Status.DELIVERY_ACK ? 'receiptTimestamp' : 'readTimestamp'
+								ev.emit(
+									'message-receipt.update',
+									ids.map(id => ({
+										key: { ...key, id },
+										receipt: {
+											userJid: (0, WABinary_1.jidNormalizedUser)(attrs.participant),
+											[updateKey]: +attrs.t
+										}
+									}))
+								)
+							}
+						} else {
+							ev.emit(
+								'messages.update',
+								ids.map(id => ({
+									key: { ...key, id },
+									update: { status, messageTimestamp: (0, Utils_1.toNumber)(+(attrs.t ?? 0)) }
+								}))
+							)
+						}
+					}
+					if (attrs.type === 'retry') {
+						// correctly set who is asking for the retry
+						key.participant = key.participant || attrs.from
+						const retryNode = (0, WABinary_1.getBinaryNodeChild)(node, 'retry')
+						if (ids[0] && key.participant && (await willSendMessageAgain(ids[0], key.participant))) {
+							if (key.fromMe) {
+								try {
+									await updateSendMessageAgainCount(ids[0], key.participant)
+									logger.debug({ attrs, key }, 'recv retry request')
+									await sendMessagesAgain(key, ids, retryNode, node)
+								} catch (error) {
+									logger.error(
+										{ key, ids, trace: error instanceof Error ? error.stack : 'Unknown error' },
+										'error in sending message again'
+									)
+								}
+							} else {
+								logger.info({ attrs, key }, 'recv retry for not fromMe message')
+							}
+						} else {
+							logger.info({ attrs, key }, 'will not send message again, as sent too many times')
+						}
+					}
+				})
+			])
+		} finally {
+			await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack receipt'))
+		}
+	}
+	const handleNotification = async node => {
+		const remoteJid = node.attrs.from
+		if (shouldIgnoreJid(remoteJid) && remoteJid !== WABinary_1.S_WHATSAPP_NET) {
+			logger.debug({ remoteJid, id: node.attrs.id }, 'ignored notification')
+			await sendMessageAck(node)
+			return
+		}
+		try {
+			await Promise.all([
+				notificationMutex.mutex(async () => {
+					const msg = await processNotification(node)
+					if (msg) {
+						const fromMe = (0, WABinary_1.areJidsSameUser)(node.attrs.participant || remoteJid, authState.creds.me.id)
+						const { senderAlt: participantAlt, addressingMode } = (0, Utils_1.extractAddressingContext)(node)
+						msg.key = {
+							remoteJid,
+							fromMe,
+							participant: node.attrs.participant,
+							participantAlt,
+							participantUsername: node.attrs.participant_username,
+							addressingMode,
+							id: node.attrs.id,
+							...(msg.key || {})
+						}
+						msg.participant ?? (msg.participant = node.attrs.participant)
+						msg.messageTimestamp = +node.attrs.t
+						let groupDataForNormalization
+						if ((0, WABinary_1.isJidGroup)(msg?.key?.remoteJid)) {
+							try {
+								groupDataForNormalization =
+									(config.useCachedGroupMetadata && config.cachedGroupMetadata
+										? await config.cachedGroupMetadata(msg.key.remoteJid)
+										: undefined) || (await sock.groupMetadata(msg.key.remoteJid))
+							} catch (error) {
+								logger.debug(
+									{ error, jid: msg.key.remoteJid },
+									'failed to fetch group metadata for recv jid normalization'
+								)
+							}
+						}
+						await (0, jid_display_normalization_1.normalizeMessageForDisplayJids)(
+							msg,
+							signalRepository,
+							logger,
+							groupDataForNormalization
+						)
+						const fullMsg = index_js_1.proto.WebMessageInfo.fromObject(msg)
+						await upsertMessage(fullMsg, 'append')
+					}
+				})
+			])
+		} finally {
+			await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack notification'))
+		}
+	}
+	const handleMessage = async node => {
+		const isInteropNode = (0, WABinary_1.isInteropUser)(node.attrs.from)
+		if (isInteropNode) {
+			logger.info(
+				{
+					from: node.attrs.from,
+					id: node.attrs.id,
+					type: node.attrs.type,
+					sts: node.attrs.sts,
+					display_name: node.attrs.display_name,
+					encType: (0, WABinary_1.getBinaryNodeChild)(node, 'enc')?.attrs?.type
+				},
+				'[interop] node arrived'
+			)
+		}
+		if (shouldIgnoreJid(node.attrs.from) && node.attrs.from !== WABinary_1.S_WHATSAPP_NET) {
+			if (isInteropNode) logger.warn({ from: node.attrs.from }, '[interop] node dropped by shouldIgnoreJid')
+			logger.debug({ key: node.attrs.key }, 'ignored message')
+			await sendMessageAck(node, Utils_1.NACK_REASONS.UnhandledError)
+			return
+		}
+		const groupJid = node.attrs.from
+		const communityJid = linkedParentMap[groupJid]
+		const encNode = (0, WABinary_1.getBinaryNodeChild)(node, 'enc')
+		// TODO: temporary fix for crashes and issues resulting of failed msmsg decryption
+		if (encNode?.attrs.type === 'msmsg') {
+			// await sendMessageAck(node, Utils_1.NACK_REASONS.MissingMessageSecret)
+			// return
+			// Pre-populate botMessageSecrets from store so msmsg can be decrypted after restart
+			if (getMessage) {
+				const metaNode = (0, WABinary_1.getBinaryNodeChild)(node, 'meta')
+				const targetId = metaNode?.attrs?.target_id
+				if (targetId) {
+					try {
+						const targetMsg = await getMessage({ remoteJid: node.attrs.from, id: targetId, fromMe: true })
+						const secret = targetMsg?.messageContextInfo?.messageSecret
+						if (secret) {
+							;(0, Utils_1.setBotMessageSecret)(targetId, secret)
+						}
+					} catch (err) {
+						logger.debug({ err, targetId }, 'failed to retrieve message secret for msmsg')
+					}
+				}
+			}
+		}
+		let acked = false
+		try {
+			const {
+				fullMessage: msg,
+				category,
+				author,
+				decrypt
+			} = (0, Utils_1.decryptMessageNode)(
+				node,
+				authState.creds.me.id,
+				authState.creds.me.lid || '',
+				signalRepository,
+				logger
+			)
+			if (isInteropNode) {
+				logger.info(
+					{ remoteJid: msg.key.remoteJid, id: msg.key.id, fromMe: msg.key.fromMe, pushName: msg.pushName },
+					'[interop] decodeMessageNode OK'
+				)
+			}
+			const alt = msg.key.participantAlt || msg.key.remoteJidAlt
+			// store new mappings we didn't have before
+			if (!!alt) {
+				const altServer = (0, WABinary_1.jidDecode)(alt)?.server
+				const primaryJid = msg.key.participant || msg.key.remoteJid
+				if (altServer === 'lid') {
+					if (!(await signalRepository.lidMapping.getPNForLID(alt))) {
+						await signalRepository.lidMapping.storeLIDPNMappings([{ lid: alt, pn: primaryJid }])
+						await signalRepository.migrateSession(primaryJid, alt)
+					}
+				} else {
+					await signalRepository.lidMapping.storeLIDPNMappings([{ lid: primaryJid, pn: alt }])
+					await signalRepository.migrateSession(alt, primaryJid)
+				}
+			}
+			await messageMutex.mutex(async () => {
+				await decrypt()
+				if (isInteropNode) {
+					const stubType = msg.messageStubType
+					const stubText = msg.messageStubParameters?.[0]
+					logger.info(
+						{
+							id: msg.key.id,
+							hasMessage: !!msg.message,
+							messageKeys: msg.message ? Object.keys(msg.message) : [],
+							stubType,
+							stubText
+						},
+						'[interop] decrypt() done'
+					)
+				}
+				if (msg.key?.remoteJid && msg.key?.id && msg.message && messageRetryManager) {
+					messageRetryManager.addRecentMessage(msg.key.remoteJid, msg.key.id, msg.message)
+				}
+				// message failed to decrypt
+				if (msg.messageStubType === index_js_1.proto.WebMessageInfo.StubType.CIPHERTEXT && msg.category !== 'peer') {
+					if (msg?.messageStubParameters?.[0] === Utils_1.MISSING_KEYS_ERROR_TEXT) {
+						if (isInteropNode) logger.warn({ id: msg.key.id }, '[interop] decrypt failed: MISSING_KEYS')
+						acked = true
+						return sendMessageAck(node, Utils_1.NACK_REASONS.ParsingError)
+					}
+					if (msg.messageStubParameters?.[0] === Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT) {
+						// Message arrived without encryption (e.g. CTWA ads messages).
+						// Check if this is eligible for placeholder resend (matching WA Web filters).
+						const unavailableNode = (0, WABinary_1.getBinaryNodeChild)(node, 'unavailable')
+						const unavailableType = unavailableNode?.attrs?.type
+						if (
+							unavailableType === 'bot_unavailable_fanout' ||
+							unavailableType === 'hosted_unavailable_fanout' ||
+							unavailableType === 'view_once_unavailable_fanout'
+						) {
+							logger.debug(
+								{ msgId: msg.key.id, unavailableType },
+								'skipping placeholder resend for excluded unavailable type'
+							)
+							acked = true
+							return sendMessageAck(node)
+						}
+						const messageAge = (0, Utils_1.unixTimestampSeconds)() - (0, Utils_1.toNumber)(msg.messageTimestamp)
+						if (messageAge > Defaults_1.PLACEHOLDER_MAX_AGE_SECONDS) {
+							logger.debug({ msgId: msg.key.id, messageAge }, 'skipping placeholder resend for old message')
+							acked = true
+							return sendMessageAck(node)
+						}
+						// Request the real content from the phone via placeholder resend PDO.
+						// Upsert the CIPHERTEXT stub as a placeholder (like WA Web's processPlaceholderMsg),
+						// and store the requestId in stubParameters[1] so users can correlate
+						// with the incoming PDO response event.
+						const cleanKey = {
+							remoteJid: msg.key.remoteJid,
+							fromMe: msg.key.fromMe,
+							id: msg.key.id,
+							participant: msg.key.participant
+						}
+						// Cache the original message metadata so the PDO response handler
+						// can preserve key fields (LID details etc.) that the phone may omit
+						const msgData = {
+							key: msg.key,
+							messageTimestamp: msg.messageTimestamp,
+							pushName: msg.pushName,
+							participant: msg.participant,
+							verifiedBizName: msg.verifiedBizName
+						}
+						requestPlaceholderResend(cleanKey, msgData)
+							.then(requestId => {
+								if (requestId && requestId !== 'RESOLVED') {
+									logger.debug({ msgId: msg.key.id, requestId }, 'requested placeholder resend for unavailable message')
+									ev.emit('messages.update', [
+										{
+											key: msg.key,
+											update: { messageStubParameters: [Utils_1.NO_MESSAGE_FOUND_ERROR_TEXT, requestId] }
+										}
+									])
+								}
+							})
+							.catch(err => {
+								logger.warn({ err, msgId: msg.key.id }, 'failed to request placeholder resend for unavailable message')
+							})
+						acked = true
+						await sendMessageAck(node)
+						// Don't return — fall through to upsertMessage so the stub is emitted
+					} else {
+						// Skip retry for expired status messages (>24h old)
+						if ((0, WABinary_1.isJidStatusBroadcast)(msg.key.remoteJid)) {
+							const messageAge = (0, Utils_1.unixTimestampSeconds)() - (0, Utils_1.toNumber)(msg.messageTimestamp)
+							if (messageAge > Defaults_1.STATUS_EXPIRY_SECONDS) {
+								logger.debug(
+									{ msgId: msg.key.id, messageAge, remoteJid: msg.key.remoteJid },
+									'skipping retry for expired status message'
+								)
+								acked = true
+								return sendMessageAck(node)
+							}
+						}
+						const errorMessage = msg?.messageStubParameters?.[0] || ''
+						const isPreKeyError = errorMessage.includes('PreKey')
+						logger.debug(`[handleMessage] Attempting retry request for failed decryption`)
+						// Handle both pre-key and normal retries in single mutex
+						await retryMutex.mutex(async () => {
+							try {
+								if (!ws.isOpen) {
+									logger.debug({ node }, 'Connection closed, skipping retry')
+									return
+								}
+								// Handle pre-key errors with upload and delay
+								if (isPreKeyError) {
+									logger.info({ error: errorMessage }, 'PreKey error detected, uploading and retrying')
+									try {
+										logger.debug('Uploading pre-keys for error recovery')
+										await uploadPreKeys(5)
+										logger.debug('Waiting for server to process new pre-keys')
+										await (0, Utils_1.delay)(1000)
+									} catch (uploadErr) {
+										logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway')
+									}
+								}
+								const encNode = (0, WABinary_1.getBinaryNodeChild)(node, 'enc')
+								await sendRetryRequest(node, !encNode)
+								if (retryRequestDelayMs) {
+									await (0, Utils_1.delay)(retryRequestDelayMs)
+								}
+							} catch (err) {
+								logger.error({ err, isPreKeyError }, 'Failed to handle retry, attempting basic retry')
+								// Still attempt retry even if pre-key upload failed
+								try {
+									const encNode = (0, WABinary_1.getBinaryNodeChild)(node, 'enc')
+									await sendRetryRequest(node, !encNode)
+								} catch (retryErr) {
+									logger.error({ retryErr }, 'Failed to send retry after error handling')
+								}
+							}
+							acked = true
+							await sendMessageAck(node, Utils_1.NACK_REASONS.UnhandledError)
+						})
+					}
+				} else {
+					if (messageRetryManager && msg.key.id) {
+						messageRetryManager.cancelPendingPhoneRequest(msg.key.id)
+					}
+					const isNewsletter = (0, WABinary_1.isJidNewsletter)(msg.key.remoteJid)
+					if (!isNewsletter) {
+						// no type in the receipt => message delivered
+						let type = undefined
+						let participant = msg.key.participant
+						if (communityJid) {
+							msg.communityJid = communityJid
+						}
+						if (category === 'peer') {
+							// special peer message
+							type = 'peer_msg'
+						} else if (msg.key.fromMe) {
+							// message was sent by us from a different device
+							type = 'sender'
+							// need to specially handle this case
+							if ((0, WABinary_1.isLidUser)(msg.key.remoteJid) || (0, WABinary_1.isLidUser)(msg.key.remoteJidAlt)) {
+								participant = author // TODO: investigate sending receipts to LIDs and not PNs
+							}
+						} else if (!sendActiveReceipts) {
+							type = 'inactive'
+						}
+						acked = true
+						// Pass sts from the original stanza for interop contacts (BirdyChat/Haiket)
+						const interopSts = (0, WABinary_1.isInteropUser)(msg.key.remoteJid) ? node.attrs.sts : undefined
+						await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type, interopSts)
+						// send ack for history message
+						const isAnyHistoryMsg = (0, Utils_1.getHistoryMsg)(msg.message)
+						if (isAnyHistoryMsg) {
+							const jid = (0, WABinary_1.jidNormalizedUser)(msg.key.remoteJid)
+							await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync') // TODO: investigate
+						}
+					} else {
+						acked = true
+						await sendMessageAck(node)
+						logger.debug({ key: msg.key }, 'processed newsletter message without receipts')
+					}
+				}
+				;(0, Utils_1.cleanMessage)(msg, authState.creds.me.id, authState.creds.me.lid)
+				const msgTs = (0, Utils_1.toNumber)(msg.messageTimestamp)
+				const isPending = !isConnected || node.attrs.offline || msgTs < socketCreatedAt
+				if (isInteropNode) {
+					logger.info(
+						{
+							id: msg.key.id,
+							isPending,
+							isConnected,
+							offline: node.attrs.offline,
+							msgTs,
+							socketCreatedAt
+						},
+						isPending ? '[interop] upsert as append (pending/offline)' : '[interop] upsert as notify'
+					)
+				}
+				if (isPending) {
+					await upsertMessage(msg, 'append')
+					return
+				}
+				let groupDataForNormalization
+				if ((0, WABinary_1.isJidGroup)(msg?.key?.remoteJid)) {
+					try {
+						groupDataForNormalization =
+							(config.useCachedGroupMetadata && config.cachedGroupMetadata
+								? await config.cachedGroupMetadata(msg.key.remoteJid)
+								: undefined) || (await sock.groupMetadata(msg.key.remoteJid))
+					} catch (error) {
+						logger.debug({ error, jid: msg.key.remoteJid }, 'failed to fetch group metadata for recv jid normalization')
+					}
+				}
+				await (0, jid_display_normalization_1.normalizeMessageForDisplayJids)(
+					msg,
+					signalRepository,
+					logger,
+					groupDataForNormalization
+				)
+				await upsertMessage(msg, 'notify')
+			})
+		} catch (error) {
+			if (isInteropNode) {
+				logger.error(
+					{ error: error?.message, stack: error?.stack, from: node.attrs.from, id: node.attrs.id },
+					'[interop] unhandled error in handleMessage'
+				)
+			}
+			logger.error({ error, node: (0, WABinary_1.binaryNodeToString)(node) }, 'error in handling message')
+			if (!acked) {
+				await sendMessageAck(node, Utils_1.NACK_REASONS.UnhandledError).catch(ackErr =>
+					logger.error({ ackErr }, 'failed to ack message after error')
+				)
+			}
+		}
+	}
+	const handleCall = async node => {
+		try {
+			const { attrs } = node
+			const [infoChild] = (0, WABinary_1.getAllBinaryNodeChildren)(node)
+			if (!infoChild) {
+				throw new boom_1.Boom('Missing call info in call node')
+			}
+			const status = (0, Utils_1.getCallStatusFromNode)(infoChild)
+			const callId = infoChild.attrs['call-id']
+			const from = infoChild.attrs.from || infoChild.attrs['call-creator']
+			const call = {
+				chatId: attrs.from,
+				from,
+				callerPn: infoChild.attrs['caller_pn'],
+				id: callId,
+				date: new Date(+attrs.t * 1000),
+				offline: !!attrs.offline,
+				status
+			}
+			if (status === 'relaylatency') {
+				const latencyValue = infoChild.attrs.latency || infoChild.attrs['latency_ms'] || infoChild.attrs['latency-ms']
+				const latencyMs = latencyValue ? Number(latencyValue) : undefined
+				if (Number.isFinite(latencyMs)) {
+					call.latencyMs = latencyMs
+				}
+			}
+			if (status === 'offer') {
+				call.isVideo = !!(0, WABinary_1.getBinaryNodeChild)(infoChild, 'video')
+				call.isGroup = infoChild.attrs.type === 'group' || !!infoChild.attrs['group-jid']
+				call.groupJid = infoChild.attrs['group-jid']
+				await callOfferCache.set(call.id, call)
+			}
+			const existingCall = await callOfferCache.get(call.id)
+			// use existing call info to populate this event
+			if (existingCall) {
+				call.isVideo = existingCall.isVideo
+				call.isGroup = existingCall.isGroup
+				call.callerPn = call.callerPn || existingCall.callerPn
+			}
+			// delete data once call has ended
+			if (status === 'reject' || status === 'accept' || status === 'timeout' || status === 'terminate') {
+				await callOfferCache.del(call.id)
+			}
+			await normalizeCallEventJids(call, infoChild)
+			ev.emit('call', [call])
+		} catch (error) {
+			logger.error({ error, node: (0, WABinary_1.binaryNodeToString)(node) }, 'error in handling call')
+		} finally {
+			await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack call'))
+		}
+	}
+	// Some accounts receive call signalling as TOP-LEVEL stanzas (<offer>, <terminate>,
+	// <mute_v2>, <transport>, … each with a call-id) instead of wrapped in <call>.
+	// This additively handles those: emit a 'call' event for state stanzas and ack ALL
+	// of them (otherwise WhatsApp keeps redelivering). The <call> path above is untouched.
+	const CALL_STATE_TAGS = new Set(['offer', 'offer_notice', 'terminate', 'accept', 'reject', 'preaccept'])
+	const handleStandaloneCallStanza = async node => {
+		try {
+			if (!CALL_STATE_TAGS.has(node.tag)) {
+				return // media/relay signalling (transport, video, duration, mute_v2, lobby, …): ack only
+			}
+			const { attrs } = node
+			const status = (0, Utils_1.getCallStatusFromNode)(node)
+			const callId = attrs['call-id']
+			const from = attrs.from || attrs['call-creator']
+			const call = {
+				chatId: attrs.from || from,
+				from,
+				callerPn: attrs['caller_pn'],
+				id: callId,
+				date: attrs.t ? new Date(+attrs.t * 1000) : new Date(),
+				offline: !!attrs.offline,
+				status
+			}
+			if (status === 'offer') {
+				call.isVideo = !!(0, WABinary_1.getBinaryNodeChild)(node, 'video')
+				call.isGroup = attrs.type === 'group' || !!attrs['group-jid']
+				call.groupJid = attrs['group-jid']
+				if (callId) {
+					await callOfferCache.set(callId, call)
+				}
+			}
+			const existingCall = callId ? await callOfferCache.get(callId) : undefined
+			if (existingCall) {
+				call.isVideo = existingCall.isVideo
+				call.isGroup = existingCall.isGroup
+				call.callerPn = call.callerPn || existingCall.callerPn
+			}
+			if (callId && (status === 'reject' || status === 'accept' || status === 'timeout' || status === 'terminate')) {
+				await callOfferCache.del(callId)
+			}
+			await normalizeCallEventJids(call, node)
+			ev.emit('call', [call])
+		} catch (error) {
+			logger.error({ error, node: (0, WABinary_1.binaryNodeToString)(node) }, 'error handling standalone call stanza')
+		} finally {
+			await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack standalone call'))
+		}
+	}
+	const handleBadAck = async ({ attrs }) => {
+		const key = { remoteJid: attrs.from, fromMe: true, id: attrs.id }
+		// WARNING: REFRAIN FROM ENABLING THIS FOR NOW. IT WILL CAUSE A LOOP
+		// // current hypothesis is that if pash is sent in the ack
+		// // it means -- the message hasn't reached all devices yet
+		// // we'll retry sending the message here
+		// if(attrs.phash) {
+		// 	logger.info({ attrs }, 'received phash in ack, resending message...')
+		// 	const msg = await getMessage(key)
+		// 	if(msg) {
+		// 		await relayMessage(key.remoteJid!, msg, { messageId: key.id!, useUserDevicesCache: false })
+		// 	} else {
+		// 		logger.warn({ attrs }, 'could not send message again, as it was not found')
+		// 	}
+		// }
+		// error in acknowledgement,
+		// device could not display the message
+		if (attrs.error) {
+			if (attrs.error === Utils_1.SERVER_ERROR_CODES.MissingTcToken) {
+				// 463 = account restricted + no tctoken for this contact.
+				// WA Web prevents this client-side (disables compose bar).
+				// No retry — retrying worsens the restriction by counting as another "reach out" to an unknown contact.
+				logger.warn(
+					{ msgId: attrs.id, from: attrs.from },
+					'error 463: account restricted or missing tctoken for contact'
+				)
+			} else if (attrs.error === Utils_1.SERVER_ERROR_CODES.SmaxInvalid) {
+				logger.warn(
+					{ msgId: attrs.id, from: attrs.from },
+					'smax-invalid (479): stanza rejected by server — likely stale device session or malformed addressing'
+				)
+			} else {
+				logger.warn({ attrs }, 'received error in ack')
+			}
+			ev.emit('messages.update', [
+				{
+					key,
+					update: {
+						status: Types_1.WAMessageStatus.ERROR,
+						messageStubParameters: [attrs.error]
+					}
+				}
+			])
+			// resend the message with device_fanout=false, use at your own risk
+			// if (attrs.error === '475') {
+			// 	const msg = await getMessage(key)
+			// 	if (msg) {
+			// 		await relayMessage(key.remoteJid!, msg, {
+			// 			messageId: key.id!,
+			// 			useUserDevicesCache: false,
+			// 			additionalAttributes: {
+			// 				device_fanout: 'false'
+			// 			}
+			// 		})
+			// 	}
+			// }
+		}
+	}
+	/// processes a node with the given function
+	/// and adds the task to the existing buffer if we're buffering events
+	const processNodeWithBuffer = async (node, identifier, exec) => {
+		ev.buffer()
+		await execTask()
+		ev.flush()
+		function execTask() {
+			return exec(node, false).catch(err => onUnexpectedError(err, identifier))
+		}
+	}
+	const offlineNodeProcessor = (0, offline_node_processor_1.makeOfflineNodeProcessor)(
+		new Map([
+			['message', handleMessage],
+			['call', handleCall],
+			['receipt', handleReceipt],
+			['notification', handleNotification]
+		]),
+		{
+			isWsOpen: () => ws.isOpen,
+			onUnexpectedError,
+			yieldToEventLoop: () => new Promise(resolve => setImmediate(resolve))
+		}
+	)
+	const processNode = async (type, node, identifier, exec) => {
+		const isOffline = !!node.attrs.offline
+		if (isOffline) {
+			offlineNodeProcessor.enqueue(type, node)
+		} else {
+			await processNodeWithBuffer(node, identifier, exec)
+		}
+	}
+	let latestNodeInMemory = null
+	const nodelogger = node => {
+		if (!node) return null
+		latestNodeInMemory = node
+		return latestNodeInMemory
+	}
+	const setNodeLoggerListener = () => {
+		return latestNodeInMemory
+	}
+	// recv a message
+	ws.on('CB:message', async node => {
+		nodelogger(node)
+		await processNode('message', node, 'processing message', handleMessage)
+	})
+	ws.on('CB:call', async node => {
+		nodelogger(node)
+		await processNode('call', node, 'handling call', handleCall)
+	})
+	// additive: top-level call-signalling stanzas (some accounts send these instead of <call>)
+	for (const callTag of [
+		'offer', 'offer_notice', 'terminate', 'accept', 'reject', 'preaccept',
+		'transport', 'video', 'duration', 'mute_v2', 'lobby', 'heartbeat', 'relaylatency', 'link_query'
+	]) {
+		ws.on('CB:' + callTag, node => {
+			nodelogger(node)
+			handleStandaloneCallStanza(node).catch(error => onUnexpectedError(error, 'handling standalone call stanza'))
+		})
+	}
+	ws.on('CB:receipt', async node => {
+		nodelogger(node)
+		await processNode('receipt', node, 'handling receipt', handleReceipt)
+	})
+	ws.on('CB:notification', async node => {
+		nodelogger(node)
+		await processNode('notification', node, 'handling notification', handleNotification)
+	})
+	ws.on('CB:ack,class:message', node => {
+		nodelogger(node)
+		handleBadAck(node).catch(error => onUnexpectedError(error, 'handling bad ack'))
+	})
+	const linkedParentMap = {}
+	ws.on('CB:iq', node => {
+		if (node && node.tag === 'iq' && node.attrs.type === 'result') {
+			const groups = node.content
+
+			if (Array.isArray(groups)) {
+				for (const group of groups) {
+					const groupId = group.attrs.id + '@g.us'
+
+					if (group && Array.isArray(group.content)) {
+						for (const item of group.content) {
+							if (item.tag === 'linked_parent' && item.attrs && item.attrs.jid) {
+								linkedParentMap[groupId] = item.attrs.jid
+							}
+						}
+					}
+				}
+			}
+		}
+	})
+	ev.on('call', async ([call]) => {
+		if (!call) {
+			return
+		}
+		nodelogger(call)
+		// missed call + group call notification message generation
+		if (call.status === 'timeout' || (call.status === 'offer' && call.isGroup)) {
+			const msg = {
+				key: {
+					remoteJid: call.chatId,
+					id: call.id,
+					fromMe: false
+				},
+				messageTimestamp: (0, Utils_1.unixTimestampSeconds)(call.date)
+			}
+			if (call.status === 'timeout') {
+				if (call.isGroup) {
+					msg.messageStubType = call.isVideo
+						? Types_1.WAMessageStubType.CALL_MISSED_GROUP_VIDEO
+						: Types_1.WAMessageStubType.CALL_MISSED_GROUP_VOICE
+				} else {
+					msg.messageStubType = call.isVideo
+						? Types_1.WAMessageStubType.CALL_MISSED_VIDEO
+						: Types_1.WAMessageStubType.CALL_MISSED_VOICE
+				}
+			} else {
+				msg.message = { call: { callKey: Buffer.from(call.id) } }
+			}
+			const protoMsg = index_js_1.proto.WebMessageInfo.fromObject(msg)
+			await upsertMessage(protoMsg, call.offline ? 'append' : 'notify')
+		}
+	})
+	let lastTcTokenPruneTs = 0
+	ev.on('connection.update', ({ isOnline, connection }) => {
+		if (connection === 'open') {
+			isConnected = true
+		}
+		if (typeof isOnline !== 'undefined') {
+			sendActiveReceipts = isOnline
+			logger.trace(`sendActiveReceipts set to "${sendActiveReceipts}"`)
+		}
+		// Daily cleanup of expired tctokens (mirrors WA Web's CLEAN_TC_TOKENS task)
+		if (isOnline) {
+			const now = Date.now()
+			const DAY_MS = 24 * 60 * 60 * 1000
+			if (now - lastTcTokenPruneTs >= DAY_MS) {
+				lastTcTokenPruneTs = now
+				void pruneExpiredTcTokens()
+			}
+		}
+	})
+	async function pruneExpiredTcTokens() {
+		try {
+			await tcTokenIndexLoaded
+			const persisted = await (0, tc_token_utils_1.readTcTokenIndex)(authState.keys)
+			const allJids = new Set(tcTokenKnownJids)
+			for (const jid of persisted) allJids.add(jid)
+			if (!allJids.size) return
+			const jids = [...allJids]
+			const allTokens = await authState.keys.get('tctoken', jids)
+			const writes = {}
+			const survivors = new Set()
+			let mutated = 0
+			for (const jid of jids) {
+				const entry = allTokens[jid]
+				if (!entry) {
+					mutated++
+					continue
+				}
+				const hasPeerToken = !!entry.token?.length
+				const peerTokenExpired = hasPeerToken && (0, tc_token_utils_1.isTcTokenExpired)(entry.timestamp)
+				const hasSenderTs = entry.senderTimestamp !== undefined
+				const senderTsExpired = hasSenderTs && (0, tc_token_utils_1.isTcTokenExpired)(entry.senderTimestamp)
+				const keepPeerToken = hasPeerToken && !peerTokenExpired
+				const keepSenderTs = hasSenderTs && !senderTsExpired
+				if (!keepPeerToken && !keepSenderTs) {
+					writes[jid] = null
+					mutated++
+				} else if (peerTokenExpired && keepSenderTs) {
+					writes[jid] = { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+					survivors.add(jid)
+					mutated++
+				} else {
+					survivors.add(jid)
+				}
+			}
+			if (mutated === 0) return
+			await authState.keys.set({
+				tctoken: {
+					...writes,
+					[tc_token_utils_1.TC_TOKEN_INDEX_KEY]: {
+						token: Buffer.from(JSON.stringify([...survivors]))
+					}
+				}
+			})
+			tcTokenKnownJids.clear()
+			for (const jid of survivors) tcTokenKnownJids.add(jid)
+			logger.debug({ mutated, remaining: survivors.size }, 'pruned expired tctokens')
+		} catch (err) {
+			logger.warn({ err: err?.message }, 'failed to prune expired tctokens')
+		}
+	}
+	return {
+		...sock,
+		sendMessageAck,
+		sendRetryRequest,
+		offerCall,
+		rejectCall,
+		acceptCall,
+		terminateCall,
+		rekeyCall,
+		joinCallLink,
+		queryCallLink,
+		nodelogger,
+		setNodeLoggerListener,
+		fetchMessageHistory,
+		requestPlaceholderResend,
+		requestWaffleNonce,
+		requestCompanionCanonicalNonce,
+		requestCompanionMetaNonce,
+		messageRetryManager
+	}
+}
+exports.makeMessagesRecvSocket = makeMessagesRecvSocket