test(binary): drain AwaitingInitialSync timer & fix stale comment

Addresses 2 review comments on PR #384:

- Codex P2: the fresh-pair test ended the socket immediately after the
  buffer assertion, leaving the 2s setTimeout in chats.ts:1522 alive.
  Its callback fired post-teardown and emitted "Cannot log after tests
  are done" via baileys-logger, making the suite noisy and trippable
  by --detectOpenHandles. Drain the timer with a 2.1s wait before
  cleanup; bump the per-test timeout to 10s to accommodate it.

- Copilot: the file header said "live messages are not held for up to
  4 seconds", but the chats.ts AwaitingInitialSync timeout is 2s.
  Replace the stale literal with "the initial-sync window" so the
  comment doesn't drift again when the timeout is tuned.

Skipped intentionally (per PR review):
- CodeRabbit Major (try/finally cleanup): diverges from the pattern
  used by the only sibling test (connection-deadlock.test.ts).
- CodeRabbit Nitpick (replace 50ms sleeps with deterministic waits):
  not flaky in practice; sibling test uses the same pattern.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/Socket/chats.ts

@@ -1060,22 +1060,21 @@ export const makeChatsSocket = (config: SocketConfig) => {
 		}
 	}
 
-	/** sending non-abt props may fix QR scan fail if server expects */
+	/** fetch AB props */
 	const fetchProps = async () => {
-		//TODO: implement both protocol 1 and protocol 2 prop fetching, specially for abKey for WM
 		const resultNode = await query({
 			tag: 'iq',
 			attrs: {
 				to: S_WHATSAPP_NET,
-				xmlns: 'w',
+				xmlns: 'abt',
 				type: 'get'
 			},
 			content: [
 				{
 					tag: 'props',
 					attrs: {
-						protocol: '2',
+						protocol: '1',
-						hash: authState?.creds?.lastPropHash || ''
+						...(authState?.creds?.lastPropHash ? { hash: authState.creds.lastPropHash } : {})
 					}
 				}
 			]

src/Socket/messages-recv.ts

@@ -2124,12 +2124,6 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		if (resolvedRemoteJid) key.remoteJid = resolvedRemoteJid
 		if (resolvedParticipant) key.participant = resolvedParticipant
 
-		if (shouldIgnoreJid(remoteJid!) && remoteJid !== S_WHATSAPP_NET) {
-			logger.trace({ remoteJid }, 'ignoring receipt from jid')
-			await sendMessageAck(node)
-			return
-		}
-
 		const ids = [attrs.id!]
 		if (Array.isArray(content)) {
 			const items = getBinaryNodeChildren(content[0], 'item')
@@ -2205,11 +2199,6 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 
 	const handleNotification = async (node: BinaryNode) => {
 		const remoteJid = node.attrs.from
-		if (shouldIgnoreJid(remoteJid!) && remoteJid !== S_WHATSAPP_NET) {
-			logger.trace({ remoteJid }, 'ignored notification')
-			await sendMessageAck(node)
-			return
-		}
 
 		try {
 			await Promise.all([
@@ -2246,12 +2235,6 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 	}
 
 	const handleMessage = async (node: BinaryNode) => {
-		if (shouldIgnoreJid(node.attrs.from!) && node.attrs.from !== S_WHATSAPP_NET) {
-			logger.trace({ from: node.attrs.from }, 'ignored message')
-			await sendMessageAck(node)
-			return
-		}
-
 		const encNode = getBinaryNodeChild(node, 'enc')
 		const unavailableNode = getBinaryNodeChild(node, 'unavailable')
 
@@ -3105,6 +3088,40 @@ export const makeMessagesRecvSocket = (config: SocketConfig) => {
 		identifier: string,
 		exec: (node: BinaryNode) => Promise<void>
 	) => {
+		// Fast path: ack and drop ignored JIDs before entering the buffer/queue.
+		// Skips type='call' so call events are never silently dropped via
+		// shouldIgnoreJid (preserves InfiniteAPI's pre-existing behavior).
+		// Wrapped in try/catch so a throw from shouldIgnoreJid (user callback)
+		// or sendMessageAck (e.g. websocket closed) is routed through
+		// onUnexpectedError instead of becoming an unhandled rejection —
+		// matches the protection processNodeWithBuffer provides.
+		if (type !== 'call') {
+			try {
+				const from = node.attrs.from
+				let ignoreJid = from
+				if (type === 'receipt' && from) {
+					const attrs = node.attrs
+					const isLid = attrs.from!.includes('lid')
+					const isNodeFromMe = areJidsSameUser(
+						attrs.participant || attrs.from,
+						isLid ? authState.creds.me?.lid : authState.creds.me?.id
+					)
+					ignoreJid = !isNodeFromMe || isJidGroup(attrs.from) ? attrs.from : attrs.recipient
+				}
+
+				if (ignoreJid && ignoreJid !== S_WHATSAPP_NET && shouldIgnoreJid(ignoreJid)) {
+					// Plain ack (no NACK error code) preserves InfiniteAPI's prior
+					// behavior — ignored stanzas are an intentional drop, not a
+					// processing failure, so we don't want server-side retries.
+					await sendMessageAck(node)
+					return
+				}
+			} catch (error) {
+				onUnexpectedError(error as Error, identifier)
+				return
+			}
+		}
+
 		const isOffline = !!node.attrs.offline
 
 		if (isOffline) {

src/__tests__/binary/reconnection-sync-skip.test.ts

@@ -0,0 +1,146 @@
+import { jest } from '@jest/globals'
+import { proto, type WAMessage } from '../..'
+import { DEFAULT_CONNECTION_CONFIG } from '../../Defaults'
+import makeWASocket from '../../Socket'
+import { makeSession, mockWebSocket } from '../TestUtils/session'
+
+mockWebSocket()
+
+// chats.ts treats a connection as a reconnection when EITHER signal is true:
+//   1. authState.creds.accountSyncCounter > 0
+//      (at least one full history sync completed in a previous session)
+//   2. socketSkippedOfflineBuffer (forwarded from socket.ts as `skipOfflineBuffer`)
+//      (socket.ts already decided to skip the offline buffer, e.g. because
+//       routingInfo was stale and was discarded on startup)
+// On reconnection, AwaitingInitialSync is skipped and the buffer is flushed
+// immediately so live messages are not held in the initial-sync window.
+describe('Reconnection Sync Skip', () => {
+	it('should skip the history sync wait on reconnection (accountSyncCounter > 0)', async () => {
+		const { state, clear } = await makeSession()
+
+		state.creds.me = { id: '1234567890:1@s.whatsapp.net', name: 'Test User' }
+		// Simulate a session that has already synced before
+		state.creds.accountSyncCounter = 1
+
+		const sock = makeWASocket({
+			...DEFAULT_CONNECTION_CONFIG,
+			auth: state
+		})
+
+		const messageListener = jest.fn()
+		sock.ev.on('messages.upsert', messageListener)
+
+		// Simulate receiving pending notifications (triggers AwaitingInitialSync)
+		sock.ev.emit('connection.update', { receivedPendingNotifications: true })
+
+		// Emit a message immediately after — if the wait is skipped,
+		// the buffer should already be flushed and this message should be delivered.
+		const msg = proto.WebMessageInfo.fromObject({
+			key: { remoteJid: '1234567890@s.whatsapp.net', fromMe: false, id: 'MSG_AFTER_RECONNECT' },
+			messageTimestamp: Date.now() / 1000,
+			message: { conversation: 'Hello after reconnect' }
+		}) as WAMessage
+		sock.ev.emit('messages.upsert', { messages: [msg], type: 'notify' })
+
+		await new Promise(resolve => setTimeout(resolve, 50))
+
+		// Message should be delivered immediately, NOT buffered
+		expect(messageListener).toHaveBeenCalledTimes(1)
+		expect(messageListener).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: expect.arrayContaining([expect.objectContaining({ key: msg.key })]),
+				type: 'notify'
+			})
+		)
+
+		await sock.end(new Error('Test completed'))
+		await clear()
+	})
+
+	it('should skip the history sync wait when socketSkippedOfflineBuffer is true (stale routingInfo, accountSyncCounter === 0)', async () => {
+		const { state, clear } = await makeSession()
+
+		state.creds.me = { id: '1234567890:1@s.whatsapp.net', name: 'Test User' }
+		// Fresh-looking session from the counter perspective
+		state.creds.accountSyncCounter = 0
+		// But routingInfo is present and we ask the socket to discard it on start.
+		// socket.ts will set hadStaleRoutingInfo=true → skipOfflineBuffer=true,
+		// which chats.ts forwards as socketSkippedOfflineBuffer. Without this
+		// branch, the buffers would be misaligned (offline buffer skipped while
+		// AwaitingInitialSync still waits) and live messages would stall.
+		state.creds.routingInfo = Buffer.from([1, 2, 3, 4])
+
+		const sock = makeWASocket({
+			...DEFAULT_CONNECTION_CONFIG,
+			auth: state,
+			clearRoutingInfoOnStart: true
+		})
+
+		const messageListener = jest.fn()
+		sock.ev.on('messages.upsert', messageListener)
+
+		sock.ev.emit('connection.update', { receivedPendingNotifications: true })
+
+		const msg = proto.WebMessageInfo.fromObject({
+			key: { remoteJid: '1234567890@s.whatsapp.net', fromMe: false, id: 'MSG_AFTER_STALE_ROUTING' },
+			messageTimestamp: Date.now() / 1000,
+			message: { conversation: 'Hello after stale routing reconnect' }
+		}) as WAMessage
+		sock.ev.emit('messages.upsert', { messages: [msg], type: 'notify' })
+
+		await new Promise(resolve => setTimeout(resolve, 50))
+
+		expect(messageListener).toHaveBeenCalledTimes(1)
+		expect(messageListener).toHaveBeenCalledWith(
+			expect.objectContaining({
+				messages: expect.arrayContaining([expect.objectContaining({ key: msg.key })]),
+				type: 'notify'
+			})
+		)
+
+		await sock.end(new Error('Test completed'))
+		await clear()
+	})
+
+	it('should still wait for history sync on fresh pairing (both signals false)', async () => {
+		const { state, clear } = await makeSession()
+
+		state.creds.me = { id: '1234567890:1@s.whatsapp.net', name: 'Test User' }
+		// Fresh pairing — both reconnect signals are false:
+		// accountSyncCounter is 0 (default) and no stale routingInfo to clear.
+		state.creds.accountSyncCounter = 0
+
+		const sock = makeWASocket({
+			...DEFAULT_CONNECTION_CONFIG,
+			auth: state
+		})
+
+		const messageListener = jest.fn()
+		sock.ev.on('messages.upsert', messageListener)
+
+		sock.ev.emit('connection.update', { receivedPendingNotifications: true })
+
+		const msg = proto.WebMessageInfo.fromObject({
+			key: { remoteJid: '1234567890@s.whatsapp.net', fromMe: false, id: 'MSG_DURING_INITIAL_SYNC' },
+			messageTimestamp: Date.now() / 1000,
+			message: { conversation: 'Hello during initial sync' }
+		}) as WAMessage
+		sock.ev.emit('messages.upsert', { messages: [msg], type: 'notify' })
+
+		await new Promise(resolve => setTimeout(resolve, 50))
+
+		// Message should be BUFFERED (not delivered) because we're waiting for history sync
+		expect(messageListener).toHaveBeenCalledTimes(0)
+
+		// Drain the 2s AwaitingInitialSync timeout (chats.ts:1522) so its callback
+		// doesn't fire after Jest considers the test done — otherwise we get a
+		// "Cannot log after tests are done" warning from the post-teardown flush
+		// and the suite is flagged with --detectOpenHandles. After the timer
+		// fires, syncState becomes Online and the buffer flushes; that delivery
+		// is post-assertion and irrelevant to the test goal.
+		await new Promise(resolve => setTimeout(resolve, 2_100))
+
+		await sock.end(new Error('Test completed'))
+		await clear()
+	}, 10_000)
+})