Feature: Lazy page-by-page restoration for infinite queries with experimental_createQueryPersister

[inducingchaos]

Problem

The experimental_createQueryPersister stores and restores the entire InfiniteData object ({ pages: [...], pageParams: [...] }) as a single cache entry. When an infinite query is first used:

1. persisterFn checks query.state.data === undefined
2. Retrieves ALL pages from storage
3. Returns the full InfiniteData at once
4. UI renders all cached pages immediately instead of respecting pagination

The "lazy" restoration currently only means "restore when query is first used" - not "restore page by page". This causes performance issues when many pages are cached, as all pages are loaded into memory and rendered at once.

Use Case

When using infinite queries with persistence:

• User scrolls through multiple pages (e.g., 7 pages of 25 items each = 175 items)
• Data is persisted to storage
• User closes and reopens the app
• On restore, all 175 items are loaded and rendered immediately
• Expected: Only the first page (25 items) should be restored initially
• Subsequent pages should be restored lazily as fetchNextPage is called

Proposed Solution

Add support for page-by-page lazy restoration in the persister. The persister should:

1. On initial restore: Return only the first page from persisted data
2. On fetchNextPage: Check if the requested page exists in persisted data before fetching from network
3. Respect staleness: Use dataUpdatedAt to determine if cached pages are stale

Architecture

flowchart TD
subgraph storage [Persistent Storage]
FullData["Full InfiniteData\n{pages: [p1,p2,...], pageParams: [...]}"]
end

subgraph memory [In-Memory Page Cache]
    PageCache["Map<queryHash, PersistedQuery>"]
end

subgraph persister [Persister Logic]
    RestoreLogic["On initial restore:\n1. Load full data into PageCache\n2. Return only page 1"]
    FetchLogic["On fetchNextPage:\n1. Check PageCache for page N\n2. If found + fresh: return cached\n3. Else: fetch from network"]
end

storage --> RestoreLogic
RestoreLogic --> PageCache
PageCache --> FetchLogic
FetchLogic -->|"Cache miss/stale"| Network["Network Request"]

[inducingchaos]

TL;DR:

The issue: when the persister restores, it loads it all into memory and shows a list of ~175 items, rather than the 25 of the first page.

maxPages was considered: https://tanstack.com/query/latest/docs/framework/react/guides/infinite-queries#what-if-i-want-to-limit-the-number-of-pages

My use case is a useInfiniteQuery in a Raycast extension, where there is zero control over which rows are rendered - everything relies on the pagination props hasNextPage and fetchNextPage

With the way that maxPages works - as soon as you scroll past the number of max pages (e.g., 1-3), the items at the top of the list are yanked out. This is not ideal.

Goal: We should only see the first page, and every subsequent page will only be loaded into the query cache when it is paginated - fetching from the persister store if possible, otherwise over the network.