Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
fix(web): reconcile foreground messages independently of websocket validation (#861)
Gener37fbbc667acc
diff --git a/src/web/src/hooks/community/community-ws/reconnect-messages.test.ts b/src/web/src/hooks/community/community-ws/reconnect-messages.test.tsindex 0c8c28824..e8c453422 100644--- a/src/web/src/hooks/community/community-ws/reconnect-messages.test.ts+++ b/src/web/src/hooks/community/community-ws/reconnect-messages.test.ts@@ -124,6 +124,96 @@ describe("focused message reconnect catch-up", () => {queryClient.clear()})+ it.each(["channel", "dm"] as const)("shares in-flight %s window work across foreground, reconnect and gap repair", async (kind) => {+ const client = new QueryClient()+ const key = kind === "channel" ? communityKeys.channelMessages("shared") : communityKeys.dmMessages("shared")+ const { unsubscribe } = seedActiveQuery(client, key)+ let release!: (page: unknown) => void+ apiFetchMock.mockReturnValueOnce(new Promise((resolve) => { release = resolve }))+ const cancel = vi.spyOn(client, "cancelQueries")+ const first = reconcileFocusedMessageQueries(client, kind, "shared")+ await vi.waitFor(() => expect(apiFetchMock).toHaveBeenCalledOnce())+ const reconnect = reconcileFocusedMessageQueries(client, kind, "shared")+ const gap = scheduleFocusedMessageGapRepair(client, { kind, scopeId: "shared" }, 5)+ expect(reconnect).toBe(first)+ expect(cancel).toHaveBeenCalledOnce()+ expect(apiFetchMock).toHaveBeenCalledOnce()+ apiFetchMock.mockResolvedValueOnce({ messages: [3, 4, 5].map((seq) => ({ id: `m_${seq}`, seq, createdAt: `2026-08-15T00:00:0${seq}.000Z` })), latestSeq: 5, hasMoreNewer: false })+ release({ messages: [], latestSeq: 2, hasMore: false })+ await Promise.all([first, reconnect, gap])+ expect(apiFetchMock).toHaveBeenCalledTimes(2)+ expect(client.getQueryData<{ pages: Array<{ messages: Array<{ id: string }> }> }>(key)?.pages.flatMap((page) => page.messages.map((message) => message.id))).toEqual(["m_2", "m_3", "m_4", "m_5", "m_1"])+ apiFetchMock.mockResolvedValueOnce({ messages: [], latestSeq: 5, hasMore: false })+ await reconcileFocusedMessageQueries(client, kind, "shared")+ expect(apiFetchMock).toHaveBeenCalledTimes(3)+ unsubscribe()+ client.clear()+ })++ it("refreshes a completed query variant when another variant still holds the scope owner", async () => {+ const client = new QueryClient()+ const key = communityKeys.channelMessages("variants")+ const taggedKey = [...key, "tag", "selected"]+ const subscriptions = [seedActiveQuery(client, key), seedActiveQuery(client, taggedKey)]+ let releaseTagged!: (page: unknown) => void+ const tagged = new Promise((resolve) => { releaseTagged = resolve })+ const fresh = { messages: [3, 4, 5].map((seq) => ({ id: `m_${seq}`, seq, createdAt: `2026-08-15T00:00:0${seq}.000Z` })), latestSeq: 5, hasMoreNewer: false }+ apiFetchMock.mockImplementation((url: string) => {+ if (url.includes("since=")) return Promise.resolve(fresh)+ if (url.includes("tag=")) return tagged+ return Promise.resolve({ messages: [], latestSeq: apiFetchMock.mock.calls.length > 2 ? 5 : 2, hasMore: false })+ })+ const first = reconcileFocusedMessageQueries(client, "channel", "variants")+ await vi.waitFor(() => expect(publishCommunityMessagesMock).toHaveBeenCalledOnce())+ const gap = scheduleFocusedMessageGapRepair(client, { kind: "channel", scopeId: "variants" }, 5)+ await vi.waitFor(() => expect(publishCommunityMessagesMock).toHaveBeenCalledTimes(2))+ releaseTagged({ messages: [], latestSeq: 2, hasMore: false })+ await Promise.all([first, gap])+ for (const queryKey of [key, taggedKey]) {+ expect(client.getQueryData<{ pages: Array<{ messages: Array<{ id: string }> }> }>(queryKey)?.pages.flatMap((page) => page.messages.map((message) => message.id))).toEqual(["m_2", "m_3", "m_4", "m_5", "m_1"])+ }+ expect(apiFetchMock.mock.calls.filter(([url]) => String(url).includes("tag=") && !String(url).includes("since="))).toHaveLength(1)+ for (const subscription of subscriptions) subscription.unsubscribe()+ client.clear()+ })++ it.each(["account", "permission", "replacement"] as const)("does not share an old repair after %s changes or let its cleanup remove the new owner", async (change) => {+ const client = new QueryClient()+ useCommunityWsStore.getState().activateProfileAccount("a")+ const key = communityKeys.channelMessages("changed")+ const subscriptions = [seedActiveQuery(client, key).unsubscribe]+ let rejectOld!: (reason: unknown) => void+ let releaseNew!: (page: unknown) => void+ apiFetchMock.mockReturnValueOnce(new Promise((_, reject) => { rejectOld = reject }))+ const first = reconcileFocusedMessageQueries(client, "channel", "changed")+ await vi.waitFor(() => expect(apiFetchMock).toHaveBeenCalledOnce())+ if (change === "account") useCommunityWsStore.getState().activateProfileAccount("b")+ else if (change === "permission") {+ useCommunityWsStore.getState().revokeChannelAccess("server", "changed")+ useCommunityWsStore.getState().rememberChannelAccess("server", "changed")+ } else {+ client.removeQueries({ queryKey: key, exact: true })+ subscriptions.push(seedActiveQuery(client, key).unsubscribe)+ }+ apiFetchMock.mockReturnValueOnce(new Promise((resolve) => { releaseNew = resolve }))+ const second = reconcileFocusedMessageQueries(client, "channel", "changed")+ expect(second).not.toBe(first)+ await vi.waitFor(() => expect(apiFetchMock).toHaveBeenCalledTimes(2))+ rejectOld(new ApiError("old denial", 403))+ await first+ expect(client.getQueryData(key)).toBeDefined()+ expect(reconcileFocusedMessageQueries(client, "channel", "changed")).toBe(second)+ expect(scheduleFocusedMessageGapRepair(client, { kind: "channel", scopeId: "changed" }, 5)).not.toBeNull()+ expect(apiFetchMock).toHaveBeenCalledTimes(2)+ apiFetchMock.mockResolvedValueOnce({ messages: [], latestSeq: 5, hasMoreNewer: false })+ releaseNew({ messages: [{ id: "current", seq: 2, createdAt: "2026-08-15T00:00:02.000Z" }], latestSeq: 2, hasMore: false })+ await second+ expect(publishCommunityMessagesMock).toHaveBeenCalledOnce()+ expect(client.getQueryData<{ pages: Array<{ messages: Array<{ id: string }> }> }>(key)?.pages[0].messages[0].id).toBe("current")+ for (const unsubscribe of subscriptions) unsubscribe()+ client.clear()+ })+it("does not repair exact-next, duplicate, or out-of-order frames", () => {const queryClient = new QueryClient()const queryKey = communityKeys.channelMessages("ch_contiguous")@@ -395,7 +485,12 @@ describe("focused message reconnect catch-up", () => {latestSeq: 3,})- await reconcileFocusedMessageQueries(queryClient, "channel", "ch_race")+ const cancel = vi.spyOn(queryClient, "cancelQueries")+ const foreground = reconcileFocusedMessageQueries(queryClient, "channel", "ch_race")+ const reconnect = reconcileFocusedMessageQueries(queryClient, "channel", "ch_race")+ expect(reconnect).toBe(foreground)+ await Promise.all([foreground, reconnect])+ expect(cancel).toHaveBeenCalledOnce()resolveStaleOlder({messages: [{ id: "stale_m_1" }],hasMore: false,@@ -415,6 +510,77 @@ describe("focused message reconnect catch-up", () => {unsubscribe()})+ it("consumes a new gap arriving while the one pagination replay is still pending", async () => {+ const client = new QueryClient()+ const key = communityKeys.channelMessages("late-replay")+ let olderCalls = 0+ const newest = { messages: [{ id: "m_2", seq: 2, createdAt: "2026-08-15T00:00:02.000Z" }], latestSeq: 2, hasMore: true, cursor: "older" }+ const older = { messages: [{ id: "m_1", seq: 1, createdAt: "2026-08-15T00:00:01.000Z" }], latestSeq: 2, hasMore: false }+ let releaseStale!: (value: typeof older) => void+ let releaseReplay!: (value: typeof older) => void+ const observer = new InfiniteQueryObserver(client, {+ queryKey: key,+ queryFn: async ({ pageParam }) => {+ if (pageParam.mode === "newest") return newest+ olderCalls += 1+ return new Promise<typeof newest | typeof older>((resolve) => {+ if (olderCalls === 1) releaseStale = resolve+ else releaseReplay = resolve+ })+ },+ initialPageParam: { mode: "newest" },+ getNextPageParam: (last) => last.hasMore ? { mode: "older" } : undefined,+ })+ const unsubscribe = observer.subscribe(() => undefined)+ await vi.waitFor(() => expect(observer.getCurrentResult().isSuccess).toBe(true))+ const pagination = observer.fetchNextPage()+ await vi.waitFor(() => expect(olderCalls).toBe(1))+ apiFetchMock.mockResolvedValueOnce(newest).mockResolvedValueOnce({ ...newest, latestSeq: 5 }).mockResolvedValueOnce({+ messages: [3, 4, 5].map((seq) => ({ id: `m_${seq}`, seq, createdAt: `2026-08-15T00:00:0${seq}.000Z` })), latestSeq: 5, hasMoreNewer: false,+ })+ const cancel = vi.spyOn(client, "cancelQueries")+ const foreground = reconcileFocusedMessageQueries(client, "channel", "late-replay")+ await vi.waitFor(() => expect(olderCalls).toBe(2))+ const gap = scheduleFocusedMessageGapRepair(client, { kind: "channel", scopeId: "late-replay" }, 5)+ expect(apiFetchMock).toHaveBeenCalledOnce()+ releaseReplay(older)+ releaseStale(older)+ await Promise.all([foreground, gap, pagination])+ expect(apiFetchMock).toHaveBeenCalledTimes(3)+ expect(cancel).toHaveBeenCalledOnce()+ expect(olderCalls).toBe(2)+ expect(client.getQueryData<{ pages: Array<{ messages: Array<{ id: string }> }> }>(key)?.pages.flatMap((entry) => entry.messages.map((row) => row.id))).toEqual(["m_2", "m_3", "m_4", "m_5", "m_1"])+ unsubscribe()+ client.clear()+ })++ it("does not replay completed pagination whose fetch metadata remains idle", async () => {+ const client = new QueryClient()+ const key = communityKeys.channelMessages("idle-pagination")+ let olderCalls = 0+ const newest = { messages: [{ id: "m_2", seq: 2, createdAt: "2026-08-15T00:00:02.000Z" }], latestSeq: 2, hasMore: true, cursor: "older-2" }+ const observer = new InfiniteQueryObserver(client, {+ queryKey: key,+ queryFn: async ({ pageParam }) => {+ if (pageParam.mode === "newest") return newest+ olderCalls += 1+ return { messages: [{ id: "m_1", seq: 1 }], latestSeq: 2, hasMore: true, cursor: "older-1" }+ },+ initialPageParam: { mode: "newest", cursor: "" },+ getNextPageParam: (last) => last.hasMore ? { mode: "older", cursor: last.cursor } : undefined,+ })+ const unsubscribe = observer.subscribe(() => undefined)+ await vi.waitFor(() => expect(observer.getCurrentResult().isSuccess).toBe(true))+ await observer.fetchNextPage()+ expect(client.getQueryState(key)?.fetchStatus).toBe("idle")+ expect(client.getQueryState(key)?.fetchMeta?.fetchMore?.direction).toBe("forward")+ apiFetchMock.mockResolvedValue(newest)+ await reconcileFocusedMessageQueries(client, "channel", "idle-pagination")+ expect(olderCalls).toBe(1)+ unsubscribe()+ client.clear()+ })+it.each([["channel", communityKeys.channelMessages("ch_empty"), "ch_empty"],["dm", communityKeys.dmMessages("dm_empty"), "dm_empty"],@@ -449,6 +615,114 @@ describe("focused message reconnect catch-up", () => {},)+ it.each(["channel", "dm"] as const)("rechecks a stale empty %s window when an in-flight foreground repair receives its first gap", async (kind) => {+ const client = new QueryClient()+ const scopeId = "first-gap"+ const key = kind === "channel" ? communityKeys.channelMessages(scopeId) : communityKeys.dmMessages(scopeId)+ const { queryFn, unsubscribe } = seedEmptyActiveQuery(client, key)+ let release!: (page: unknown) => void+ apiFetchMock.mockReturnValueOnce(new Promise((resolve) => { release = resolve }))+ const repair = reconcileFocusedMessageQueries(client, kind, scopeId)+ await vi.waitFor(() => expect(apiFetchMock).toHaveBeenCalledOnce())+ const gap = scheduleFocusedMessageGapRepair(client, { kind, scopeId }, 2)+ expect(gap).not.toBeNull()+ apiFetchMock.mockResolvedValueOnce({+ messages: [1, 2].map((seq) => ({ id: `m_${seq}`, seq, createdAt: `2026-08-15T00:00:0${seq}.000Z` })),+ latestSeq: 2,+ hasMore: false,+ })+ release({ messages: [], latestSeq: 0, hasMore: false })+ await Promise.all([repair, gap])+ expect(apiFetchMock).toHaveBeenCalledTimes(2)+ expect(apiFetchMock.mock.calls.map(([url]) => url)).toEqual([+ `/api/community/channels/${scopeId}/messages`,+ `/api/community/channels/${scopeId}/messages`,+ ])+ expect(client.getQueryData<{ pages: Array<{ messages: Array<{ id: string }> }> }>(key)?.pages[0].messages.map((message) => message.id)).toEqual(["m_1", "m_2"])+ expect(queryFn).not.toHaveBeenCalled()+ unsubscribe()+ client.clear()+ })++ it.each(["channel", "dm"] as const)("bounds stale empty %s reads and allows a later recovery", async (kind) => {+ const client = new QueryClient()+ const scopeId = "bounded-empty"+ const key = kind === "channel" ? communityKeys.channelMessages(scopeId) : communityKeys.dmMessages(scopeId)+ const { queryFn, unsubscribe } = seedEmptyActiveQuery(client, key)+ apiFetchMock.mockResolvedValue({ messages: [], latestSeq: 0, hasMore: false })+ await scheduleFocusedMessageGapRepair(client, { kind, scopeId }, 2)+ expect(apiFetchMock).toHaveBeenCalledTimes(8)+ expect(client.getQueryData<{ pages: Array<{ messages: unknown[] }> }>(key)?.pages[0].messages).toEqual([])+ apiFetchMock.mockResolvedValueOnce({ messages: [{ id: "m_later", seq: 1 }], latestSeq: 1, hasMore: false })+ await reconcileFocusedMessageQueries(client, kind, scopeId)+ expect(apiFetchMock).toHaveBeenCalledTimes(9)+ expect(client.getQueryData<{ pages: Array<{ messages: Array<{ id: string }> }> }>(key)?.pages[0].messages.map((message) => message.id)).toEqual(["m_later"])+ expect(queryFn).not.toHaveBeenCalled()+ unsubscribe()+ client.clear()+ })++ it.each(["permission", "replacement"] as const)("drops an empty-window retry result after %s changes", async (change) => {+ const client = new QueryClient()+ const scopeId = "empty-retry-owner"+ const key = communityKeys.channelMessages(scopeId)+ const subscriptions = [seedEmptyActiveQuery(client, key).unsubscribe]+ let release!: (page: unknown) => void+ apiFetchMock.mockResolvedValueOnce({ messages: [], latestSeq: 0, hasMore: false })+ apiFetchMock.mockReturnValueOnce(new Promise((resolve) => { release = resolve }))+ const gap = scheduleFocusedMessageGapRepair(client, { kind: "channel", scopeId }, 2)+ await vi.waitFor(() => expect(apiFetchMock).toHaveBeenCalledTimes(2))+ if (change === "permission") useCommunityWsStore.getState().revokeChannelAccess("server", scopeId)+ else {+ client.removeQueries({ queryKey: key, exact: true })+ subscriptions.push(seedActiveQuery(client, key).unsubscribe)+ }+ const current = client.getQueryData(key)+ release({ messages: [{ id: "m_obsolete", seq: 2 }], latestSeq: 2, hasMore: false })+ await gap+ expect(client.getQueryData(key)).toBe(current)+ expect(publishCommunityMessagesMock).not.toHaveBeenCalled()+ expect(apiFetchMock).toHaveBeenCalledTimes(2)+ for (const unsubscribe of subscriptions) unsubscribe()+ client.clear()+ })++ it("preserves a same-query cold reset until its canonical read completes instead of rebuilding pages from old HTTP", async () => {+ const client = new QueryClient()+ const key = communityKeys.channelMessages("reset-pending")+ const oldPage = { messages: [{ id: "m_old", seq: 2 }], latestSeq: 2, hasMore: false }+ client.setQueryData(key, { pages: [oldPage], pageParams: [{ mode: "newest" }] })+ let releaseCanonical!: (page: typeof oldPage) => void+ const queryFn = vi.fn(() => new Promise<typeof oldPage>((resolve) => { releaseCanonical = resolve }))+ const observer = new InfiniteQueryObserver(client, {+ queryKey: key,+ queryFn,+ initialPageParam: { mode: "newest" } as const,+ getNextPageParam: () => undefined,+ staleTime: Infinity,+ })+ const unsubscribe = observer.subscribe(() => undefined)+ const query = client.getQueryCache().find({ queryKey: key, exact: true })+ let releaseOld!: (page: typeof oldPage) => void+ apiFetchMock.mockReturnValueOnce(new Promise((resolve) => { releaseOld = resolve }))+ const repair = reconcileFocusedMessageQueries(client, "channel", "reset-pending")+ await vi.waitFor(() => expect(apiFetchMock).toHaveBeenCalledOnce())+ const reset = client.resetQueries({ queryKey: key, exact: true })+ await vi.waitFor(() => expect(queryFn).toHaveBeenCalledOnce())+ expect(client.getQueryCache().find({ queryKey: key, exact: true })).toBe(query)+ expect(client.getQueryData(key)).toBeUndefined()+ releaseOld(oldPage)+ await repair+ expect(client.getQueryData(key)).toBeUndefined()+ releaseCanonical({ messages: [{ id: "m_current", seq: 3 }], latestSeq: 3, hasMore: false })+ await reset+ expect(client.getQueryData<{ pages: Array<{ messages: Array<{ id: string }> }> }>(key)?.pages[0].messages.map((message) => message.id)).toEqual(["m_current"])+ expect(queryFn).toHaveBeenCalledOnce()+ expect(apiFetchMock).toHaveBeenCalledOnce()+ unsubscribe()+ client.clear()+ })+it.each([["channel", communityKeys.channelMessages("ch_cold"), "ch_cold"],["dm", communityKeys.dmMessages("dm_cold"), "dm_cold"],diff --git a/src/web/src/hooks/community/community-ws/reconnect-messages.ts b/src/web/src/hooks/community/community-ws/reconnect-messages.tsindex 33e8ca70a..10d99eebe 100644--- a/src/web/src/hooks/community/community-ws/reconnect-messages.ts+++ b/src/web/src/hooks/community/community-ws/reconnect-messages.ts@@ -1,4 +1,4 @@-import type { InfiniteData, QueryClient, QueryKey } from "@tanstack/react-query"+import type { InfiniteData, Query, QueryClient, QueryKey } from "@tanstack/react-query"import { apiFetchProfiles, messageProfilePatches } from "@/lib/community/profile-seed"import { ApiError } from "@/lib/errors"import { captureChannelMetadataToken, isChannelMetadataTokenCurrent } from "@/hooks/community/channel-metadata"@@ -125,7 +125,17 @@ type GapRepairScope = {serverId?: string}-const gapRepairs = new WeakMap<QueryClient, Map<string, Promise<void>>>()+type FocusedQueryRepair = { promise: Promise<void>; settled: boolean }++type FocusedMessageRepair = {+ token: ReturnType<typeof captureChannelMetadataToken>+ queries: Map<Query, FocusedQueryRepair>+ promise: Promise<void>+ gapPromise: Promise<void>+ target: { seq: number }+}++const focusedMessageRepairs = new WeakMap<QueryClient, Map<string, FocusedMessageRepair>>()function knownFocusedMessageSeq(queryClient: QueryClient,@@ -166,26 +176,7 @@ export function scheduleFocusedMessageGapRepair(incomingSeq: number,): Promise<void> | null {if (incomingSeq <= knownFocusedMessageSeq(queryClient, scope) + 1) return null- let repairs = gapRepairs.get(queryClient)- if (!repairs) {- repairs = new Map()- gapRepairs.set(queryClient, repairs)- }- const key = `${scope.kind}:${scope.scopeId}`- const existing = repairs.get(key)- if (existing) return existing- const repair = reconcileFocusedMessageQueries(- queryClient,- scope.kind,- scope.scopeId,- ).catch(() => {- // Realtime delivery is fail-open. A reconnect still runs the same- // authoritative reconciliation path if this best-effort repair fails.- }).finally(() => {- repairs!.delete(key)- })- repairs.set(key, repair)- return repair+ return getFocusedMessageRepair(queryClient, scope.kind, scope.scopeId, incomingSeq).gapPromise}/**@@ -227,6 +218,7 @@ async function fetchCatchUp(scopeId: string,cursor: string,tag: string | null,+ target: { seq: number },): Promise<MessagesPage> {const messages: Msg[] = []let latestSeq = 0@@ -245,7 +237,10 @@ async function fetchCatchUp(latestSeq = Math.max(latestSeq, page.latestSeq ?? 0)hasMoreNewer = page.hasMoreNewer ?? falsenewerCursor = page.newerCursor- if (!hasMoreNewer || !newerCursor) break+ if (!hasMoreNewer || !newerCursor) {+ if (latestSeq < target.seq) continue+ break+ }nextCursor = newerCursor}@@ -293,11 +288,12 @@ function mergeReconciledPages(return { ...cache, pages }}-export async function reconcileFocusedMessageQueries(+function getFocusedMessageRepair(queryClient: QueryClient,kind: "channel" | "dm",scopeId: string,-): Promise<void> {+ incomingSeq = 0,+): FocusedMessageRepair {const queryKey = kind === "channel"? communityKeys.channelMessages(scopeId): communityKeys.dmMessages(scopeId)@@ -305,71 +301,154 @@ export async function reconcileFocusedMessageQueries(queryKey,type: "active",})+ let repairs = focusedMessageRepairs.get(queryClient)+ if (!repairs) {+ repairs = new Map()+ focusedMessageRepairs.set(queryClient, repairs)+ }+ const key = `${kind}:${scopeId}`+ const previous = repairs.get(key)+ const reusable = previous && isChannelMetadataTokenCurrent(previous.token)+ ? previous+ : undefined+ const target = reusable?.target ?? { seq: 0 }+ target.seq = Math.max(target.seq, incomingSeq)+ if (reusable+ && reusable.queries.size === queries.length+ && queries.every((query) => {+ const operation = reusable.queries.get(query)+ return operation && !operation.settled+ })) return reusableconst token = captureChannelMetadataToken(scopeId)- const operations = queries.map(async (query) => {- const publicationToken = captureCommunityLiveSnapshotToken(queryClient)- const isCurrent = () => isChannelMetadataTokenCurrent(token)- && queryClient.getQueryCache().find({ queryKey: query.queryKey, exact: true }) === query- // Infinite-query pagination computes its result from the data snapshot at- // fetch start. If that generation completes after reconciliation, TanStack- // can replace the reconciled cache with its stale snapshot. Capture the- // user's pagination intent, cancel that exact generation, then replay the- // same direction against the reconciled cache below.- const pendingDirection = query.state.fetchMeta?.fetchMore?.direction- await queryClient.cancelQueries(- { queryKey: query.queryKey, exact: true },- { revert: true, silent: true },- )-- if (!isCurrent()) return- let accessDenied = false- try {- const window = warmReconnectWindow(query.queryKey, query.state.data)- if (!window) {- await queryClient.refetchQueries(- { queryKey: query.queryKey, exact: true, type: "active" },- { throwOnError: true },- )- return- }- const refreshed = await fetchCurrentWindow(- scopeId,- window.pageParam,- window.tag,+ const queryOperations = new Map<Query, FocusedQueryRepair>()+ for (const query of queries) {+ const existing = reusable?.queries.get(query)+ if (existing && !existing.settled) {+ queryOperations.set(query, existing)+ continue+ }+ const operation = (async () => {+ const publicationToken = captureCommunityLiveSnapshotToken(queryClient)+ const isCurrent = () => isChannelMetadataTokenCurrent(token)+ && queryClient.getQueryCache().find({ queryKey: query.queryKey, exact: true }) === query+ // Infinite-query pagination computes its result from the data snapshot at+ // fetch start. If that generation completes after reconciliation, TanStack+ // can replace the reconciled cache with its stale snapshot. Capture the+ // user's pagination intent, cancel that exact generation, then replay the+ // same direction against the reconciled cache below.+ const pendingDirection = query.state.fetchStatus !== "idle"+ ? query.state.fetchMeta?.fetchMore?.direction+ : undefined+ await queryClient.cancelQueries(+ { queryKey: query.queryKey, exact: true },+ { revert: true, silent: true },)+if (!isCurrent()) return- const catchUp = window.cursor !== null- && (refreshed.latestSeq ?? 0) > window.latestSeq- ? await fetchCatchUp(scopeId, window.cursor, window.tag)- : null- if (!isCurrent()) return- publishCommunityMessages(queryClient, {- channelId: scopeId,- messages: catchUp- ? [...refreshed.messages, ...catchUp.messages]- : refreshed.messages,- proof: { token: publicationToken, signal: undefined },- })- queryClient.setQueryData<MessageCache>(query.queryKey, (current) => (- isMessageCache(current)- ? mergeReconciledPages(current, refreshed, catchUp)- : current- ))- } catch (error) {- if (!isCurrent()) return- if (!isDefinitiveAccessDenial(error)) throw error- accessDenied = true- clearDeniedMessageScope(queryClient, kind, scopeId)- } finally {- if (pendingDirection && !accessDenied && isCurrent()) {- await query.fetch(undefined, {- meta: { fetchMore: { direction: pendingDirection } },+ let accessDenied = false+ let processedTarget = 0+ const refresh = async () => {+ let window = warmReconnectWindow(query.queryKey, query.state.data)+ if (!window) {+ await queryClient.refetchQueries(+ { queryKey: query.queryKey, exact: true, type: "active" },+ { throwOnError: true },+ )+ if (!isCurrent()) return+ window = warmReconnectWindow(query.queryKey, query.state.data)+ if (!window || target.seq <= window.latestSeq) {+ processedTarget = target.seq+ return+ }+ }+ let refreshed = await fetchCurrentWindow(+ scopeId,+ window.pageParam,+ window.tag,+ )+ if (!isCurrent()) return+ for (let attempt = 1; window.cursor === null+ && (refreshed.latestSeq ?? 0) < target.seq+ && attempt < MAX_CATCH_UP_PAGES; attempt += 1) {+ refreshed = await fetchCurrentWindow(scopeId, window.pageParam, window.tag)+ if (!isCurrent()) return+ }+ const catchUp = window.cursor !== null+ && Math.max(refreshed.latestSeq ?? 0, target.seq) > window.latestSeq+ ? await fetchCatchUp(scopeId, window.cursor, window.tag, target)+ : null+ if (!isCurrent()) return+ const coveredTarget = target.seq+ publishCommunityMessages(queryClient, {+ channelId: scopeId,+ messages: catchUp+ ? [...refreshed.messages, ...catchUp.messages]+ : refreshed.messages,+ proof: { token: publicationToken, signal: undefined },})+ queryClient.setQueryData<MessageCache>(query.queryKey, (current) => (+ isMessageCache(current)+ ? mergeReconciledPages(current, refreshed, catchUp)+ : current+ ))+ processedTarget = coveredTarget+ }+ const reconcile = async () => {+ try {+ await refresh()+ } catch (error) {+ if (!isCurrent()) return+ if (!isDefinitiveAccessDenial(error)) throw error+ accessDenied = true+ clearDeniedMessageScope(queryClient, kind, scopeId)+ }}+ try {+ await reconcile()+ } finally {+ try {+ if (pendingDirection && !accessDenied && isCurrent()) {+ await query.fetch(undefined, {+ meta: { fetchMore: { direction: pendingDirection } },+ })+ }+ } finally {+ if (!accessDenied && isCurrent() && target.seq > processedTarget) {+ await reconcile()+ }+ }+ }+ })()+ const queryRepair = { promise: operation, settled: false }+ queryOperations.set(query, queryRepair)+ void operation.then(+ () => { queryRepair.settled = true },+ () => { queryRepair.settled = true },+ )+ }+ const promise = Promise.allSettled([...queryOperations.values()].map((query) => query.promise)).then((settled) => {+ if (settled.some((result) => result.status === "rejected")) {+ throw new Error("focused messages failed")}})- const settled = await Promise.allSettled(operations)- if (settled.some((result) => result.status === "rejected")) {- throw new Error("focused messages failed")+ const repair: FocusedMessageRepair = {+ token,+ queries: queryOperations,+ promise,+ gapPromise: promise.catch(() => undefined),+ target,}+ repairs.set(key, repair)+ void promise.finally(() => {+ if (repairs.get(key) === repair) repairs.delete(key)+ }).catch(() => undefined)+ return repair+}++export function reconcileFocusedMessageQueries(+ queryClient: QueryClient,+ kind: "channel" | "dm",+ scopeId: string,+): Promise<void> {+ return getFocusedMessageRepair(queryClient, kind, scopeId).promise}diff --git a/src/web/src/hooks/community/community-ws/reconnect.ts b/src/web/src/hooks/community/community-ws/reconnect.tsindex c1c4f5d65..92ebc95e5 100644--- a/src/web/src/hooks/community/community-ws/reconnect.ts+++ b/src/web/src/hooks/community/community-ws/reconnect.ts@@ -124,6 +124,36 @@ async function reconcileCachedServer(queryClient: QueryClient, serverId: string)}}+export async function reconcileFocusedCommunityMessages(+ queryClient: QueryClient,+ sub = useCommunityStore.getState().subscription,+) {+ const operations: Promise<unknown>[] = []+ if (sub.channelId) {+ operations.push(reconcileFocusedMessageQueries(+ queryClient,+ "channel",+ sub.channelId,+ ))+ }+ if (sub.secondaryChannelId) {+ operations.push(reconcileFocusedMessageQueries(+ queryClient,+ "channel",+ sub.secondaryChannelId,+ ))+ }+ if (sub.dmConversationId) {+ operations.push(reconcileFocusedMessageQueries(+ queryClient,+ "dm",+ sub.dmConversationId,+ ))+ }+ const settled = await Promise.allSettled(operations)+ if (settled.some((result) => result.status === "rejected")) throw new Error("focused messages failed")+}+function policyExecutors(queryClient: QueryClient,viewerUserId?: string | null,@@ -131,32 +161,7 @@ function policyExecutors(const sub = useCommunityStore.getState().subscriptionconst queryKeys = queryClient.getQueryCache().getAll().map((query) => query.queryKey)return {- "focused-messages": async () => {- const operations: Promise<unknown>[] = []- if (sub.channelId) {- operations.push(reconcileFocusedMessageQueries(- queryClient,- "channel",- sub.channelId,- ))- }- if (sub.secondaryChannelId) {- operations.push(reconcileFocusedMessageQueries(- queryClient,- "channel",- sub.secondaryChannelId,- ))- }- if (sub.dmConversationId) {- operations.push(reconcileFocusedMessageQueries(- queryClient,- "dm",- sub.dmConversationId,- ))- }- const settled = await Promise.allSettled(operations)- if (settled.some((result) => result.status === "rejected")) throw new Error("focused messages failed")- },+ "focused-messages": () => reconcileFocusedCommunityMessages(queryClient, sub),"focused-opener": async () => {const parentMessageId = useCommunityStore.getState().currentChannelMeta?.parentMessageIdif (!parentMessageId) returndiff --git a/src/web/src/hooks/community/use-community-ws-foreground.test.ts b/src/web/src/hooks/community/use-community-ws-foreground.test.tsnew file mode 100644index 000000000..5c67af44e--- /dev/null+++ b/src/web/src/hooks/community/use-community-ws-foreground.test.ts@@ -0,0 +1,163 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"+import { QueryObserver } from "@tanstack/react-query"+import { communityKeys } from "@/lib/query-keys"+import { useCommunityStore } from "@/stores/community"+import { useCommunityWsStore } from "@/stores/community/ws"+import {+ capturedOnMessage,+ capturedOnReconnect,+ capturedQueryClient,+ capturedUseUserWsOptions,+ cleanupCommunityWsHarness,+ flushEffects,+ getCommunityApiFetchMock,+ messageCreate,+ mountHook,+ resetCommunityWsHarness,+ resetHookMemoization,+ unmountHook,+} from "./community-ws/test-harness"++const subscriptions: Array<() => void> = []+const message = (id: string, seq = 1) => ({+ id, seq, type: "chat" as const, content: id, authorId: "author",+ createdAt: `2026-08-15T00:00:0${seq}.000Z`,+})+const page = (id: string) => ({ messages: [message(id)], latestSeq: 1, hasMore: false })++function seed(id: string, kind: "channel" | "dm" = "channel") {+ const key = kind === "channel" ? communityKeys.channelMessages(id) : communityKeys.dmMessages(id)+ capturedQueryClient.setQueryData(key, { pages: [page(`old-${id}`)], pageParams: [{ mode: "newest" }] })+ const observer = new QueryObserver(capturedQueryClient, {+ queryKey: key,+ queryFn: async () => ({ pages: [page(`query-${id}`)], pageParams: [{ mode: "newest" }] }),+ staleTime: Infinity,+ })+ subscriptions.push(observer.subscribe(() => undefined))+ return key+}++beforeEach(resetCommunityWsHarness)+afterEach(async () => {+ for (const unsubscribe of subscriptions.splice(0)) unsubscribe()+ await cleanupCommunityWsHarness()+})++describe("community foreground message reconciliation", () => {+ it.each(["split", "dm"] as const)("starts only focused %s messages while transport access is disconnected", async (layout) => {+ const store = useCommunityStore.getState()+ const secondary = Symbol("parent")+ if (layout === "split") {+ store.subscribe({ channelId: "primary" })+ store.claimSecondaryChannel(secondary, "parent")+ seed("primary")+ seed("parent")+ } else {+ store.subscribe({ dmConversationId: "dm" })+ seed("dm", "dm")+ }+ seed("unrelated")+ await mountHook()+ flushEffects()+ useCommunityWsStore.getState().markAccessDisconnected()+ getCommunityApiFetchMock().mockImplementation(async (path) => page(String(path)))+ const invalidate = vi.spyOn(capturedQueryClient, "invalidateQueries")+ await capturedUseUserWsOptions!.onForeground!()+ const paths = getCommunityApiFetchMock().mock.calls.map(([path]) => path)+ expect(paths).toEqual(layout === "split" ? [+ "/api/community/channels/primary/messages",+ "/api/community/channels/parent/messages",+ ] : ["/api/community/channels/dm/messages"])+ expect(invalidate).not.toHaveBeenCalled()+ if (layout === "split") {+ store.releaseSecondaryChannel(secondary)+ getCommunityApiFetchMock().mockClear()+ await capturedUseUserWsOptions!.onForeground!()+ expect(getCommunityApiFetchMock().mock.calls.map(([path]) => path)).toEqual([+ "/api/community/channels/primary/messages",+ ])+ }+ })++ it("shares a held foreground window with reconnect and a later gap frame without duplicate cancellation", async () => {+ useCommunityStore.getState().subscribe({ channelId: "focused" })+ const key = seed("focused")+ await mountHook()+ flushEffects()+ let release!: (value: unknown) => void+ getCommunityApiFetchMock().mockImplementation(async (path) => {+ if (path === "/api/community/channels/focused/messages") return new Promise((resolve) => { release = resolve })+ if (String(path).includes("/messages?since=")) return {+ messages: [message("missed", 2), message("live", 3)], latestSeq: 3, hasMoreNewer: false,+ }+ if (path === "/api/community/users/me/read-state") return { revision: 0, readStates: [] }+ throw new Error(`unexpected fetch: ${String(path)}`)+ })+ const cancel = vi.spyOn(capturedQueryClient, "cancelQueries")+ const foreground = capturedUseUserWsOptions!.onForeground!()+ await vi.waitFor(() => expect(release).toBeTypeOf("function"))+ const duplicate = capturedUseUserWsOptions!.onForeground!()+ const reconnect = capturedOnReconnect!({ reconnectDurationMs: 1_000 })+ const event = messageCreate("focused", "live")+ event.message.seq = 3+ capturedOnMessage!(event)+ await Promise.resolve()+ expect(getCommunityApiFetchMock().mock.calls.filter(([path]) => path === "/api/community/channels/focused/messages")).toHaveLength(1)+ expect(cancel.mock.calls.filter(([filters]) => JSON.stringify(filters.queryKey) === JSON.stringify(key))).toHaveLength(1)+ release(page("snapshot-before-gap"))+ await Promise.all([foreground, duplicate, reconnect])+ expect(getCommunityApiFetchMock().mock.calls.filter(([path]) => String(path).includes("/channels/focused/messages"))).toHaveLength(2)+ expect(cancel.mock.calls.filter(([filters]) => JSON.stringify(filters.queryKey) === JSON.stringify(key))).toHaveLength(1)+ })++ it("reconciles a new target independently and never applies the previous target response to it", async () => {+ useCommunityStore.getState().subscribe({ channelId: "a" })+ seed("a")+ const currentKey = seed("b")+ await mountHook()+ flushEffects()+ let releaseOld!: (value: unknown) => void+ getCommunityApiFetchMock().mockImplementation(async (path) => {+ if (path === "/api/community/channels/a/messages") return new Promise((resolve) => { releaseOld = resolve })+ if (path === "/api/community/channels/b/messages") return page("current-b")+ throw new Error(`unexpected fetch: ${String(path)}`)+ })+ const old = capturedUseUserWsOptions!.onForeground!()+ await vi.waitFor(() => expect(releaseOld).toBeTypeOf("function"))+ useCommunityStore.getState().subscribe({ channelId: "b" })+ await capturedUseUserWsOptions!.onForeground!()+ releaseOld(page("late-a"))+ await old+ expect(capturedQueryClient.getQueryData<{ pages: Array<{ messages: Array<{ id: string }> }> }>(currentKey)?.pages.flatMap((entry) => entry.messages.map((row) => row.id))).toEqual(["current-b", "old-b"])+ })++ it("does not let an old account callback start work after the same hook renders another account", async () => {+ useCommunityWsStore.getState().activateProfileAccount("a")+ useCommunityStore.getState().subscribe({ channelId: "account-target" })+ seed("account-target")+ await mountHook({ viewerUserId: "a" })+ flushEffects()+ const old = capturedUseUserWsOptions!.onForeground!+ useCommunityWsStore.getState().activateProfileAccount("b")+ await old()+ expect(getCommunityApiFetchMock()).not.toHaveBeenCalled()+ resetHookMemoization()+ await mountHook({ viewerUserId: "b" })+ await old()+ expect(getCommunityApiFetchMock()).not.toHaveBeenCalled()+ getCommunityApiFetchMock().mockResolvedValue(page("current-account"))+ await capturedUseUserWsOptions!.onForeground!()+ expect(getCommunityApiFetchMock()).toHaveBeenCalledOnce()+ })++ it("does not let a disposed owner start work from an old foreground callback", async () => {+ useCommunityStore.getState().subscribe({ channelId: "disposed" })+ seed("disposed")+ await mountHook()+ flushEffects()+ const old = capturedUseUserWsOptions!.onForeground!+ unmountHook()+ await old()+ expect(getCommunityApiFetchMock()).not.toHaveBeenCalled()+ })+})diff --git a/src/web/src/hooks/community/use-community-ws.ts b/src/web/src/hooks/community/use-community-ws.tsindex 30a057ab4..0fa29104f 100644--- a/src/web/src/hooks/community/use-community-ws.ts+++ b/src/web/src/hooks/community/use-community-ws.ts@@ -12,7 +12,10 @@ import {SEEN_DELIVERY_OPERATION_TRIM_TO,useCommunityWsStore,} from "@/stores/community/ws"-import { reconcileCommunityWsReconnect } from "@/hooks/community/community-ws/reconnect"+import {+ reconcileCommunityWsReconnect,+ reconcileFocusedCommunityMessages,+} from "@/hooks/community/community-ws/reconnect"import {dispatchCommunityWsEvent,dispatchCommunityWsEvents,@@ -528,10 +531,17 @@ export function useCommunityWs(options?: UseCommunityWsOptions): void {}await reconcileAccountReadState(queryClient, { surfaceMode: "non-inbox" })}, [queryClient])+ const handleForeground = useCallback(() => {+ if (inboxRefreshOwner.current?.disposed+ || viewerUserIdRef.current !== viewerUserId+ || (viewerUserId !== null && useCommunityWsStore.getState().profileViewerId !== viewerUserId)) return+ return reconcileFocusedCommunityMessages(queryClient)+ }, [queryClient, viewerUserId])const { send, reconnectNow } = useUserWs(handleMessage, {onReconnect: handleReconnect,onDisconnect: useCommunityWsStore.getState().markAccessDisconnected,onAuthenticated: handleAuthenticated,+ onForeground: handleForeground,onConnectionStateChange: handleConnectionStateChange,requestDaemonStatusOnAuth: false,})diff --git a/src/web/src/lib/use-user-ws.test.ts b/src/web/src/lib/use-user-ws.test.tsindex 1556b14b6..66d9cd8f6 100644--- a/src/web/src/lib/use-user-ws.test.ts+++ b/src/web/src/lib/use-user-ws.test.ts@@ -1650,6 +1650,81 @@ describe("useUserWs", () => {expect(ws.closed).toBe(false)})+ it("notifies foreground data work before validation and again for changed targets during a pending probe", async () => {+ setupTokenFetch()+ let finish!: () => void+ const dataWork = new Promise<void>((resolve) => { finish = resolve })+ const onForeground = vi.fn(() => dataWork)+ const onReconnect = vi.fn()+ await mountHook(vi.fn(), { onForeground, onReconnect, requestDaemonStatusOnAuth: false })+ const ws = MockWebSocket.instances[0]!+ ws.simulateOpen()+ ws.simulateMessage({ type: "auth.ok" })++ dispatchHiddenToVisible()+ expect(onForeground).toHaveBeenCalledOnce()+ expect(connectionPings(ws)).toHaveLength(1)+ expect(onReconnect).not.toHaveBeenCalled()+ dispatchWindowFocus()+ mockDocument.dispatch("resume")+ dispatchPageShow(true)+ expect(onForeground).toHaveBeenCalledTimes(4)+ expect(connectionPings(ws)).toHaveLength(1)++ const [{ nonce }] = connectionPings(ws)+ ws.simulateMessage({ type: "connection.pong", nonce })+ expect(ws.closed).toBe(false)+ expect(MockWebSocket.instances).toEqual([ws])+ expect(onReconnect).not.toHaveBeenCalled()+ finish()+ await flushPromises()+ })++ it("notifies foreground data work while token or authentication is still pending", async () => {+ const token = deferred<Response>()+ mockFetch.mockReturnValueOnce(token.promise)+ const onForeground = vi.fn()+ await mountHook(vi.fn(), { onForeground, requestDaemonStatusOnAuth: false })+ dispatchWindowFocus()+ expect(onForeground).toHaveBeenCalledOnce()+ expect(MockWebSocket.instances).toHaveLength(0)+ token.resolve({ ok: true, json: async () => ({ userId: "user-1", token: "test-token" }) } as Response)+ await flushPromises()+ const ws = MockWebSocket.instances[0]!+ dispatchWindowFocus()+ expect(onForeground).toHaveBeenCalledTimes(2)+ expect(ws.readyState).toBe(MockWebSocket.CONNECTING)+ ws.simulateOpen()+ dispatchWindowFocus()+ expect(onForeground).toHaveBeenCalledTimes(3)+ expect(connectionPings(ws)).toHaveLength(0)+ })++ it("keeps foreground data failures independent of socket validation and blocks hidden/offline work", async () => {+ setupTokenFetch()+ const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined)+ const onForeground = vi.fn(() => { throw new Error("data unavailable") })+ await mountHook(vi.fn(), { onForeground, requestDaemonStatusOnAuth: false })+ const ws = MockWebSocket.instances[0]!+ ws.simulateOpen()+ ws.simulateMessage({ type: "auth.ok" })+ mockDocument.visibilityState = "hidden"+ mockDocument.dispatch("visibilitychange")+ dispatchWindowFocus()+ expect(onForeground).not.toHaveBeenCalled()+ mockNavigator.onLine = false+ mockWindow.dispatch("offline")+ mockDocument.visibilityState = "visible"+ mockDocument.dispatch("visibilitychange")+ expect(onForeground).not.toHaveBeenCalled()+ mockNavigator.onLine = true+ mockWindow.dispatch("online")+ expect(onForeground).toHaveBeenCalledOnce()+ expect(connectionPings(ws)).toHaveLength(1)+ expect(warn).toHaveBeenCalledWith("[ws] lifecycle callback threw", { callback: "foreground" })+ warn.mockRestore()+ })+it("coalesces an offline-online signal pair while foreground validation is pending", async () => {setupTokenFetch()await mountHook(vi.fn(), { requestDaemonStatusOnAuth: false })diff --git a/src/web/src/lib/use-user-ws.ts b/src/web/src/lib/use-user-ws.tsindex c2e9c99c9..99740d70d 100644--- a/src/web/src/lib/use-user-ws.ts+++ b/src/web/src/lib/use-user-ws.ts@@ -127,12 +127,13 @@ export type UseUserWsOptions = {onReconnect?: (info: { reconnectDurationMs: number }) => void | Promise<void>onDisconnect?: () => void | Promise<void>onAuthenticated?: () => void | Promise<void>+ onForeground?: () => void | Promise<void>onConnectionStateChange?: (phase: UserWsConnectionPhase) => void | Promise<void>requestDaemonStatusOnAuth?: boolean}function runLifecycleCallback(- name: "authenticated" | "connection-state" | "disconnect" | "reconnect",+ name: "authenticated" | "connection-state" | "disconnect" | "foreground" | "reconnect",callback: (() => void | Promise<void>) | undefined,) {if (!callback) return@@ -175,6 +176,7 @@ export function useUserWs(const onReconnectRef = useRef(options?.onReconnect)const onDisconnectRef = useRef(options?.onDisconnect)const onAuthenticatedRef = useRef(options?.onAuthenticated)+ const onForegroundRef = useRef(options?.onForeground)const onConnectionStateChangeRef = useRef(options?.onConnectionStateChange)const lastConnectionPhaseRef = useRef<UserWsConnectionPhase | null>(null)const requestDaemonStatusOnAuthRef = useRef(options?.requestDaemonStatusOnAuth ?? true)@@ -218,9 +220,11 @@ export function useUserWs(useEffect(() => {onDisconnectRef.current = options?.onDisconnectonAuthenticatedRef.current = options?.onAuthenticated+ onForegroundRef.current = options?.onForegroundonConnectionStateChangeRef.current = options?.onConnectionStateChange}, [options?.onAuthenticated,+ options?.onForeground,options?.onConnectionStateChange,options?.onDisconnect,])@@ -921,6 +925,8 @@ export function useUserWs(const recoveryNeeded = forceValidation || connectionValidationNeededRef.currentif (!recoveryNeeded) return+ runLifecycleCallback("foreground", onForegroundRef.current)+ if (isOffline() || isPageHidden()) returnif (pendingTokenRef.current) returnconst ws = wsRef.current