Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

27.8 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest';
import {
  bridgeLatestMessagePage,
  hasMoreOlderMessages,
  hasOlderMessagesAfterReopen,
  collectCompleteIncrementalMessages,
  hasOlderMessagesByServerCount,
  incrementalMessagePageNeedsFallback,
  latestMessageCursor,
  listMessagesWithPayloadRetry,
  MESSAGE_PAGE_SIZE,
  type MessagePageRetryResult,
  oldestMessageCursor,
  projectLoadedMessageWindow,
  projectLoadedMessageWindowIncrementally,
  shouldKeepOlderMessagesAffordance,
  shouldRefreshLatestMessageWindowOnReopen,
} from '@/session/messagePaging';
import type { RemoteMessage, RemoteSession } from '@/session/types';

function message(id: string, createdAt: string): RemoteMessage {
  return {
    id,
    clientId: id,
    sessionId: 's1',
    role: 'assistant',
    content: 'hello',
    toolUseId: null,
    agentMeta: null,
    createdAt,
  };
}

function sessionVersion(patch: Partial<Pick<RemoteSession, '_count' | 'updatedAt'>> = {}): Pick<RemoteSession, '_count' | 'updatedAt'> {
  return {
    updatedAt: '2026-01-01T00:00:01.000Z',
    _count: { messages: 2 },
    ...patch,
  };
}

describe('messagePaging', () => {
  it('never sends temporary stream identities as host pagination cursors', () => {
    const rows = [
      message('mobile-stream-old', '2026-01-01T00:00:01.000Z'),
      message('host-row', '2026-01-01T00:00:02.000Z'),
      message('mobile-stream-new', '2026-01-01T00:00:03.000Z'),
    ];
    expect(oldestMessageCursor(rows)).toBe('host-row');
    expect(latestMessageCursor(rows)).toBe('host-row');
    expect(oldestMessageCursor([rows[0], rows[2]])).toBeNull();
    expect(latestMessageCursor([rows[0], rows[2]])).toBeNull();
  });

  it('does not let running stream rows consume the remaining host history count', () => {
    const rows = [
      message('host-row', '2026-01-01T00:00:01.000Z'),
      message('mobile-stream-new', '2026-01-01T00:00:02.000Z'),
    ];
    expect(hasOlderMessagesAfterReopen(2, rows)).toBe(true);
    expect(hasOlderMessagesByServerCount(2, rows)).toBe(true);
    expect(hasOlderMessagesAfterReopen(undefined, [rows[1]], 1)).toBe(false);
  });

  it('finds the oldest message id without relying on current array order', () => {
    expect(oldestMessageCursor([
      message('m3', '2026-01-01T00:00:03.000Z'),
      message('m1', '2026-01-01T00:00:01.000Z'),
      message('m2', '2026-01-01T00:00:02.000Z'),
    ])).toBe('m1');
  });

  it('finds the latest host cursor and skips local system cards', () => {
    expect(latestMessageCursor([
      message('m1', '2026-01-01T00:00:01.000Z'),
      message('mobile-system-context-1', '2026-01-01T00:00:03.000Z'),
      message('m2', '2026-01-01T00:00:02.000Z'),
    ])).toBe('m2');
  });

  it('uses the host rowid to choose a same-timestamp cursor', () => {
    const createdAt = '2026-01-01T00:00:01.000Z';
    expect(latestMessageCursor([
      { ...message('z-older', createdAt), rowid: 4 },
      { ...message('a-newer', createdAt), rowid: 5 },
    ])).toBe('a-newer');
  });

  it('returns null when no stable message id exists', () => {
    expect(oldestMessageCursor([
      { ...message('', '2026-01-01T00:00:01.000Z'), clientId: 'client-only' },
    ])).toBeNull();
  });

  describe('projectLoadedMessageWindow', () => {
    const compact = (id: string, createdAt: string): RemoteMessage => ({
      ...message(`mobile-system-compact:${id}`, createdAt),
      systemCardType: 'compact',
    });

    it('hides detached Compact cards older than the loaded host window', () => {
      const detached = compact('old', '2026-01-01T00:00:01.000Z');
      const rows = [
        detached,
        message('m10', '2026-01-01T00:00:10.000Z'),
        message('m11', '2026-01-01T00:00:11.000Z'),
      ];

      expect(projectLoadedMessageWindow(rows).map((row) => row.id)).toEqual(['m10', 'm11']);
    });

    it('restores a Compact card when older host rows reach its time range', () => {
      const rows = [
        message('m0', '2026-01-01T00:00:00.000Z'),
        compact('in-window', '2026-01-01T00:00:01.000Z'),
        message('m2', '2026-01-01T00:00:02.000Z'),
      ];

      expect(projectLoadedMessageWindow(rows)).toBe(rows);
    });

    it('collapses adjacent replay-time Compact cards to the latest boundary', () => {
      const rows = [
        message('m1', '2026-01-01T00:00:01.000Z'),
        compact('replay-1', '2026-01-01T00:00:10.000Z'),
        compact('replay-2', '2026-01-01T00:00:11.000Z'),
        compact('replay-3', '2026-01-01T00:00:12.000Z'),
      ];

      expect(projectLoadedMessageWindow(rows).map((row) => row.id)).toEqual([
        'm1',
        'mobile-system-compact:replay-3',
      ]);
    });

    it('keeps only the latest detached tail Compact across temporary streaming rows', () => {
      const temporaryStream = message('mobile-stream-1', '2026-01-01T00:00:11.000Z');
      const rows = [
        message('m1', '2026-01-01T00:00:01.000Z'),
        compact('replay-1', '2026-01-01T00:00:10.000Z'),
        temporaryStream,
        compact('replay-2', '2026-01-01T00:00:12.000Z'),
      ];

      expect(projectLoadedMessageWindow(rows).map((row) => row.id)).toEqual([
        'm1',
        'mobile-stream-1',
        'mobile-system-compact:replay-2',
      ]);
    });

    it('does not let a generated streaming client id widen the persisted host window', () => {
      const temporaryStream = {
        ...message('temporary-row', '2026-01-01T00:00:11.000Z'),
        clientId: 'mobile-stream-2',
      };
      const rows = [
        message('m1', '2026-01-01T00:00:01.000Z'),
        compact('replay-1', '2026-01-01T00:00:10.000Z'),
        temporaryStream,
        compact('replay-2', '2026-01-01T00:00:12.000Z'),
      ];

      expect(projectLoadedMessageWindow(rows).map((row) => row.id)).toEqual([
        'm1',
        'temporary-row',
        'mobile-system-compact:replay-2',
      ]);
    });

    it('keeps Compact boundaries separated by host body rows', () => {
      const rows = [
        message('m0', '2026-01-01T00:00:00.000Z'),
        compact('first', '2026-01-01T00:00:01.000Z'),
        message('body', '2026-01-01T00:00:02.000Z'),
        compact('second', '2026-01-01T00:00:03.000Z'),
      ];

      expect(projectLoadedMessageWindow(rows)).toBe(rows);
    });

    it('keeps current-tail Compact and unrelated local system cards', () => {
      const contextCard = {
        ...message('mobile-system-context:1', '2025-12-31T23:59:59.000Z'),
        systemCardType: 'context' as const,
      };
      const rows = [
        contextCard,
        message('m1', '2026-01-01T00:00:01.000Z'),
        compact('tail', '2026-01-01T00:00:02.000Z'),
      ];

      expect(projectLoadedMessageWindow(rows)).toBe(rows);
    });

    it('does not erase Compact-only local state when no host cursor is loaded', () => {
      const rows = [compact('only', '2026-01-01T00:00:01.000Z')];
      expect(projectLoadedMessageWindow(rows)).toBe(rows);
    });

    it('collapses an adjacent Compact-only wall when no host cursor is loaded', () => {
      const rows = [
        compact('first', '2026-01-01T00:00:01.000Z'),
        compact('second', '2026-01-01T00:00:02.000Z'),
        compact('latest', '2026-01-01T00:00:03.000Z'),
      ];

      expect(projectLoadedMessageWindow(rows).map((row) => row.id)).toEqual([
        'mobile-system-compact:latest',
      ]);
    });

    it('patches a visible streaming row without rescanning a Compact projection', () => {
      const rows = [
        message('m1', '2026-01-01T00:00:01.000Z'),
        compact('replay-1', '2026-01-01T00:00:02.000Z'),
        compact('replay-2', '2026-01-01T00:00:03.000Z'),
        message('streaming', '2026-01-01T00:00:04.000Z'),
      ];
      const structureToken = {};
      const first = projectLoadedMessageWindowIncrementally({
        changedIndexes: new Set(),
        messages: rows,
        structureToken,
      });
      expect(first.projected.map((row) => row.id)).toEqual([
        'm1',
        'mobile-system-compact:replay-2',
        'streaming',
      ]);

      const nextRows = [...rows];
      nextRows[3] = { ...rows[3], content: 'next token' };
      let unrelatedSourceReads = 0;
      const observedRows = new Proxy(nextRows, {
        get(target, property, receiver) {
          if (typeof property === 'string' && /^\d+$/.test(property) && Number(property) !== 3) {
            unrelatedSourceReads += 1;
          }
          return Reflect.get(target, property, receiver);
        },
      });
      const next = projectLoadedMessageWindowIncrementally({
        changedIndexes: new Set([3]),
        messages: observedRows,
        previous: first,
        structureToken,
      });

      expect(unrelatedSourceReads).toBe(0);
      expect(next.sourceToProjectedIndex).toBe(first.sourceToProjectedIndex);
      expect(next.changedIndexes).toEqual(new Set([2]));
      expect(next.projected.map((row) => row.content)).toEqual([
        'hello',
        'hello',
        'next token',
      ]);
    });
  });

  it('keeps the load-earlier affordance only when the remote page is full', () => {
    expect(hasMoreOlderMessages([message('m1', '2026-01-01T00:00:01.000Z')], 2)).toBe(false);
    expect(hasMoreOlderMessages([
      message('m1', '2026-01-01T00:00:01.000Z'),
      message('m2', '2026-01-01T00:00:02.000Z'),
    ], 2)).toBe(true);
  });

  it('keeps the load-earlier affordance for a short page trimmed by the remote frame limit', () => {
    // 被控端帧超限裁行时保留行带 agentMeta.remoteRowsTrimmed:短页不代表历史到头。
    const trimmed = {
      ...message('m1', '2026-01-01T00:00:01.000Z'),
      agentMeta: { remoteRowsTrimmed: true, remoteOriginalRowCount: 80 },
    };
    expect(hasMoreOlderMessages([trimmed], 2)).toBe(true);
  });

  it('retries message pages with smaller limits when device-link payload exceeds frame size', async () => {
    const calls: number[] = [];
    const page = [message('m1', '2026-01-01T00:00:01.000Z')];
    const result = await listMessagesWithPayloadRetry(async (limit) => {
      calls.push(limit);
      if (limit > 10) {
        const err = new Error('frame exceeds 2097152 bytes');
        (err as Error & { code: string }).code = 'PAYLOAD_TOO_LARGE';
        throw err;
      }
      return page;
    }, [80, 20, 10]);

    expect(calls).toEqual([80, 20, 10]);
    expect(result).toEqual({
      messages: page,
      limit: 10,
      reducedByPayloadTooLarge: true,
    });
    expect(shouldKeepOlderMessagesAffordance(result)).toBe(true);
  });

  it('uses small network pages without reducing the cached history window', async () => {
    const calls: number[] = [];
    const result = await listMessagesWithPayloadRetry(async (limit) => {
      calls.push(limit);
      return Array.from({ length: limit }, (_, i) => message(`m${i}`, '2026-01-01T00:00:01.000Z'));
    });
    expect(calls).toEqual([20]);
    expect(MESSAGE_PAGE_SIZE).toBe(80);
    expect(shouldKeepOlderMessagesAffordance(result)).toBe(true);
  });

  it('does not retry non-payload pagination errors', async () => {
    const calls: number[] = [];
    await expect(listMessagesWithPayloadRetry(async (limit) => {
      calls.push(limit);
      throw new Error('remote unavailable');
    }, [80, 40])).rejects.toThrow('remote unavailable');
    expect(calls).toEqual([80]);
  });

  it('keeps the load-earlier affordance after a reduced payload page', () => {
    expect(shouldKeepOlderMessagesAffordance({
      messages: [message('m1', '2026-01-01T00:00:01.000Z')],
      limit: 10,
      reducedByPayloadTooLarge: true,
    })).toBe(true);
    expect(shouldKeepOlderMessagesAffordance({
      messages: [message('m1', '2026-01-01T00:00:01.000Z')],
      limit: 10,
      reducedByPayloadTooLarge: false,
    })).toBe(false);
    expect(shouldKeepOlderMessagesAffordance({
      messages: [],
      limit: 1,
      reducedByPayloadTooLarge: true,
    })).toBe(false);
  });

  describe('incrementalMessagePageNeedsFallback', () => {
    const page = {
      messages: [message('m2', '2026-01-01T00:00:02.000Z')],
      limit: 20,
      reducedByPayloadTooLarge: false,
    };

    it('accepts a complete page when the fresh count delta matches it', () => {
      expect(incrementalMessagePageNeedsFallback({
        page,
        totalCount: 2,
        previousTotalCount: 1,
      })).toBe(false);
    });

    it('falls back when the fresh count delta is larger than the returned page', () => {
      expect(incrementalMessagePageNeedsFallback({
        page,
        totalCount: 3,
        previousTotalCount: 1,
      })).toBe(true);
    });

    it('falls back when the fresh count regresses', () => {
      expect(incrementalMessagePageNeedsFallback({
        page,
        totalCount: 1,
        previousTotalCount: 2,
      })).toBe(true);
    });

    it('falls back when an older host ignores the after cursor', () => {
      expect(incrementalMessagePageNeedsFallback({
        page: {
          ...page,
          messages: [
            message('m1', '2026-01-01T00:00:01.000Z'),
            message('m2', '2026-01-01T00:00:02.000Z'),
          ],
        },
        afterMessage: message('m1', '2026-01-01T00:00:01.000Z'),
      })).toBe(true);
    });

    it('uses rowid when checking an incremental cursor with equal timestamps', () => {
      const createdAt = '2026-01-01T00:00:01.000Z';
      expect(incrementalMessagePageNeedsFallback({
        page: {
          ...page,
          messages: [{ ...message('m2', createdAt), rowid: 5 }],
        },
        afterMessage: { ...message('m1', createdAt), rowid: 4 },
      })).toBe(false);
      expect(incrementalMessagePageNeedsFallback({
        page: {
          ...page,
          messages: [{ ...message('m0', createdAt), rowid: 3 }],
        },
        afterMessage: { ...message('m1', createdAt), rowid: 4 },
      })).toBe(true);
    });

    it('falls back for a full or payload-reduced page when the total is unknown', () => {
      const fullPage = {
        messages: Array.from({ length: 20 }, (_, index) =>
          message(`m${index}`, `2026-01-01T00:00:${String(index).padStart(2, '0')}.000Z`)),
        limit: 20,
        reducedByPayloadTooLarge: false,
      };
      expect(incrementalMessagePageNeedsFallback({
        page: fullPage,
      })).toBe(true);
      expect(incrementalMessagePageNeedsFallback({
        page: { ...page, reducedByPayloadTooLarge: true },
      })).toBe(true);
      expect(incrementalMessagePageNeedsFallback({
        page,
      })).toBe(false);
    });
  });


  describe('collectCompleteIncrementalMessages', () => {
    it('walks multiple after pages to collect a large delta', async () => {
      const anchor = message('m0', '2026-01-01T00:00:00.000Z');
      const pages = new Map([
        ['m2', { messages: [message('m3', '2026-01-01T00:00:03.000Z'), message('m4', '2026-01-01T00:00:04.000Z')], limit: 2, reducedByPayloadTooLarge: false }],
      ]);
      const result = await collectCompleteIncrementalMessages({
        initialPage: { messages: [message('m1', '2026-01-01T00:00:01.000Z'), message('m2', '2026-01-01T00:00:02.000Z')], limit: 2, reducedByPayloadTooLarge: false },
        afterMessage: anchor,
        fetchAfter: async (cursor) => pages.get(cursor) ?? { messages: [], limit: 2, reducedByPayloadTooLarge: false },
        fetchLatest: async () => { throw new Error('tail fallback should not run'); },
        fetchBefore: async () => { throw new Error('before fallback should not run'); },
      });
      expect(result?.map((item) => item.id)).toEqual(['m1', 'm2', 'm3', 'm4']);
    });

    it('walks backward from the latest tail when after is ignored', async () => {
      const anchor = message('m1', '2026-01-01T00:00:01.000Z');
      const result = await collectCompleteIncrementalMessages({
        initialPage: { messages: [message('m4', '2026-01-01T00:00:04.000Z'), message('m5', '2026-01-01T00:00:05.000Z')], limit: 2, reducedByPayloadTooLarge: false },
        afterMessage: anchor,
        fetchAfter: async () => ({ messages: [message('m4', '2026-01-01T00:00:04.000Z'), message('m5', '2026-01-01T00:00:05.000Z')], limit: 2, reducedByPayloadTooLarge: false }),
        fetchLatest: async () => ({ messages: [message('m4', '2026-01-01T00:00:04.000Z'), message('m5', '2026-01-01T00:00:05.000Z')], limit: 2, reducedByPayloadTooLarge: false }),
        fetchBefore: async (before) => before === 'm4'
          ? { messages: [message('m2', '2026-01-01T00:00:02.000Z'), message('m3', '2026-01-01T00:00:03.000Z')], limit: 2, reducedByPayloadTooLarge: false }
          : before === 'm2'
            ? { messages: [message('m1', '2026-01-01T00:00:01.000Z')], limit: 2, reducedByPayloadTooLarge: false }
            : { messages: [], limit: 2, reducedByPayloadTooLarge: false },
      });
      expect(result?.map((item) => item.id)).toEqual(['m2', 'm3', 'm4', 'm5']);
    });
    it('keeps paging until a short page even when a net delta would be smaller', async () => {
      const anchor = message('m0', '2026-01-01T00:00:00.000Z');
      const calls: string[] = [];
      const result = await collectCompleteIncrementalMessages({
        initialPage: { messages: [message('m1', '2026-01-01T00:00:01.000Z'), message('m2', '2026-01-01T00:00:02.000Z')], limit: 2, reducedByPayloadTooLarge: false },
        afterMessage: anchor,
        fetchAfter: async (cursor) => {
          calls.push(cursor);
          return cursor === 'm2'
            ? { messages: [message('m3', '2026-01-01T00:00:03.000Z'), message('m4', '2026-01-01T00:00:04.000Z')], limit: 2, reducedByPayloadTooLarge: false }
            : { messages: [message('m5', '2026-01-01T00:00:05.000Z')], limit: 2, reducedByPayloadTooLarge: false };
        },
        fetchLatest: async () => { throw new Error('tail fallback should not run'); },
        fetchBefore: async () => { throw new Error('before fallback should not run'); },
      });
      expect(calls).toEqual(['m2', 'm4']);
      expect(result?.map((item) => item.id)).toEqual(['m1', 'm2', 'm3', 'm4', 'm5']);
    });

    it('does not accept a forward prefix after reaching the page limit', async () => {
      const anchor = message('m0', '2026-01-01T00:00:00.000Z');
      const result = await collectCompleteIncrementalMessages({
        initialPage: {
          messages: [
            message('m1', '2026-01-01T00:00:01.000Z'),
            message('m2', '2026-01-01T00:00:02.000Z'),
          ],
          limit: 2,
          reducedByPayloadTooLarge: false,
        },
        afterMessage: anchor,
        fetchAfter: async () => ({
          messages: [
            message('m3', '2026-01-01T00:00:03.000Z'),
            message('m4', '2026-01-01T00:00:04.000Z'),
          ],
          limit: 2,
          reducedByPayloadTooLarge: false,
        }),
        fetchLatest: async () => {
          throw new Error('tail fallback should not run');
        },
        fetchBefore: async () => {
          throw new Error('before fallback should not run');
        },
        maxPages: 1,
      });

      expect(result).toBeNull();
    });

    it('does not accept an unknown after cursor from an empty continuation', async () => {
      const anchor = message('deleted-anchor', '2026-01-01T00:00:01.000Z');
      const result = await collectCompleteIncrementalMessages({
        initialPage: {
          messages: [
            message('m4', '2026-01-01T00:00:04.000Z'),
            message('m5', '2026-01-01T00:00:05.000Z'),
          ],
          limit: 2,
          reducedByPayloadTooLarge: false,
        },
        afterMessage: anchor,
        fetchAfter: async () => ({
          messages: [],
          limit: 2,
          reducedByPayloadTooLarge: false,
        }),
        fetchLatest: async () => ({
          messages: [
            message('m4', '2026-01-01T00:00:04.000Z'),
            message('m5', '2026-01-01T00:00:05.000Z'),
          ],
          limit: 2,
          reducedByPayloadTooLarge: false,
        }),
        fetchBefore: async () => ({
          messages: [message('m2', '2026-01-01T00:00:02.000Z')],
          limit: 2,
          reducedByPayloadTooLarge: false,
        }),
      });

      expect(result).toBeNull();
    });

    it('rejects a short backward page that never reaches the original cursor', async () => {
      const anchor = message('deleted-anchor', '2026-01-01T00:00:01.000Z');
      const result = await collectCompleteIncrementalMessages({
        initialPage: {
          messages: [
            message('m4', '2026-01-01T00:00:04.000Z'),
            message('m5', '2026-01-01T00:00:05.000Z'),
          ],
          limit: 2,
          reducedByPayloadTooLarge: false,
        },
        afterMessage: anchor,
        fetchAfter: async () => ({
          messages: [
            message('m4', '2026-01-01T00:00:04.000Z'),
            message('m5', '2026-01-01T00:00:05.000Z'),
          ],
          limit: 2,
          reducedByPayloadTooLarge: false,
        }),
        fetchLatest: async () => ({
          messages: [
            message('m4', '2026-01-01T00:00:04.000Z'),
            message('m5', '2026-01-01T00:00:05.000Z'),
          ],
          limit: 2,
          reducedByPayloadTooLarge: false,
        }),
        fetchBefore: async () => ({
          messages: [message('m2', '2026-01-01T00:00:02.000Z')],
          limit: 2,
          reducedByPayloadTooLarge: false,
        }),
      });

      expect(result).toBeNull();
    });
  });

  describe('shouldRefreshLatestMessageWindowOnReopen', () => {
    it('refreshes when the cached message window was never synced to the current session meta', () => {
      const freshSession = sessionVersion();

      expect(shouldRefreshLatestMessageWindowOnReopen({
        freshSession,
        messageWindowSynced: false,
        storedSession: freshSession,
      })).toBe(true);
    });

    it('refreshes when session updatedAt or message count changed', () => {
      expect(shouldRefreshLatestMessageWindowOnReopen({
        freshSession: sessionVersion({ updatedAt: '2026-01-01T00:00:02.000Z' }),
        messageWindowSynced: true,
        storedSession: sessionVersion(),
      })).toBe(true);

      expect(shouldRefreshLatestMessageWindowOnReopen({
        freshSession: sessionVersion({ _count: { messages: 3 } }),
        messageWindowSynced: true,
        storedSession: sessionVersion({ _count: { messages: 2 } }),
      })).toBe(true);
    });

    it('skips refresh only when meta is unchanged and the message window is marked synced', () => {
      const freshSession = sessionVersion();

      expect(shouldRefreshLatestMessageWindowOnReopen({
        freshSession,
        messageWindowSynced: true,
        storedSession: freshSession,
      })).toBe(false);
    });
  });

  describe('hasOlderMessagesAfterReopen (reopen skip-fetch path)', () => {
    const loaded = [
      message('m2', '2026-01-01T00:00:02.000Z'),
      message('m3', '2026-01-01T00:00:03.000Z'),
    ];

    it('keeps affordance when server total exceeds in-store loaded count', () => {
      expect(hasOlderMessagesAfterReopen(10, loaded)).toBe(true);
    });

    it('hides affordance when in-store already holds the full history', () => {
      expect(hasOlderMessagesAfterReopen(2, loaded)).toBe(false);
    });

    it('ignores locally-appended system cards when counting loaded real messages', () => {
      const withSystemCard = [
        ...loaded,
        message('mobile-system-1', '2026-01-01T00:00:04.000Z'),
      ];
      // total 2 == 2 real loaded (system card excluded) → no older.
      expect(hasOlderMessagesAfterReopen(2, withSystemCard)).toBe(false);
      // total 3 > 2 real loaded → older exist.
      expect(hasOlderMessagesAfterReopen(3, withSystemCard)).toBe(true);
    });

    it('falls back to window heuristic when server total is unknown', () => {
      const fullWindow = Array.from({ length: MESSAGE_PAGE_SIZE }, (_, index) =>
        message(`w${index}`, `2026-01-02T00:00:${String(index).padStart(2, '0')}.000Z`));
      expect(hasOlderMessagesAfterReopen(undefined, fullWindow)).toBe(true);
      expect(hasOlderMessagesAfterReopen(undefined, loaded)).toBe(false);
    });

    it('returns false when nothing is loaded', () => {
      expect(hasOlderMessagesAfterReopen(5, [])).toBe(false);
      expect(hasOlderMessagesAfterReopen(undefined, [])).toBe(false);
    });
  });

  describe('hasOlderMessagesByServerCount (optimistic affordance on cache hydrate)', () => {
    const loaded = [
      message('m2', '2026-01-01T00:00:02.000Z'),
      message('m3', '2026-01-01T00:00:03.000Z'),
    ];

    it('lights the affordance only when a known server total exceeds loaded real messages', () => {
      expect(hasOlderMessagesByServerCount(10, loaded)).toBe(true);
      expect(hasOlderMessagesByServerCount(2, loaded)).toBe(false);
    });

    it('never lights up when the server total is unknown (no window fallback)', () => {
      // 与 hasOlderMessagesAfterReopen 不同:_count 未知一律 false,绝不凭空点亮入口。
      const fullWindow = Array.from({ length: MESSAGE_PAGE_SIZE }, (_, index) =>
        message(`w${index}`, `2026-01-02T00:00:${String(index).padStart(2, '0')}.000Z`));
      expect(hasOlderMessagesByServerCount(undefined, fullWindow)).toBe(false);
      expect(hasOlderMessagesByServerCount(undefined, loaded)).toBe(false);
    });

    it('excludes locally-appended system cards from the loaded count', () => {
      const withSystemCard = [...loaded, message('mobile-system-1', '2026-01-01T00:00:04.000Z')];
      expect(hasOlderMessagesByServerCount(2, withSystemCard)).toBe(false);
      expect(hasOlderMessagesByServerCount(3, withSystemCard)).toBe(true);
    });
  });

  describe('bridgeLatestMessagePage', () => {
    const at = (second: number) => `2026-01-01T00:00:${String(second).padStart(2, '0')}.000Z`;
    const page = (ids: number[], limit = 2): MessagePageRetryResult => ({
      messages: ids.map((id) => message(`m${id}`, at(id))),
      limit,
      reducedByPayloadTooLarge: false,
    });
    // m1..m9 on the host; the client already verified up to m3.
    const host = (before: string) => {
      const index = Number(before.slice(1));
      return Promise.resolve(page([index - 2, index - 1].filter((id) => id >= 1)));
    };
    const reachesM3 = (rows: readonly RemoteMessage[]) => !rows.some((row) => row.id === 'm3');

    it('returns the latest page unchanged when it already joins', async () => {
      const latest = page([8, 9]);
      const readBefore = vi.fn(host);
      await expect(bridgeLatestMessagePage(latest, {
        needsBridge: () => false, readBefore, isCurrent: () => true,
      })).resolves.toBe(latest);
      expect(readBefore).not.toHaveBeenCalled();
    });

    it('reads older pages until the window joins and keeps the oldest page continuation', async () => {
      const readBefore = vi.fn(host);
      const bridged = await bridgeLatestMessagePage(page([8, 9]), {
        needsBridge: reachesM3, readBefore, isCurrent: () => true,
      });
      expect(readBefore.mock.calls.map(([before]) => before)).toEqual(['m8', 'm6', 'm4']);
      expect(bridged.messages.map((row) => row.id)).toEqual(['m2', 'm3', 'm4', 'm5', 'm6', 'm7', 'm8', 'm9']);
      expect(shouldKeepOlderMessagesAffordance(bridged)).toBe(true);
    });

    it('stops at the page budget, at history start, or when superseded', async () => {
      const capped = await bridgeLatestMessagePage(page([8, 9]), {
        needsBridge: reachesM3, readBefore: host, isCurrent: () => true, maxPages: 1,
      });
      expect(capped.messages.map((row) => row.id)).toEqual(['m6', 'm7', 'm8', 'm9']);

      const start = await bridgeLatestMessagePage(page([2, 3]), {
        needsBridge: () => true, readBefore: host, isCurrent: () => true,
      });
      expect(start.messages.map((row) => row.id)).toEqual(['m1', 'm2', 'm3']);
      expect(shouldKeepOlderMessagesAffordance(start)).toBe(false);

      const latest = page([8, 9]);
      await expect(bridgeLatestMessagePage(latest, {
        needsBridge: reachesM3, readBefore: host, isCurrent: () => false,
      })).resolves.toBe(latest);
    });

    it('fails the snapshot when a bridge read fails, so recovery retries instead of committing a gap', async () => {
      await expect(bridgeLatestMessagePage(page([8, 9]), {
        needsBridge: reachesM3, readBefore: () => Promise.reject(new Error('INVOKE_TIMEOUT')), isCurrent: () => true,
      })).rejects.toThrow('INVOKE_TIMEOUT');
    });
  });
});