agent-messenger 2.36.1 → 2.37.1

package/src/platforms/kakaotalk/client.test.ts

@@ -47,6 +47,23 @@ function makeLong(n: number): { low: number; high: number } {
   return { low: n, high: 0 }
 }
 
+function memberChannelInfo(
+  activeMembersCount: number,
+  displayMembers: Array<Record<string, unknown>> = [],
+  chatId = 100,
+) {
+  return {
+    statusCode: 0,
+    body: {
+      chatInfo: {
+        chatId: makeLong(chatId),
+        activeMembersCount,
+        displayMembers,
+      },
+    },
+  }
+}
+
 function resetAllMocks() {
   mockLogin.mockReset()
   mockGetChatList.mockReset()
@@ -111,6 +128,7 @@ describe('KakaoTalkClient', () => {
   })
 
   afterEach(() => {
+    expect(mockGetChatInfo).not.toHaveBeenCalled()
     resetAllMocks()
   })
 
@@ -224,6 +242,42 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    it('preserves an unknown non-empty string type from the login snapshot', async () => {
+      mockLogin.mockResolvedValue({
+        ...DEFAULT_LOGIN_RESULT,
+        chatDatas: [{ ...DEFAULT_LOGIN_RESULT.chatDatas[0], t: 'FutureChat' }],
+      })
+
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+
+      await expect(client.getChats()).resolves.toMatchObject([{ type: 'FutureChat' }])
+
+      client.close()
+    })
+
+    for (const invalidType of ['', true] as const) {
+      it(`rejects invalid ${JSON.stringify(invalidType)} type from the login snapshot`, async () => {
+        mockLogin.mockResolvedValue({
+          ...DEFAULT_LOGIN_RESULT,
+          chatDatas: [{ ...DEFAULT_LOGIN_RESULT.chatDatas[0], t: invalidType }],
+        })
+
+        const client = await new KakaoTalkClient().login({
+          oauthToken: 'token',
+          userId: 'user1',
+          deviceUuid: 'device1',
+        })
+
+        await expect(client.getChats()).rejects.toMatchObject({ code: 'get_chats_failed' })
+
+        client.close()
+      })
+    }
+
     it('populates last_message.author_name from paired chat.i / chat.k arrays', async () => {
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
       const chats = await client.getChats()
@@ -482,7 +536,9 @@ describe('KakaoTalkClient', () => {
       mockLogin.mockResolvedValue(emptyLoginResult)
 
       mockGetChatList.mockResolvedValueOnce({
+        statusCode: 0,
         body: {
+          status: 0,
           chatDatas: [
             {
               c: 100,
@@ -541,7 +597,9 @@ describe('KakaoTalkClient', () => {
       mockLogin.mockResolvedValue(loginResult)
 
       mockGetChatList.mockResolvedValueOnce({
+        statusCode: 0,
         body: {
+          status: 0,
           chatDatas: [
             {
               c: 300,
@@ -578,7 +636,9 @@ describe('KakaoTalkClient', () => {
 
       // Return a chat with same ID as login result
       mockGetChatList.mockResolvedValueOnce({
+        statusCode: 0,
         body: {
+          status: 0,
           chatDatas: [
             {
               c: 100, // Same as first login chat
@@ -612,7 +672,9 @@ describe('KakaoTalkClient', () => {
       mockLogin.mockResolvedValue(loginResult)
 
       mockGetChatList.mockResolvedValueOnce({
+        statusCode: 0,
         body: {
+          status: 0,
           chatDatas: [
             {
               c: makeLong(300),
@@ -644,6 +706,148 @@ describe('KakaoTalkClient', () => {
       client.close()
     })
 
+    it('collects every LCHATLIST page until an explicit EOF', async () => {
+      mockLogin.mockResolvedValue({ ...DEFAULT_LOGIN_RESULT, eof: false })
+      mockGetChatList
+        .mockResolvedValueOnce({
+          statusCode: 0,
+          body: {
+            status: 0,
+            chatDatas: [
+              {
+                c: 300,
+                t: 1,
+                k: ['Dave'],
+                i: [4],
+                a: 1,
+                n: 0,
+                o: 1698000000,
+                l: null,
+                ll: makeLong(100),
+              },
+            ],
+            lastTokenId: makeLong(1),
+            lastChatId: makeLong(300),
+            eof: false,
+          },
+        })
+        .mockResolvedValueOnce({
+          statusCode: 0,
+          body: {
+            status: 0,
+            chatDatas: [
+              {
+                c: 400,
+                t: 1,
+                k: ['Erin'],
+                i: [5],
+                a: 1,
+                n: 0,
+                o: 1697000000,
+                l: null,
+                ll: makeLong(90),
+              },
+            ],
+            lastTokenId: makeLong(2),
+            lastChatId: makeLong(400),
+            eof: true,
+          },
+        })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats({ all: true })
+
+      expect(chats.map((chat) => chat.chat_id)).toEqual(['100', '200', '300', '400'])
+      expect(mockGetChatList).toHaveBeenCalledTimes(2)
+
+      client.close()
+    })
+
+    it('fails closed when LCHATLIST has a nonzero response status', async () => {
+      mockLogin.mockResolvedValue({ ...DEFAULT_LOGIN_RESULT, eof: false })
+      mockGetChatList.mockResolvedValueOnce({
+        statusCode: 503,
+        body: { status: 0, chatDatas: [], lastTokenId: makeLong(1), lastChatId: makeLong(300), eof: true },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChats({ all: true })).rejects.toMatchObject({
+        code: 'get_chats_failed',
+        responseFailureKind: 'provider_rejection',
+        serverStatus: 503,
+      })
+
+      client.close()
+    })
+
+    it('fails closed on an empty non-EOF LCHATLIST page', async () => {
+      mockLogin.mockResolvedValue({ ...DEFAULT_LOGIN_RESULT, eof: false })
+      mockGetChatList.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { status: 0, chatDatas: [], lastTokenId: makeLong(1), lastChatId: makeLong(300), eof: false },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChats({ all: true })).rejects.toMatchObject({ code: 'get_chats_failed' })
+      expect(mockGetChatList).toHaveBeenCalledTimes(1)
+
+      client.close()
+    })
+
+    it('fails closed when LCHATLIST reaches the page cap without EOF', async () => {
+      mockLogin.mockResolvedValue({ ...DEFAULT_LOGIN_RESULT, eof: false })
+      let page = 0
+      mockGetChatList.mockImplementation(async () => {
+        page++
+        return {
+          statusCode: 0,
+          body: {
+            status: 0,
+            chatDatas: [
+              {
+                c: 1000 + page,
+                t: 1,
+                k: [`Room ${page}`],
+                i: [1000 + page],
+                a: 1,
+                n: 0,
+                o: 1600000000 - page,
+                l: null,
+                ll: makeLong(page),
+              },
+            ],
+            lastTokenId: makeLong(page),
+            lastChatId: makeLong(1000 + page),
+            eof: false,
+          },
+        }
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChats({ all: true })).rejects.toMatchObject({ code: 'get_chats_failed' })
+      expect(mockGetChatList).toHaveBeenCalledTimes(50)
+
+      client.close()
+    })
+
+    it('preserves non-all search compatibility on an empty non-EOF page', async () => {
+      mockLogin.mockResolvedValue({ ...DEFAULT_LOGIN_RESULT, eof: false })
+      mockGetChatList.mockResolvedValueOnce({
+        body: { chatDatas: [], lastTokenId: makeLong(1), lastChatId: makeLong(300), eof: false },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chats = await client.getChats({ search: 'Alice' })
+
+      expect(chats.map((chat) => chat.chat_id)).toEqual(['100'])
+      expect(mockGetChatList).toHaveBeenCalledTimes(1)
+
+      client.close()
+    })
+
     it('wraps errors as KakaoTalkError', async () => {
       mockLogin.mockRejectedValue(new Error('Connection refused'))
 
@@ -769,96 +973,836 @@ describe('KakaoTalkClient', () => {
       })
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
-      const title = await client.getChatTitle('500')
+      const title = await client.getChatTitle('500')
+
+      expect(title).toBe('User Set Title')
+      expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('returns null when INFOLINK fails for open chats', async () => {
+      const openChatLogin = {
+        chatDatas: [
+          {
+            c: 500,
+            t: 'OD',
+            li: makeLong(7777),
+            k: [],
+            i: [],
+            a: 1,
+            n: 0,
+            o: 1700000000,
+            l: null,
+            ll: makeLong(1),
+          },
+        ],
+        lastTokenId: makeLong(0),
+        lastChatId: makeLong(0),
+        eof: true,
+      }
+      mockLogin.mockResolvedValue(openChatLogin)
+      mockGetChannelInfo.mockResolvedValueOnce({ body: { chatInfo: { chatMetas: [] } } })
+      mockGetOpenLinkInfo.mockRejectedValueOnce(new Error('INFOLINK timeout'))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const title = await client.getChatTitle('500')
+
+      expect(title).toBeNull()
+
+      client.close()
+    })
+
+    it('returns null when open chat has no link id (li missing)', async () => {
+      const openChatLogin = {
+        chatDatas: [
+          {
+            c: 500,
+            t: 'OM',
+            k: [],
+            i: [],
+            a: 1,
+            n: 0,
+            o: 1700000000,
+            l: null,
+            ll: makeLong(1),
+          },
+        ],
+        lastTokenId: makeLong(0),
+        lastChatId: makeLong(0),
+        eof: true,
+      }
+      mockLogin.mockResolvedValue(openChatLogin)
+      mockGetChannelInfo.mockResolvedValueOnce({ body: { chatInfo: { chatMetas: [] } } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const title = await client.getChatTitle('500')
+
+      expect(title).toBeNull()
+      expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('wraps getChatList failure as KakaoTalkError with code get_chats_failed', async () => {
+      const loginResult = { ...DEFAULT_LOGIN_RESULT, eof: false }
+      mockLogin.mockResolvedValue(loginResult)
+      mockGetChatList.mockRejectedValue(new Error('Network error'))
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      try {
+        await client.getChats({ all: true })
+        expect.unreachable('should have thrown')
+      } catch (e) {
+        expect(e).toBeInstanceOf(KakaoTalkError)
+        expect((e as KakaoTalkError).code).toBe('get_chats_failed')
+      }
+
+      client.close()
+    })
+  })
+
+  describe('getChat', () => {
+    it('returns one fully normalized late chat from read-only CHATINFO', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatInfo: {
+            chatId: makeLong(300),
+            type: 11,
+            left: false,
+            activeMembersCount: 2,
+            newMessageCount: 4,
+            invalidNewMessageCount: false,
+            lastLogId: makeLong(77),
+            lastSeenLogId: makeLong(73),
+            lastChatLog: {
+              logId: makeLong(77),
+              authorId: 42,
+              type: 1,
+              message: 'latest',
+              sendAt: 1700000077,
+            },
+            displayMembers: [
+              { userId: makeLong(42), nickName: 'Alice' },
+              { userId: makeLong(43), nickName: 'Bob' },
+            ],
+            chatMetas: [{ type: 3, content: 'Late room' }],
+            pushAlert: true,
+          },
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const chat = await client.getChat('300')
+
+      expect(chat).toEqual({
+        chat_id: '300',
+        type: 11,
+        display_name: 'Alice, Bob',
+        title: 'Late room',
+        active_members: 2,
+        unread_count: 4,
+        last_message: {
+          author_id: 42,
+          author_name: 'Alice',
+          message: 'latest',
+          sent_at: 1700000077,
+        },
+      })
+
+      client.close()
+    })
+
+    it('classifies an explicit CHATINFO header rejection without exposing response contents', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({ statusCode: 403, body: {} })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'provider_rejection',
+        responseFailureKind: 'provider_rejection',
+        responseStatusSource: 'packet',
+        serverStatus: 403,
+      })
+
+      client.close()
+    })
+
+    it('classifies an explicit CHATINFO body rejection and preserves its numeric status', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({ statusCode: 0, body: { status: -404 } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'provider_rejection',
+        responseFailureKind: 'provider_rejection',
+        responseStatusSource: 'body',
+        serverStatus: -404,
+      })
+
+      client.close()
+    })
+
+    it('does not expose rejected CHATINFO body contents through public error metadata', async () => {
+      const secretSentinel = 'secret-sentinel-do-not-emit'
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { status: -404, secret: secretSentinel },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      let error: unknown
+      try {
+        await client.getChat('300')
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      const publicError = error as KakaoTalkError
+      expect(publicError).toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'provider_rejection',
+        responseFailureKind: 'provider_rejection',
+        responseStatusSource: 'body',
+        serverStatus: -404,
+      })
+      expect(publicError.message).not.toContain(secretSentinel)
+      expect(JSON.stringify(publicError)).not.toContain(secretSentinel)
+      expect(JSON.stringify(publicError.cause)).not.toContain(secretSentinel)
+
+      client.close()
+    })
+
+    it('classifies synthetic connection-close status -1 as transient rather than provider rejection', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({ statusCode: -1, body: { error: 'connection closed' } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'synthetic_connection_close',
+        responseFailureKind: 'transient_or_unknown',
+        responseStatusSource: 'packet',
+        serverStatus: -1,
+      })
+
+      client.close()
+    })
+
+    it('does not classify status -1 with a nonmatching body as a synthetic connection close', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({ statusCode: -1, body: { error: 'provider rejected' } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'provider_rejection',
+        responseFailureKind: 'provider_rejection',
+        responseStatusSource: 'packet',
+        serverStatus: -1,
+      })
+
+      client.close()
+    })
+
+    it('classifies a thrown CHATINFO transport failure as transient or unknown', async () => {
+      const secretSentinel = 'secret-transport-body-do-not-emit'
+      mockGetChannelInfo.mockRejectedValueOnce(
+        Object.assign(new Error('socket unavailable'), { body: { secret: secretSentinel } }),
+      )
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      let error: unknown
+      try {
+        await client.getChat('300')
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      expect(error).toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'transport_or_unknown',
+        responseFailureKind: 'transient_or_unknown',
+      })
+      const serialized = JSON.stringify(error)
+      expect(serialized).not.toContain(secretSentinel)
+      expect(serialized).not.toContain('body')
+      expect(serialized).not.toContain('message')
+      expect(serialized).not.toContain('cause')
+
+      client.close()
+    })
+
+    it('classifies a successful CHATINFO response without chatInfo as structurally absent', async () => {
+      const secretSentinel = 'secret-chat-body-do-not-emit'
+      mockGetChannelInfo.mockResolvedValueOnce({ statusCode: 0, body: { secret: secretSentinel } })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      let error: unknown
+      try {
+        await client.getChat('300')
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      expect(error).toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'chat_info_absent',
+        responseFailureKind: 'transient_or_unknown',
+      })
+      const serialized = JSON.stringify(error)
+      expect(serialized).not.toContain(secretSentinel)
+      expect(serialized).not.toContain('body')
+      expect(serialized).not.toContain('message')
+      expect(serialized).not.toContain('cause')
+
+      client.close()
+    })
+
+    it('classifies a successful CHATINFO response with null chatInfo as structurally absent', async () => {
+      const secretSentinel = 'secret-null-chat-body-do-not-emit'
+      const chatIdSentinel = '987654321012345678'
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { chatInfo: null, secret: secretSentinel },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      let error: unknown
+      try {
+        await client.getChat(chatIdSentinel)
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      expect(error).toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'chat_info_absent',
+        responseFailureKind: 'transient_or_unknown',
+      })
+      const serialized = JSON.stringify(error)
+      expect(serialized).not.toContain(secretSentinel)
+      expect(serialized).not.toContain('body')
+      expect(serialized).not.toContain('message')
+      expect(serialized).not.toContain('cause')
+      expect(serialized).not.toContain('chatId')
+      expect(serialized).not.toContain(chatIdSentinel)
+
+      client.close()
+    })
+
+    it('classifies exact CHATINFO left=true as structurally absent without exposing response contents', async () => {
+      const secretSentinel = 'secret-left-chat-body-do-not-emit'
+      const nativeChatIdSentinel = '987654321'
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatInfo: {
+            left: true,
+            chatId: makeLong(Number(nativeChatIdSentinel)),
+            secret: secretSentinel,
+          },
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      let error: unknown
+      try {
+        await client.getChat(nativeChatIdSentinel)
+      } catch (cause) {
+        error = cause
+      }
+
+      expect(error).toBeInstanceOf(KakaoTalkError)
+      expect(error).toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'chat_info_absent',
+        responseFailureKind: 'transient_or_unknown',
+      })
+      const publicError = error as KakaoTalkError
+      const serialized = JSON.stringify(publicError)
+      expect(publicError.message).not.toContain(secretSentinel)
+      expect(publicError.message).not.toContain(nativeChatIdSentinel)
+      expect(serialized).not.toContain(secretSentinel)
+      expect(serialized).not.toContain(nativeChatIdSentinel)
+
+      client.close()
+    })
+
+    for (const [label, chatInfo] of [
+      ['mismatched chatId', { left: true, chatId: makeLong(301) }],
+      ['missing chatId', { left: true }],
+      ['invalid chatId', { left: true, chatId: { invalid: true } }],
+    ] as const) {
+      it(`does not classify CHATINFO left=true with ${label} as structurally absent`, async () => {
+        mockGetChannelInfo.mockResolvedValueOnce({
+          statusCode: 0,
+          body: { chatInfo },
+        })
+
+        const client = await new KakaoTalkClient().login({
+          oauthToken: 'token',
+          userId: 'user1',
+          deviceUuid: 'device1',
+        })
+
+        await expect(client.getChat('300')).rejects.toMatchObject({
+          code: 'get_chat_failed',
+          getChatFailureReason: 'transport_or_unknown',
+          responseFailureKind: 'transient_or_unknown',
+        })
+
+        client.close()
+      })
+    }
+
+    for (const [label, chatInfo] of [
+      ['left=false', { left: false }],
+      ['left missing', {}],
+      ['left nonboolean', { left: 'true' }],
+    ] as const) {
+      it(`does not classify malformed successful CHATINFO with ${label} as structurally absent`, async () => {
+        mockGetChannelInfo.mockResolvedValueOnce({
+          statusCode: 0,
+          body: { chatInfo },
+        })
+
+        const client = await new KakaoTalkClient().login({
+          oauthToken: 'token',
+          userId: 'user1',
+          deviceUuid: 'device1',
+        })
+
+        await expect(client.getChat('300')).rejects.toMatchObject({
+          code: 'get_chat_failed',
+          getChatFailureReason: 'transport_or_unknown',
+          responseFailureKind: 'transient_or_unknown',
+        })
+
+        client.close()
+      })
+    }
+
+    it('classifies malformed successful CHATINFO chatInfo as transport or unknown', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { chatInfo: { chatId: makeLong(300) } },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'transport_or_unknown',
+        responseFailureKind: 'transient_or_unknown',
+      })
+
+      client.close()
+    })
+
+    for (const openChatType of ['OM', 'OD'] as const) {
+      it(`preserves ${openChatType} and falls back to INFOLINK when CHATINFO has no title`, async () => {
+        mockGetChannelInfo.mockResolvedValueOnce({
+          statusCode: 0,
+          body: {
+            chatInfo: {
+              chatId: makeLong(300),
+              type: openChatType,
+              activeMembersCount: 2,
+              newMessageCount: 0,
+              invalidNewMessageCount: false,
+              lastLogId: makeLong(77),
+              lastSeenLogId: makeLong(73),
+              lastChatLog: null,
+              displayMembers: [
+                { userId: makeLong(42), nickName: 'Alice' },
+                { userId: makeLong(43), nickName: 'Bob' },
+              ],
+              chatMetas: [],
+              li: makeLong(7777),
+              pushAlert: true,
+            },
+          },
+        })
+        mockGetOpenLinkInfo.mockResolvedValueOnce({ body: { ols: [{ ln: 'Open Group Title' }] } })
+
+        const client = await new KakaoTalkClient().login({
+          oauthToken: 'token',
+          userId: 'user1',
+          deviceUuid: 'device1',
+        })
+        const chat = await client.getChat('300')
+
+        expect(chat).toEqual({
+          chat_id: '300',
+          type: openChatType,
+          display_name: 'Alice, Bob',
+          title: 'Open Group Title',
+          active_members: 2,
+          unread_count: 0,
+          last_message: null,
+        })
+        expect(mockGetOpenLinkInfo).toHaveBeenCalledTimes(1)
+
+        client.close()
+      })
+    }
+
+    it('falls back to INFOLINK for a numeric open-chat code', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatInfo: {
+            chatId: makeLong(300),
+            type: 13,
+            activeMembersCount: 2,
+            newMessageCount: 0,
+            invalidNewMessageCount: false,
+            lastLogId: makeLong(77),
+            lastSeenLogId: makeLong(73),
+            lastChatLog: null,
+            displayMembers: [],
+            chatMetas: [],
+            li: makeLong(7777),
+            pushAlert: true,
+          },
+        },
+      })
+      mockGetOpenLinkInfo.mockResolvedValueOnce({ body: { ols: [{ ln: 'Numeric Open Title' }] } })
+
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+      const chat = await client.getChat('300')
+
+      expect(chat.type).toBe(13)
+      expect(chat.title).toBe('Numeric Open Title')
+      expect(mockGetOpenLinkInfo).toHaveBeenCalledTimes(1)
+
+      client.close()
+    })
+
+    for (const normalChatType of ['DirectChat', 'MultiChat', 'PlusChat', 'MemoChat'] as const) {
+      it(`preserves donor-defined ${normalChatType} without contacting INFOLINK`, async () => {
+        mockGetChannelInfo.mockResolvedValueOnce({
+          statusCode: 0,
+          body: {
+            chatInfo: {
+              chatId: makeLong(300),
+              type: normalChatType,
+              activeMembersCount: 2,
+              newMessageCount: 0,
+              invalidNewMessageCount: false,
+              lastLogId: makeLong(1),
+              lastSeenLogId: makeLong(0),
+              displayMembers: [],
+              chatMetas: [],
+              li: makeLong(7777),
+              pushAlert: true,
+            },
+          },
+        })
+
+        const client = await new KakaoTalkClient().login({
+          oauthToken: 'token',
+          userId: 'user1',
+          deviceUuid: 'device1',
+        })
+
+        await expect(client.getChat('300')).resolves.toEqual({
+          chat_id: '300',
+          type: normalChatType,
+          display_name: null,
+          title: null,
+          active_members: 2,
+          unread_count: 0,
+          last_message: null,
+        })
+        expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+
+        client.close()
+      })
+    }
+
+    it('rejects an empty string CHATINFO type without contacting INFOLINK', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatInfo: {
+            chatId: makeLong(300),
+            type: '',
+            activeMembersCount: 2,
+            newMessageCount: 0,
+            invalidNewMessageCount: false,
+            lastLogId: makeLong(1),
+            lastSeenLogId: makeLong(0),
+            displayMembers: [],
+            chatMetas: [],
+            pushAlert: true,
+          },
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({
+        code: 'get_chat_failed',
+        getChatFailureReason: 'transport_or_unknown',
+        responseFailureKind: 'transient_or_unknown',
+      })
+      expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('preserves an unknown non-empty string CHATINFO type without contacting INFOLINK', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatInfo: {
+            chatId: makeLong(300),
+            type: 'UnknownChat',
+            activeMembersCount: 2,
+            newMessageCount: 0,
+            invalidNewMessageCount: false,
+            lastLogId: makeLong(1),
+            lastSeenLogId: makeLong(0),
+            displayMembers: [],
+            chatMetas: [],
+            pushAlert: true,
+          },
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+
+      await expect(client.getChat('300')).resolves.toEqual({
+        chat_id: '300',
+        type: 'UnknownChat',
+        display_name: null,
+        title: null,
+        active_members: 2,
+        unread_count: 0,
+        last_message: null,
+      })
+      expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('rejects a CHATINFO response bound to a different chat id', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatInfo: {
+            chatId: makeLong(999),
+            type: 11,
+            activeMembersCount: 2,
+            newMessageCount: 0,
+            invalidNewMessageCount: false,
+            lastLogId: makeLong(1),
+            lastSeenLogId: makeLong(0),
+            displayMembers: [],
+            chatMetas: [],
+            pushAlert: true,
+          },
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('300')).rejects.toMatchObject({ code: 'get_chat_failed' })
+
+      client.close()
+    })
+
+    it('rejects an invalid chat id before opening a LOCO session', async () => {
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+
+      await expect(client.getChat('not-a-number')).rejects.toMatchObject({ code: 'invalid_chat_id' })
+      expect(mockLogin).not.toHaveBeenCalled()
+      expect(mockGetChannelInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+  })
+
+  describe('getMessages', () => {
+    it('returns a lossless forward page without discarding the oldest messages', async () => {
+      mockGetChatLogs.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          status: 0,
+          chatLogs: Array.from({ length: 5 }, (_, index) => ({
+            logId: makeLong(index + 1),
+            chatId: 100,
+            type: 1,
+            authorId: 42,
+            message: `message-${index + 1}`,
+            sendAt: 1700000000 + index,
+          })),
+          eof: true,
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const page = await client.getMessagePage('100', { count: 2 })
+
+      expect(page.messages.map((message) => message.log_id)).toEqual(['1', '2'])
+      expect(page.next_cursor).toBe('2')
+      expect(page.complete).toBe(false)
+
+      client.close()
+    })
+
+    it('returns a complete forward page when the protocol page is exhausted', async () => {
+      mockGetChatLogs.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          status: 0,
+          chatLogs: [
+            { logId: makeLong(11), chatId: 100, type: 1, authorId: 42, message: 'eleven', sendAt: 11 },
+            { logId: makeLong(10), chatId: 100, type: 1, authorId: 42, message: 'ten', sendAt: 10 },
+          ],
+          eof: true,
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const page = await client.getMessagePage('100', { from: '9', count: 10 })
 
-      expect(title).toBe('User Set Title')
-      expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+      expect(page.messages.map((message) => message.log_id)).toEqual(['10', '11'])
+      expect(page.next_cursor).toBe('11')
+      expect(page.complete).toBe(true)
 
       client.close()
     })
 
-    it('returns null when INFOLINK fails for open chats', async () => {
-      const openChatLogin = {
-        chatDatas: [
-          {
-            c: 500,
-            t: 'OD',
-            li: makeLong(7777),
-            k: [],
-            i: [],
-            a: 1,
-            n: 0,
-            o: 1700000000,
-            l: null,
-            ll: makeLong(1),
-          },
-        ],
-        lastTokenId: makeLong(0),
-        lastChatId: makeLong(0),
-        eof: true,
-      }
-      mockLogin.mockResolvedValue(openChatLogin)
-      mockGetChannelInfo.mockResolvedValueOnce({ body: { chatInfo: { chatMetas: [] } } })
-      mockGetOpenLinkInfo.mockRejectedValueOnce(new Error('INFOLINK timeout'))
+    it('continues exclusively after the supplied cursor when the server repeats it', async () => {
+      mockGetChatLogs.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          status: 0,
+          chatLogs: [
+            { logId: makeLong(2), chatId: 100, type: 1, authorId: 42, message: 'repeat', sendAt: 2 },
+            { logId: makeLong(3), chatId: 100, type: 1, authorId: 42, message: 'three', sendAt: 3 },
+            { logId: makeLong(4), chatId: 100, type: 1, authorId: 42, message: 'four', sendAt: 4 },
+          ],
+          eof: true,
+        },
+      })
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
-      const title = await client.getChatTitle('500')
+      const page = await client.getMessagePage('100', { from: '2', count: 10 })
 
-      expect(title).toBeNull()
+      expect(page.messages.map((message) => message.log_id)).toEqual(['3', '4'])
+      expect(page.next_cursor).toBe('4')
+      expect(page.complete).toBe(true)
 
       client.close()
     })
 
-    it('returns null when open chat has no link id (li missing)', async () => {
-      const openChatLogin = {
-        chatDatas: [
-          {
-            c: 500,
-            t: 'OM',
-            k: [],
-            i: [],
-            a: 1,
-            n: 0,
-            o: 1700000000,
-            l: null,
-            ll: makeLong(1),
+    it('does not report completion when the protocol makes no cursor progress', async () => {
+      mockGetChatLogs.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { status: 0, chatLogs: [], eof: false },
+      })
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatInfo: {
+            chatId: makeLong(100),
+            type: 11,
+            activeMembersCount: 2,
+            newMessageCount: 0,
+            invalidNewMessageCount: false,
+            lastLogId: makeLong(999),
+            lastSeenLogId: makeLong(0),
+            displayMembers: [],
+            chatMetas: [],
+            pushAlert: true,
           },
-        ],
-        lastTokenId: makeLong(0),
-        lastChatId: makeLong(0),
-        eof: true,
-      }
-      mockLogin.mockResolvedValue(openChatLogin)
-      mockGetChannelInfo.mockResolvedValueOnce({ body: { chatInfo: { chatMetas: [] } } })
+        },
+      })
+      mockSyncMessages.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { status: 0, chatLogs: [], isOK: false },
+      })
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
-      const title = await client.getChatTitle('500')
+      const page = await client.getMessagePage('100', { from: '9', count: 10 })
 
-      expect(title).toBeNull()
-      expect(mockGetOpenLinkInfo).not.toHaveBeenCalled()
+      expect(page).toEqual({ messages: [], next_cursor: null, complete: false })
 
       client.close()
     })
 
-    it('wraps getChatList failure as KakaoTalkError with code get_chats_failed', async () => {
-      const loginResult = { ...DEFAULT_LOGIN_RESULT, eof: false }
-      mockLogin.mockResolvedValue(loginResult)
-      mockGetChatList.mockRejectedValue(new Error('Network error'))
+    it('uses read-only CHATINFO to paginate a late room missing from the login snapshot', async () => {
+      mockLogin.mockResolvedValueOnce({ ...structuredClone(DEFAULT_LOGIN_RESULT), chatDatas: [] })
+      mockGetChatLogs.mockResolvedValueOnce({
+        statusCode: 0,
+        body: { status: 0, chatLogs: [], eof: true },
+      })
+      mockGetChannelInfo.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          chatInfo: {
+            chatId: makeLong(300),
+            type: 11,
+            activeMembersCount: 2,
+            newMessageCount: 1,
+            invalidNewMessageCount: false,
+            lastLogId: makeLong(12),
+            lastSeenLogId: makeLong(0),
+            displayMembers: [],
+            chatMetas: [],
+            pushAlert: true,
+          },
+        },
+      })
+      mockSyncMessages.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          status: 0,
+          isOK: true,
+          chatLogs: [{ logId: makeLong(12), chatId: 300, type: 1, authorId: 42, message: 'late', sendAt: 12 }],
+        },
+      })
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
-      try {
-        await client.getChats({ all: true })
-        expect.unreachable('should have thrown')
-      } catch (e) {
-        expect(e).toBeInstanceOf(KakaoTalkError)
-        expect((e as KakaoTalkError).code).toBe('get_chats_failed')
-      }
+      const page = await client.getMessagePage('300', { from: '11', count: 10 })
+
+      expect(page.messages.map((message) => message.log_id)).toEqual(['12'])
+      expect(page.next_cursor).toBe('12')
+      expect(page.complete).toBe(true)
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
+      expect(mockSyncMessages.mock.calls[0]?.[2]?.toString()).toBe('11')
+      expect(mockSyncMessages.mock.calls[0]?.[3]?.toString()).toBe('12')
 
       client.close()
     })
-  })
 
-  describe('getMessages', () => {
     it('falls back to SYNCMSG when MCHATLOGS succeeds with an empty result', async () => {
       const loginResult = structuredClone(DEFAULT_LOGIN_RESULT)
       loginResult.chatDatas[0]!.ll = makeLong(10)
@@ -1610,7 +2554,8 @@ describe('KakaoTalkClient', () => {
 
   describe('getMembers / getMembersByIds', () => {
     it('returns formatted members from GETMEM with normalized fields', async () => {
-      mockGetAllMembers.mockResolvedValueOnce({
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(2)).mockResolvedValueOnce(memberChannelInfo(2))
+      mockGetAllMembers.mockResolvedValue({
         statusCode: 0,
         body: {
           members: [
@@ -1670,12 +2615,14 @@ describe('KakaoTalkClient', () => {
         open_profile_link_id: '99',
         open_permission: 4,
       })
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
 
       client.close()
     })
 
-    it('merges CHATONROOM members when GETMEM returns a partial member list', async () => {
-      mockGetAllMembers.mockResolvedValueOnce({
+    it('rejects a partial GETMEM snapshot without entering the room', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(3)).mockResolvedValueOnce(memberChannelInfo(3))
+      mockGetAllMembers.mockResolvedValue({
         statusCode: 0,
         body: {
           members: [
@@ -1689,43 +2636,223 @@ describe('KakaoTalkClient', () => {
           token: 0,
         },
       })
-      mockGetChatInfo.mockResolvedValueOnce({
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      await expect(client.getMembers('100')).rejects.toMatchObject({
+        code: 'get_members_failed',
+      })
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('returns a stable empty snapshot for a zero-member room without CHATONROOM', async () => {
+      mockGetChannelInfo.mockResolvedValue(memberChannelInfo(0))
+      mockGetAllMembers.mockResolvedValue({
+        statusCode: 0,
+        body: { members: [] },
+      })
+
+      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
+      const snapshot = await client.getMemberSnapshot('100')
+
+      expect(snapshot).toMatchObject({
+        chat_id: '100',
+        active_members: 0,
+        complete: true,
+        consistency_basis: 'stable_double_read_chatinfo_getmem',
+      })
+      expect(snapshot.members).toEqual([])
+      expect(mockGetAllMembers).toHaveBeenCalledTimes(2)
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('returns a stable CHATINFO GETMEM snapshot without CHATONROOM', async () => {
+      const visible = [
+        {
+          userId: makeLong(42),
+          nickName: 'Alice',
+          type: 100,
+        },
+      ]
+      mockGetChannelInfo
+        .mockResolvedValueOnce(memberChannelInfo(2, visible))
+        .mockResolvedValueOnce(memberChannelInfo(2, visible))
+      mockGetAllMembers.mockResolvedValue({
+        statusCode: 0,
+        body: {
+          members: [
+            visible[0],
+            {
+              userId: makeLong(43),
+              nickName: 'Bob',
+              type: 100,
+            },
+          ],
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+      const snapshot = await client.getMemberSnapshot('100')
+
+      expect(snapshot).toMatchObject({
+        chat_id: '100',
+        active_members: 2,
+        complete: true,
+        consistency_basis: 'stable_double_read_chatinfo_getmem',
+      })
+      expect(snapshot.members.map((member) => member.user_id)).toEqual(['42', '43'])
+      expect(mockGetAllMembers).toHaveBeenCalledTimes(2)
+      expect(mockGetChannelInfo).toHaveBeenCalledTimes(2)
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('fails closed when active membership changes across the snapshot', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(2)).mockResolvedValueOnce(memberChannelInfo(3))
+      mockGetAllMembers.mockResolvedValue({
         statusCode: 0,
         body: {
-          status: 0,
-          m: [
-            { userId: makeLong(42), nickName: 'Alice From Room', type: 100 },
-            { userId: makeLong(43), nickName: 'Bob', type: 100 },
-            { userId: makeLong(44), nickName: 'Carol', type: 100 },
+          members: [
+            { userId: makeLong(42), nickName: 'Alice' },
+            { userId: makeLong(43), nickName: 'Bob' },
           ],
         },
       })
 
-      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
-      const members = await client.getMembers('100')
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+      await expect(client.getMemberSnapshot('100')).rejects.toMatchObject({
+        code: 'get_member_snapshot_failed',
+      })
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
 
-      expect(members.map((member) => member.user_id)).toEqual(['42', '43', '44'])
-      expect(members[0].nickname).toBe('Alice')
-      expect(members[0].profile_image_url).toBe('https://kakao.com/p/alice.jpg')
-      expect(members[1].nickname).toBe('Bob')
-      expect(members[2].nickname).toBe('Carol')
+      client.close()
+    })
+
+    it('fails closed on a same-cardinality hidden member swap', async () => {
+      const visible = [{ userId: makeLong(42), nickName: 'Visible' }]
+      mockGetChannelInfo
+        .mockResolvedValueOnce(memberChannelInfo(2, visible))
+        .mockResolvedValueOnce(memberChannelInfo(2, visible))
+      mockGetAllMembers
+        .mockResolvedValueOnce({
+          statusCode: 0,
+          body: {
+            members: [visible[0], { userId: makeLong(43), nickName: 'Departed' }],
+          },
+        })
+        .mockResolvedValueOnce({
+          statusCode: 0,
+          body: {
+            members: [visible[0], { userId: makeLong(44), nickName: 'Joined' }],
+          },
+        })
+
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+      await expect(client.getMemberSnapshot('100')).rejects.toMatchObject({
+        code: 'get_member_snapshot_failed',
+      })
 
       client.close()
     })
 
-    it('returns empty array when GETMEM returns no members', async () => {
-      mockGetAllMembers.mockResolvedValueOnce({ statusCode: 0, body: {} })
+    it('fails closed on malformed CHATINFO member identity', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(1, [{ userId: {}, nickName: 'Malformed' }]))
 
-      const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
-      const members = await client.getMembers('100')
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+      await expect(client.getMemberSnapshot('100')).rejects.toMatchObject({
+        code: 'get_member_snapshot_failed',
+      })
+      expect(mockGetAllMembers).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('fails closed on malformed GETMEM member identity', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(1))
+      mockGetAllMembers.mockResolvedValueOnce({
+        statusCode: 0,
+        body: {
+          members: [{ userId: '42', nickName: 'Malformed string id' }],
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+      await expect(client.getMemberSnapshot('100')).rejects.toMatchObject({
+        code: 'get_member_snapshot_failed',
+      })
+
+      client.close()
+    })
+
+    it('fails closed on duplicate GETMEM identity without CHATONROOM', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(2))
+      mockGetAllMembers.mockResolvedValue({
+        statusCode: 0,
+        body: {
+          members: [
+            { userId: makeLong(42), nickName: 'Alice' },
+            { userId: makeLong(42), nickName: 'Duplicate' },
+          ],
+        },
+      })
+
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+      await expect(client.getMemberSnapshot('100')).rejects.toMatchObject({
+        code: 'get_member_snapshot_failed',
+      })
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
+
+      client.close()
+    })
+
+    it('fails closed on CHATINFO chat id mismatch before GETMEM', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(1, [], 101))
 
-      expect(members).toEqual([])
+      const client = await new KakaoTalkClient().login({
+        oauthToken: 'token',
+        userId: 'user1',
+        deviceUuid: 'device1',
+      })
+      await expect(client.getMemberSnapshot('100')).rejects.toMatchObject({
+        code: 'get_member_snapshot_failed',
+      })
+      expect(mockGetAllMembers).not.toHaveBeenCalled()
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
 
       client.close()
     })
 
     it('normalizes missing user_type to null and treats pli=0 as absent', async () => {
-      mockGetAllMembers.mockResolvedValueOnce({
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(3)).mockResolvedValueOnce(memberChannelInfo(3))
+      mockGetAllMembers.mockResolvedValue({
         statusCode: 0,
         body: {
           members: [
@@ -1749,6 +2876,7 @@ describe('KakaoTalkClient', () => {
     })
 
     it('wraps GETMEM failures as KakaoTalkError get_members_failed', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(1))
       mockGetAllMembers.mockRejectedValueOnce(new Error('Network error'))
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
@@ -1764,6 +2892,7 @@ describe('KakaoTalkClient', () => {
     })
 
     it('throws on synthetic disconnect packet from GETMEM (statusCode != 0)', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(1))
       mockGetAllMembers.mockResolvedValueOnce({
         statusCode: -1,
         body: { error: 'connection closed' },
@@ -1782,6 +2911,7 @@ describe('KakaoTalkClient', () => {
     })
 
     it('throws on GETMEM body.status nonzero', async () => {
+      mockGetChannelInfo.mockResolvedValueOnce(memberChannelInfo(1))
       mockGetAllMembers.mockResolvedValueOnce({
         statusCode: 0,
         body: { status: -500 },
@@ -1893,6 +3023,8 @@ describe('KakaoTalkClient', () => {
         expect((e as KakaoTalkError).code).toBe('invalid_chat_id')
       }
       expect(mockGetAllMembers).not.toHaveBeenCalled()
+      expect(mockGetChannelInfo).not.toHaveBeenCalled()
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
       expect(mockLogin).not.toHaveBeenCalled()
 
       client.close()
@@ -1959,17 +3091,22 @@ describe('KakaoTalkClient', () => {
         if (handler) handler()
         return Promise.resolve({ statusCode: -1, body: { error: 'connection closed' } })
       })
-      mockGetAllMembers.mockResolvedValueOnce({
+      mockGetAllMembers.mockResolvedValue({
         statusCode: 0,
         body: { members: [{ userId: makeLong(42), nickName: 'Alice', type: 100 }] },
       })
+      mockGetChannelInfo
+        .mockResolvedValueOnce(memberChannelInfo(1))
+        .mockResolvedValueOnce(memberChannelInfo(1))
+        .mockResolvedValueOnce(memberChannelInfo(1))
 
       const client = await new KakaoTalkClient().login({ oauthToken: 'token', userId: 'user1', deviceUuid: 'device1' })
       const members = await client.getMembers('100')
 
       expect(members).toHaveLength(1)
       expect(members[0].nickname).toBe('Alice')
-      expect(mockGetAllMembers).toHaveBeenCalledTimes(2)
+      expect(mockGetAllMembers).toHaveBeenCalledTimes(3)
+      expect(mockGetChatInfo).not.toHaveBeenCalled()
       // Login fires twice: once for the initial connect, once for the reconnect
       // after the captured onClose handler invalidated this.state.
       expect(mockLogin).toHaveBeenCalledTimes(2)