Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

26.1 KB
Raw Blame
import { createElement } from 'react'
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
import type { RpcClient } from '../transport/rpc-client'
import {
  useMobileNativeChatSession,
  type MobileNativeChatSession
} from './use-mobile-native-chat-session'

function message(id: string): NativeChatMessage {
  return {
    id,
    role: 'assistant',
    blocks: [{ type: 'text', text: id }],
    timestamp: 1,
    source: 'transcript'
  }
}

describe('useMobileNativeChatSession', () => {
  let renderer: ReactTestRenderer | null = null
  let state: MobileNativeChatSession | null = null
  let emit: (frame: unknown) => void = () => {}

  beforeEach(() => {
    state = null
  })

  afterEach(() => {
    act(() => renderer?.unmount())
    renderer = null
  })

  function Harness({ client }: { client: RpcClient | null }): null {
    state = useMobileNativeChatSession({
      client,
      sourceIdentity: 'host-a\0workspace-a',
      agent: 'claude',
      sessionId: 'session',
      transcriptPath: null
    })
    return null
  }

  async function mount(client: RpcClient): Promise<void> {
    await act(async () => {
      renderer = create(createElement(Harness, { client }))
    })
  }

  it('drops an older-page response captured before transcript replacement', async () => {
    let resolveEarlier: (response: unknown) => void = () => {}
    const sendRequest = vi.fn(
      () => new Promise((resolve) => (resolveEarlier = resolve))
    ) as unknown as RpcClient['sendRequest']
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      onData({
        type: 'snapshot',
        messages: Array.from({ length: 40 }, (_unused, index) => message(`old-${index}`)),
        hasMore: true,
        beforeOffset: 100
      })
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)
    act(() => state?.loadEarlier())

    await act(async () => {
      emit({
        type: 'replacement',
        messages: [message('replacement')],
        hasMore: false,
        beforeOffset: 0
      })
    })
    await act(async () => {
      resolveEarlier({
        ok: true,
        result: { messages: [message('stale-page')], hasMore: false, beforeOffset: 0 }
      })
      await Promise.resolve()
    })

    expect(state?.messages.map((entry) => entry.id)).toEqual(['replacement'])
    expect(state?.loadingEarlier).toBe(false)
  })

  it('drops an older-page response after the client source disappears', async () => {
    let resolveEarlier: (response: unknown) => void = () => {}
    const sendRequest = vi.fn(
      () => new Promise((resolve) => (resolveEarlier = resolve))
    ) as unknown as RpcClient['sendRequest']
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      onData({
        type: 'snapshot',
        messages: Array.from({ length: 40 }, (_unused, index) => message(`old-${index}`)),
        hasMore: true,
        beforeOffset: 100
      })
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)
    act(() => state?.loadEarlier())
    await act(async () => renderer?.update(createElement(Harness, { client: null })))
    await act(async () => {
      resolveEarlier({ ok: true, result: { messages: [message('stale-page')] } })
      await Promise.resolve()
    })

    // Retain visible history after source loss, but reject late pages from the retired source.
    expect(state?.messages.map((entry) => entry.id)).not.toContain('stale-page')
    expect(state?.messages).toHaveLength(40)
    expect(state?.status).toBe('idle')
    expect(state?.loadingEarlier).toBe(false)
  })

  it.each(['replacement', 'snapshot'] as const)(
    'can page again after an authoritative %s resets a maxed-out read window',
    async (frameType) => {
      const sendRequest = vi.fn().mockResolvedValue({
        ok: true,
        result: { messages: [message('older')], hasMore: true, beforeOffset: 50 }
      })
      const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
        emit = onData
        onData({
          type: 'snapshot',
          messages: Array.from({ length: 40 }, (_unused, index) => message(`old-${index}`)),
          hasMore: true,
          beforeOffset: 100
        })
        return () => {}
      })
      await mount({ sendRequest, subscribe } as unknown as RpcClient)
      for (let page = 0; page < 33; page += 1) {
        await act(async () => {
          state?.loadEarlier()
          await Promise.resolve()
        })
      }
      const requestsAtCap = sendRequest.mock.calls.length
      expect(requestsAtCap).toBe(33)
      expect(state?.hasMore).toBe(false)
      expect(sendRequest).toHaveBeenLastCalledWith(
        'nativeChat.readSession',
        {
          agent: 'claude',
          sessionId: 'session',
          limit: 40,
          beforeOffset: 50,
          capabilities: { transcriptSourceOrder: 1 }
        },
        expect.objectContaining({ budgetSpansConnect: true })
      )
      await act(async () => state?.loadEarlier())
      expect(sendRequest).toHaveBeenCalledTimes(33)

      await act(async () =>
        emit({
          type: frameType,
          messages: [message('authoritative')],
          hasMore: true,
          beforeOffset: 500
        })
      )
      await act(async () => {
        state?.loadEarlier()
        await Promise.resolve()
      })

      expect(sendRequest).toHaveBeenCalledTimes(requestsAtCap + 1)
      expect(sendRequest).toHaveBeenLastCalledWith(
        'nativeChat.readSession',
        {
          agent: 'claude',
          sessionId: 'session',
          limit: 60,
          beforeOffset: 500,
          capabilities: { transcriptSourceOrder: 1 }
        },
        expect.objectContaining({ budgetSpansConnect: true })
      )
    }
  )

  it('keeps paged-in history across an auto-reconnect replay snapshot', async () => {
    // Reconnect replays the original small window; merge it into paged history instead of truncating.
    const sendRequest = vi.fn().mockResolvedValue({
      ok: true,
      result: {
        messages: Array.from({ length: 60 }, (_unused, index) => message(`paged-${index}`)),
        hasMore: false,
        beforeOffset: 40
      }
    })
    const window = Array.from({ length: 40 }, (_unused, index) => message(`win-${index}`))
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      onData({ type: 'snapshot', messages: window, hasMore: true, beforeOffset: 100 })
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)
    await act(async () => {
      state?.loadEarlier()
      await Promise.resolve()
    })
    expect(state?.messages).toHaveLength(100)

    await act(async () =>
      emit({ type: 'snapshot', messages: window, hasMore: true, beforeOffset: 100 })
    )
    expect(state?.messages).toHaveLength(100)
    expect(state?.messages[0]?.id).toBe('paged-0')

    await act(async () =>
      emit({
        type: 'snapshot',
        messages: [...window, message('live-1')],
        hasMore: true,
        beforeOffset: 100
      })
    )
    expect(state?.messages).toHaveLength(101)
    expect(state?.messages[0]?.id).toBe('paged-0')
    expect(state?.messages.at(-1)?.id).toBe('live-1')
  })

  it('keeps the rows it shows when a replay window has moved past them', async () => {
    const sendRequest = vi.fn(() => new Promise<never>(() => {}))
    const window = Array.from({ length: 40 }, (_unused, index) => message(`win-${index}`))
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      onData({ type: 'snapshot', messages: window, hasMore: false, beforeOffset: 0 })
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)

    await act(async () =>
      emit({
        type: 'snapshot',
        messages: [...window.slice(1), message('live-1')],
        hasMore: true,
        beforeOffset: 10
      })
    )

    expect(state?.messages.map((entry) => entry.id)).toEqual([
      ...window.map((entry) => entry.id),
      'live-1'
    ])
    expect(state?.hasMore).toBe(false)
  })

  it('drops paged rows that an authoritative replay says were removed', async () => {
    const sendRequest = vi.fn().mockResolvedValue({
      ok: true,
      result: {
        messages: Array.from({ length: 60 }, (_unused, index) => message(`paged-${index}`)),
        hasMore: false,
        beforeOffset: 40
      }
    })
    const window = Array.from({ length: 40 }, (_unused, index) => message(`win-${index}`))
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      onData({ type: 'snapshot', messages: window, hasMore: true, beforeOffset: 100 })
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)
    await act(async () => {
      state?.loadEarlier()
      await Promise.resolve()
    })
    expect(state?.messages).toHaveLength(100)

    await act(async () =>
      emit({ type: 'snapshot', messages: window, hasMore: false, beforeOffset: 0 })
    )

    expect(state?.messages).toEqual(window)
    expect(state?.hasMore).toBe(false)
  })

  it('clears a stale cursor when a replacement omits paging metadata', async () => {
    const sendRequest = vi.fn(() => new Promise<never>(() => {}))
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      onData({
        type: 'snapshot',
        messages: Array.from({ length: 40 }, (_unused, index) => message(`win-${index}`)),
        hasMore: true,
        beforeOffset: 100
      })
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)

    await act(async () =>
      emit({
        type: 'replacement',
        messages: Array.from({ length: 40 }, (_unused, index) => message(`new-${index}`))
      })
    )
    act(() => state?.loadEarlier())

    expect(sendRequest).toHaveBeenCalledWith(
      'nativeChat.readSession',
      {
        agent: 'claude',
        sessionId: 'session',
        limit: 100,
        capabilities: { transcriptSourceOrder: 1 }
      },
      expect.objectContaining({ budgetSpansConnect: true })
    )
  })

  it('clears hasMore when a replaced window is shorter than the initial page', async () => {
    const sendRequest = vi.fn()
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      onData({
        type: 'snapshot',
        messages: Array.from({ length: 40 }, (_unused, index) => message(`win-${index}`)),
        hasMore: true,
        beforeOffset: 100
      })
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)
    expect(state?.hasMore).toBe(true)

    await act(async () => emit({ type: 'replacement', messages: [message('only')] }))

    expect(state?.hasMore).toBe(false)
  })

  it('fences an in-flight older page when a merging replay re-cuts the byte cursor', async () => {
    let resolveEarlier: (response: unknown) => void = () => {}
    const sendRequest = vi.fn(
      () => new Promise((resolve) => (resolveEarlier = resolve))
    ) as unknown as RpcClient['sendRequest']
    const retained = Array.from({ length: 40 }, (_unused, index) => message(`win-${index}`))
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      onData({ type: 'snapshot', messages: retained, hasMore: true, beforeOffset: 100 })
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)
    act(() => state?.loadEarlier())

    // Even an untrimmed replay can recut the cursor; an old in-flight page must not overwrite the new offset.
    await act(async () =>
      emit({ type: 'snapshot', messages: retained, hasMore: true, beforeOffset: 250 })
    )
    await act(async () => {
      resolveEarlier({
        ok: true,
        result: { messages: [message('stale-page')], hasMore: true, beforeOffset: 40 }
      })
      await Promise.resolve()
    })

    expect(state?.messages.some((entry) => entry.id === 'stale-page')).toBe(false)
    expect(state?.loadingEarlier).toBe(false)
  })

  it('lands a page across a same-cursor replay, and flags a refused page until the next tap', async () => {
    const pages: ((response: unknown) => void)[] = []
    const sendRequest = vi.fn(() => new Promise((resolve) => pages.push(resolve)))
    const window = Array.from({ length: 40 }, (_unused, index) => message(`win-${index}`))
    const snapshot = { type: 'snapshot', messages: window, hasMore: true, beforeOffset: 100 }
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      onData(snapshot)
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)
    const answer = (response: unknown) =>
      act(async () => {
        pages.at(-1)?.(response)
        await Promise.resolve()
      })

    act(() => state?.loadEarlier())
    await act(async () => emit(snapshot))
    await answer({
      ok: true,
      result: { messages: [message('older')], hasMore: true, beforeOffset: 40 }
    })
    expect(state?.messages.map((entry) => entry.id)).toEqual([
      'older',
      ...window.map((entry) => entry.id)
    ])

    act(() => state?.loadEarlier())
    await answer({ id: 'x', ok: false, error: { code: 'refused', message: 'refused' } })
    expect(state?.olderPages).toBe('failed')
    expect(state?.loadingEarlier).toBe(false)
    act(() => state?.loadEarlier())
    expect(sendRequest).toHaveBeenCalledTimes(3)
    expect(state?.olderPages).toBe('loading')
  })

  it('keeps the base snapshot authoritative when a live append arrives first', async () => {
    const sendRequest = vi.fn()
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)
    // Only snapshots establish the base; early appends cannot turn the first real snapshot into replay.
    await act(async () =>
      emit({ type: 'appended', messages: [message('early-a'), message('early-b')] })
    )
    await act(async () =>
      emit({
        type: 'snapshot',
        messages: [message('early-b'), message('base-c')],
        hasMore: true,
        beforeOffset: 3
      })
    )

    expect(state?.messages.map((entry) => entry.id)).toEqual(['early-b', 'base-c'])
  })

  it('keeps every row it shows while live output outgrows the first window', async () => {
    let resolvePage: (response: unknown) => void = () => {}
    const sendRequest = vi
      .fn()
      .mockImplementationOnce(() => new Promise((resolve) => (resolvePage = resolve)))
      .mockImplementation(() => new Promise<never>(() => {}))
    const window = Array.from({ length: 40 }, (_unused, index) => message(`window-${index}`))
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      onData({ type: 'snapshot', messages: window, hasMore: true, beforeOffset: 100 })
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)
    const shown = window.map((entry) => entry.id)

    act(() => state?.loadEarlier())
    await act(async () => emit({ type: 'appended', messages: [message('live-1')] }))
    expect(state?.messages.map((entry) => entry.id)).toEqual([...shown, 'live-1'])

    await act(async () => {
      resolvePage({
        ok: true,
        result: { messages: [message('older-page')], hasMore: true, beforeOffset: 50 }
      })
      await Promise.resolve()
    })
    expect(state?.messages.map((entry) => entry.id)).toEqual(['older-page', ...shown, 'live-1'])
  })

  it('pages a growing tail from what the phone holds, not from the first window', async () => {
    const sendRequest = vi.fn(() => new Promise<never>(() => {}))
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      emit = onData
      onData({
        type: 'snapshot',
        messages: Array.from({ length: 40 }, (_unused, index) => message(`window-${index}`)),
        hasMore: true
      })
      return () => {}
    })
    await mount({ sendRequest, subscribe } as unknown as RpcClient)
    await act(async () =>
      emit({
        type: 'appended',
        messages: Array.from({ length: 30 }, (_unused, index) => message(`live-${index}`))
      })
    )

    act(() => state?.loadEarlier())

    expect(sendRequest).toHaveBeenLastCalledWith(
      'nativeChat.readSession',
      {
        agent: 'claude',
        sessionId: 'session',
        limit: 130,
        capabilities: { transcriptSourceOrder: 1 }
      },
      expect.objectContaining({ budgetSpansConnect: true })
    )
  })
})

describe('useMobileNativeChatSession transcriptLoading', () => {
  let renderer: ReactTestRenderer | null = null
  const renders: {
    sessionId: string | null
    transcriptLoading: boolean
    status: string
    ids: string[]
  }[] = []

  beforeEach(() => {
    renders.length = 0
  })

  afterEach(() => {
    act(() => renderer?.unmount())
    renderer = null
  })

  function Harness({
    client,
    sessionId,
    agent = 'claude',
    sourceIdentity = 'host-a\0workspace-a'
  }: {
    client: RpcClient | null
    sessionId: string | null
    agent?: string | null
    sourceIdentity?: string
  }): null {
    const session = useMobileNativeChatSession({
      client,
      sourceIdentity,
      agent,
      sessionId,
      transcriptPath: null
    })
    renders.push({
      sessionId,
      transcriptLoading: session.transcriptLoading,
      status: session.status,
      ids: session.messages.map((entry) => entry.id)
    })
    return null
  }

  async function mountAt(client: RpcClient | null, sessionId: string | null): Promise<void> {
    await act(async () => {
      renderer = create(createElement(Harness, { client, sessionId }))
    })
  }

  it('reports loading on the very first render, before the subscription effect runs', async () => {
    // Idle alone cannot make an empty pre-read transcript trustworthy for launch seeding.
    const subscribe: RpcClient['subscribe'] = vi.fn(() => () => {})
    await mountAt({ subscribe } as unknown as RpcClient, 'session-a')

    expect(renders[0]).toMatchObject({ transcriptLoading: true, ids: [] })
  })

  it('re-reads instead of resurfacing a settled read when the same identity returns', async () => {
    // View toggles clear subscription state; retain settled history without claiming the reread is ready.
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      onData({ type: 'snapshot', messages: [message('a-1')], hasMore: false })
      return () => {}
    })
    const client = { subscribe } as unknown as RpcClient
    await mountAt(client, 'session-a')
    expect(renders.at(-1)).toMatchObject({ status: 'ready', transcriptLoading: false })

    await act(async () =>
      renderer?.update(createElement(Harness, { client, sessionId: 'session-a', agent: null }))
    )
    renders.length = 0
    await act(async () =>
      renderer?.update(createElement(Harness, { client, sessionId: 'session-a', agent: 'claude' }))
    )

    expect(renders[0]).toMatchObject({
      status: 'loading',
      transcriptLoading: true,
      ids: ['a-1']
    })
  })

  it('keeps the last settled list rendered while a swapped client re-reads', async () => {
    // A new client invalidates the old ready verdict but must keep the cached conversation visible.
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      onData({ type: 'snapshot', messages: [message('a-1')], hasMore: false })
      return () => {}
    })
    const client = { subscribe } as unknown as RpcClient
    await mountAt(client, 'session-a')
    expect(renders.at(-1)).toMatchObject({ status: 'ready' })

    let emitFresh: (frame: unknown) => void = () => {}
    const reconnected = {
      subscribe: vi.fn((_method: string, _params: unknown, onData: (frame: unknown) => void) => {
        emitFresh = onData
        return () => {}
      })
    } as unknown as RpcClient
    renders.length = 0
    await act(async () =>
      renderer?.update(createElement(Harness, { client: reconnected, sessionId: 'session-a' }))
    )

    expect(renders[0]).toMatchObject({
      status: 'loading',
      transcriptLoading: true,
      ids: ['a-1']
    })
    // Check every commit: passive resubscribe reset could blank history after a first-frame assertion passed.
    expect([...new Set(renders.map((entry) => entry.ids.join(',')))]).toEqual(['a-1'])

    await act(async () =>
      emitFresh({ type: 'snapshot', messages: [message('a-1'), message('a-2')], hasMore: false })
    )
    expect(renders.at(-1)).toMatchObject({
      status: 'ready',
      transcriptLoading: false,
      ids: ['a-1', 'a-2']
    })
  })

  it('keeps the retained transcript rendered when the stream reports an error', async () => {
    // Failed rereads must retain the last settled history until newer history replaces it.
    let emitFrame: (frame: unknown) => void = () => {}
    const client = {
      subscribe: vi.fn((_method: string, _params: unknown, onData: (frame: unknown) => void) => {
        emitFrame = onData
        onData({ type: 'snapshot', messages: [message('a-1')], hasMore: false })
        return () => {}
      })
    } as unknown as RpcClient
    await mountAt(client, 'session-a')
    expect(renders.at(-1)).toMatchObject({ status: 'ready', ids: ['a-1'] })

    renders.length = 0
    await act(async () => emitFrame({ type: 'error', message: 'stream broke' }))

    expect(renders.at(-1)).toMatchObject({
      status: 'error',
      transcriptLoading: false,
      ids: ['a-1']
    })
  })

  it('never holds a cached list across a host/workspace source change', async () => {
    const firstClient = {
      subscribe: vi.fn((_method: string, _params: unknown, onData: (frame: unknown) => void) => {
        onData({ type: 'snapshot', messages: [message('source-a')], hasMore: false })
        return () => {}
      })
    } as unknown as RpcClient
    await mountAt(firstClient, 'session-a')

    const secondClient = { subscribe: vi.fn(() => () => {}) } as unknown as RpcClient
    renders.length = 0
    await act(async () =>
      renderer?.update(
        createElement(Harness, {
          client: secondClient,
          sessionId: 'session-a',
          sourceIdentity: 'host-b\0workspace-b'
        })
      )
    )

    expect(renders[0]).toMatchObject({ status: 'loading', ids: [] })
  })

  it('never hands out the previous session’s messages under the new session id', async () => {
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, params, onData) => {
      if ((params as { sessionId: string }).sessionId === 'session-a') {
        onData({ type: 'snapshot', messages: [message('a-1')], hasMore: false })
      }
      return () => {}
    })
    const client = { subscribe } as unknown as RpcClient
    await mountAt(client, 'session-a')
    await act(async () =>
      renderer?.update(createElement(Harness, { client, sessionId: 'session-b' }))
    )

    // The passive reset lags one commit; session-a rows must never surface under session-b.
    const leaked = renders.find(
      (entry) => entry.sessionId === 'session-b' && entry.ids.includes('a-1')
    )
    expect(leaked).toBeUndefined()
    expect(renders.find((entry) => entry.sessionId === 'session-b')).toMatchObject({
      transcriptLoading: true,
      ids: []
    })
  })

  it('settles the view but not the read on a pending snapshot', async () => {
    // Pending means no file yet: render without a spinner, but do not call empty history ready for launch seeding.
    const subscribe: RpcClient['subscribe'] = vi.fn((_method, _params, onData) => {
      onData({ type: 'snapshot', messages: [], hasMore: false, pending: true })
      return () => {}
    })
    await mountAt({ subscribe } as unknown as RpcClient, 'session-a')

    expect(subscribe).toHaveBeenCalledWith(
      'nativeChat.subscribe',
      expect.objectContaining({ capabilities: { transcriptPending: 1, transcriptSourceOrder: 1 } }),
      expect.any(Function)
    )
    expect(renders.at(-1)).toMatchObject({
      status: 'awaiting-transcript',
      transcriptLoading: true,
      ids: []
    })
  })

  it('takes the real snapshot after a pending one as this subscription’s base', async () => {
    let emitFrame: (frame: unknown) => void = () => {}
    const client = {
      subscribe: vi.fn((_method: string, _params: unknown, onData: (frame: unknown) => void) => {
        emitFrame = onData
        onData({ type: 'snapshot', messages: [], hasMore: false, pending: true })
        return () => {}
      })
    } as unknown as RpcClient
    await mountAt(client, 'session-a')

    await act(async () =>
      emitFrame({ type: 'appended', messages: [message('early-a'), message('early-b')] })
    )
    await act(async () =>
      emitFrame({
        type: 'snapshot',
        messages: [message('early-b'), message('base-c')],
        hasMore: true,
        beforeOffset: 100
      })
    )

    expect(renders.at(-1)).toMatchObject({
      status: 'ready',
      transcriptLoading: false,
      ids: ['early-b', 'base-c']
    })
  })

  it('never captures a pending window over the retained transcript', async () => {
    const client = {
      subscribe: vi.fn((_method: string, _params: unknown, onData: (frame: unknown) => void) => {
        onData({ type: 'snapshot', messages: [message('a-1')], hasMore: false })
        return () => {}
      })
    } as unknown as RpcClient
    await mountAt(client, 'session-a')

    const reconnected = {
      subscribe: vi.fn((_method: string, _params: unknown, onData: (frame: unknown) => void) => {
        onData({ type: 'snapshot', messages: [], hasMore: false, pending: true })
        return () => {}
      })
    } as unknown as RpcClient
    await act(async () =>
      renderer?.update(createElement(Harness, { client: reconnected, sessionId: 'session-a' }))
    )

    const rebound = { subscribe: vi.fn(() => () => {}) } as unknown as RpcClient
    renders.length = 0
    await act(async () =>
      renderer?.update(createElement(Harness, { client: rebound, sessionId: 'session-a' }))
    )

    expect(renders.at(-1)).toMatchObject({ status: 'loading', ids: ['a-1'] })
  })
})