fix(assets): defer a loadMore started while a refresh is in flight

Splitting the shared in-flight guard fixed a refresh being swallowed by a
pending loadMore, but it also dropped the protection the shared guard gave
in the other direction. On main a loadMore issued while a refresh was
pending returned the refresh's promise and did nothing. It now issues a
real request, and because the refresh has already rewound the offset and
cursor to the head, that request re-fetches the first page. Every id
dedupes against the just-refreshed seenIds, so `fresh` is empty and
`flatOutputHasMore` is stranded at false, dead-ending pagination even
though the server reported more pages.

The epoch guard does not catch this: the loadMore captures the epoch after
the refresh has already incremented it, so the two match on settle.

Defer to the in-flight refresh instead, mirroring the branch directly above
that defers to an in-flight loadMore.

Not reachable through the one current consumer, which gates loadMore on
`!loading`, but the store should not depend on callers for this.

Author: mattmillerai

src/stores/assetsStore.test.ts

@@ -2511,6 +2511,33 @@ describe('assetsStore - Flat Output Assets (cloud-only)', () => {
       }
     })
 
+    it('defers a loadMore started during a refresh instead of stranding hasMore', async () => {
+      const { store } = await setupStoreWithFirstPage()
+      const refreshPage = deferredPage()
+
+      vi.mocked(assetService.getAssetsPageByTag).mockReturnValueOnce(
+        refreshPage.promise
+      )
+
+      const refreshResult = store.updateFlatOutputs()
+      const loadMoreResult = store.loadMoreFlatOutputs()
+
+      // The refresh already rewound the offset to the head, so the loadMore has
+      // no next page to ask for and must not issue a second request.
+      expect(vi.mocked(assetService.getAssetsPageByTag)).toHaveBeenCalledTimes(
+        1
+      )
+
+      const head = Array.from({ length: FLAT_OUTPUT_PAGE_SIZE }, (_, i) =>
+        makeAsset(`b${i}`, `g${i}.png`)
+      )
+      refreshPage.resolve(makePage(head, { hasMore: true }))
+      await Promise.all([refreshResult, loadMoreResult])
+
+      expect(store.flatOutputHasMore).toBe(true)
+      expect(store.flatOutputAssets).toHaveLength(FLAT_OUTPUT_PAGE_SIZE)
+    })
+
     it('concurrent refreshes deduplicate the network call and produce consistent state', async () => {
       const page = deferredPage()
       vi.mocked(assetService.getAssetsPageByTag).mockReturnValueOnce(

src/stores/assetsStore.ts

@@ -329,6 +329,14 @@ export const useAssetsStore = defineStore('assets', () => {
       await flatOutputLoadMoreInFlight.value
       return
     }
+    // A refresh has already reset the offset and cursor to the head, so there
+    // is no next page to ask for yet; the refresh itself delivers that page.
+    // Issuing one anyway re-fetches the head, which dedupes to nothing and
+    // would strand `flatOutputHasMore` at false.
+    if (flatOutputRefreshInFlight.value) {
+      await flatOutputRefreshInFlight.value
+      return
+    }
 
     flatOutputError.value = null