From 5b0713582f33726bed2c6b5aaccf86b6fab7ca6c Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Sat, 26 Sep 2026 08:52:26 -0400 Subject: [PATCH 1/4] FE-2894 fix(account-core): follow-ups from the web session reviews - A sign-out while an interactive sign-in is in flight wins: the late session is discarded, deleted, and never published to sibling tabs. - A live session is adopted even when the remembered-login lookup throws; only the different-user sign-out is skipped. - The billing CSRF replay re-checks the scope after the re-read, so a request superseded meanwhile is abandoned rather than replayed. - Comments record why a sibling tab's answer can be trusted and why the token cache is checked before the backoff. --- .../src/core/billing/credentialedTransport.ts | 1 + .../credentialedTransport.webSession.test.ts | 15 ++++++++ .../account-core/src/core/sessionTokenMint.ts | 2 + .../core/webSessionIdentity.lifecycle.test.ts | 37 +++++++++++++++++++ .../src/core/webSessionIdentity.test.ts | 14 +++++++ .../src/core/webSessionIdentity.ts | 24 +++++++++++- 6 files changed, 91 insertions(+), 2 deletions(-) diff --git a/packages/account-core/src/core/billing/credentialedTransport.ts b/packages/account-core/src/core/billing/credentialedTransport.ts index 8563826fc5a..1584aae1e0a 100644 --- a/packages/account-core/src/core/billing/credentialedTransport.ts +++ b/packages/account-core/src/core/billing/credentialedTransport.ts @@ -156,6 +156,7 @@ async function exchangeWithSession( signal: context.signal }) if (reread.status === 'error') return rereadFailure(reread) + if (!context.stillInScope()) return { status: 'error', code: 'SUPERSEDED' } return sendAs(reread.session) } diff --git a/packages/account-core/src/core/billing/credentialedTransport.webSession.test.ts b/packages/account-core/src/core/billing/credentialedTransport.webSession.test.ts index 04bbb5e976a..d6a54156134 100644 --- a/packages/account-core/src/core/billing/credentialedTransport.webSession.test.ts +++ b/packages/account-core/src/core/billing/credentialedTransport.webSession.test.ts @@ -230,6 +230,21 @@ describe('createCredentialedBillingTransport with a web session', () => { expect(endpoint.requests).toEqual([]) }) + it('does not replay once the host left the scope during the re-read', async () => { + let reread = () => false + const { transport, fetchImpl, endpoint } = makeTransport({ + responses: [refusal('csrf_invalid')], + scope: () => (reread() ? { ...SCOPE, workspaceId: 'ws-2' } : SCOPE) + }) + reread = () => endpoint.requests.length > 0 + + const result = await transport({ method: 'POST', route: '/billing/topup' }) + + expect(result).toEqual({ status: 'error', code: 'SUPERSEDED' }) + expect(endpoint.requests).toHaveLength(1) + expect(fetchImpl).toHaveBeenCalledOnce() + }) + it('reports NOT_AUTHENTICATED without sending when there is no session', async () => { const { transport, fetchImpl } = makeTransport({ session: undefined }) diff --git a/packages/account-core/src/core/sessionTokenMint.ts b/packages/account-core/src/core/sessionTokenMint.ts index cbf083fa306..eb4c2a94663 100644 --- a/packages/account-core/src/core/sessionTokenMint.ts +++ b/packages/account-core/src/core/sessionTokenMint.ts @@ -228,6 +228,8 @@ export function createSessionTokenMint({ if (session === undefined) return failure('NO_SESSION') const userId = session.user.id + // The cache is checked before the backoff on purpose: a caller already + // holding a fresh token is still served while new mints wait. const cached = cache.get(workspaceId) if (cached && isCredentialFresh(cached, now(), refreshBufferMs)) { return { status: 'ok', credential: cached } diff --git a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts index 00c8e04fd09..a5111a52279 100644 --- a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts +++ b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts @@ -279,6 +279,43 @@ describe('tabs of one site', () => { expect(sibling.remoteSignOuts).toEqual([]) }) + it('a sign-out during an interactive sign-in wins, in this tab and its siblings', async () => { + const endpoint = liveEndpoint({ kind: 'dead', code: 'no_session' }) + const site = createFakeSiteBus() + let releasePost = () => {} + const postHeld = new Promise((resolve) => { + releasePost = resolve + }) + const acting = openTab({ + endpoint, + site, + remembered: null, + fetchImpl: async (input, init) => { + if (init?.method === 'POST') await postHeld + return endpoint.fetch(input, init) + } + }) + const sibling = openTab({ endpoint, site, remembered: null }) + await settle() + + const signingIn = acting.identity.signedIn(async () => 'fresh-proof') + await settle() + await acting.identity.signOut() + releasePost() + const answer = await signingIn + await settle() + + expect(answer).toMatchObject({ status: 'error', code: 'SESSION_REVOKED' }) + expect(summarize(acting.identity.getState())).toBe('signed_out:signed_out') + expect(summarize(sibling.identity.getState())).toBe('signed_out:signed_out') + expect(methods(endpoint).slice(-4)).toEqual([ + 'DELETE', + 'POST', + 'GET', + 'DELETE' + ]) + }) + it('a tab that signed out is not signed back in by a sibling heartbeat', async () => { const endpoint = liveEndpoint() const site = createFakeSiteBus() diff --git a/packages/account-core/src/core/webSessionIdentity.test.ts b/packages/account-core/src/core/webSessionIdentity.test.ts index 0c23aa9b612..be1831eb673 100644 --- a/packages/account-core/src/core/webSessionIdentity.test.ts +++ b/packages/account-core/src/core/webSessionIdentity.test.ts @@ -237,6 +237,20 @@ describe('network errors', () => { expect(login.signOutLocally).not.toHaveBeenCalled() }) + it('adopts a live session even when the remembered-login lookup throws', async () => { + const login = fakeRememberedLogin('user-2') + login.currentUserId.mockRejectedValueOnce(new Error('provider offline')) + const { endpoint, scheduler, identity } = bootIdentity({ + state: { kind: 'live', user: SESSION_USER }, + login + }) + + expect(summarize(await nextRest(identity))).toBe('signed_in:user-1') + expect(scheduler.delays()).toEqual([]) + expect(requestLog(endpoint)).toEqual(['GET']) + expect(login.signOutLocally).not.toHaveBeenCalled() + }) + it.for([ { name: 'a pending session read', pending: 'read' }, { name: 'a pending identity proof', pending: 'proof' } diff --git a/packages/account-core/src/core/webSessionIdentity.ts b/packages/account-core/src/core/webSessionIdentity.ts index 8f033e72421..00fdbb15f10 100644 --- a/packages/account-core/src/core/webSessionIdentity.ts +++ b/packages/account-core/src/core/webSessionIdentity.ts @@ -453,6 +453,11 @@ const zSharedResult = z.discriminatedUnion('status', [ }) ]) +/** + * Every tab of a site reads the same host-only cookie, so a sibling's answer + * is this tab's own session observed elsewhere; that is what makes adopting + * it safe. A per-tab session scope would break this assumption. + */ const zSharedMessage = z.object({ from: z.enum(['heartbeat', 'sign_in', 'sign_out']), result: zSharedResult @@ -512,6 +517,7 @@ function createAccountIdentity( const listeners = new Set<(state: WebSessionIdentityState) => void>() let state: WebSessionIdentityState = { phase: 'idle' } let epoch = 0 + let signOuts = 0 let cancelRetry: (() => void) | undefined let cancelBeat: (() => void) | undefined let releaseLeadership: (() => void) | undefined @@ -545,8 +551,16 @@ function createAccountIdentity( () => undefined ) if (started !== epoch) return - if (remembered === undefined) return dispatch({ type: 'login_errored' }) - dispatch({ ...answered, result, rememberedUserId: remembered.value }) + // A failed lookup matters only without a live session to adopt: with one, + // it can skip nothing but the different-user sign-out. + if (remembered === undefined && result.status !== 'ok') { + return dispatch({ type: 'login_errored' }) + } + dispatch({ + ...answered, + result, + rememberedUserId: remembered?.value ?? null + }) } function beat(): void { @@ -702,13 +716,19 @@ function createAccountIdentity( dispatch({ type: 'boot' }) }, signedIn: async (getProof) => { + const signOutsAtStart = signOuts const result = await createWebSession(options.session, getProof) if (result.status !== 'ok') return result + if (signOuts !== signOutsAtStart) { + void deleteWebSession(options.session) + return revoked + } dispatch({ type: 'session_created', session: result.session }) publish('sign_in', result) return result }, signOut: async () => { + signOuts += 1 dispatch({ type: 'sign_out_requested' }) const result = await deleteWebSession(options.session) if (result.status === 'ok') publish('sign_out', revoked) From 239ab1f6fb8ea610f619e8507cbac7cf20146344 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Sat, 26 Sep 2026 09:23:03 -0400 Subject: [PATCH 2/4] fix(account-core): a stale sign-in's cleanup never touches a later session The cleanup DELETE is skipped once a newer sign-in has started, since that sign-in owns the cookie now, and a failed cleanup is returned instead of a clean revocation. --- .../core/webSessionIdentity.lifecycle.test.ts | 62 +++++++++++++++++++ .../src/core/webSessionIdentity.ts | 8 ++- 2 files changed, 68 insertions(+), 2 deletions(-) diff --git a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts index a5111a52279..027dd16cefc 100644 --- a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts +++ b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts @@ -316,6 +316,68 @@ describe('tabs of one site', () => { ]) }) + it('a stale sign-in never deletes the session a later sign-in created', async () => { + const endpoint = liveEndpoint({ kind: 'dead', code: 'no_session' }) + let releaseFirstPost = () => {} + const firstPostHeld = new Promise((resolve) => { + releaseFirstPost = resolve + }) + let posts = 0 + const tab = openTab({ + endpoint, + remembered: null, + fetchImpl: async (input, init) => { + if (init?.method === 'POST' && ++posts === 1) await firstPostHeld + return endpoint.fetch(input, init) + } + }) + await settle() + + const stale = tab.identity.signedIn(async () => 'first-proof') + await settle() + await tab.identity.signOut() + await tab.identity.signedIn(async () => 'second-proof') + const afterSecond = methods(endpoint).length + releaseFirstPost() + await stale + await settle() + + expect(summarize(tab.identity.getState())).toBe('signed_in:user-2') + expect(methods(endpoint).slice(afterSecond)).not.toContain('DELETE') + }) + + it('reports a failed cleanup instead of a clean revocation', async () => { + const endpoint = liveEndpoint({ kind: 'dead', code: 'no_session' }) + let releasePost = () => {} + const postHeld = new Promise((resolve) => { + releasePost = resolve + }) + let deletes = 0 + const tab = openTab({ + endpoint, + remembered: null, + fetchImpl: async (input, init) => { + if (init?.method === 'POST') await postHeld + if (init?.method === 'DELETE' && ++deletes === 2) { + return new Response('{}', { status: 503 }) + } + return endpoint.fetch(input, init) + } + }) + await settle() + + const signingIn = tab.identity.signedIn(async () => 'fresh-proof') + await settle() + await tab.identity.signOut() + releasePost() + + expect(await signingIn).toMatchObject({ + status: 'error', + code: 'SESSION_UNAVAILABLE' + }) + expect(summarize(tab.identity.getState())).toBe('signed_out:signed_out') + }) + it('a tab that signed out is not signed back in by a sibling heartbeat', async () => { const endpoint = liveEndpoint() const site = createFakeSiteBus() diff --git a/packages/account-core/src/core/webSessionIdentity.ts b/packages/account-core/src/core/webSessionIdentity.ts index 00fdbb15f10..f080aebbe1b 100644 --- a/packages/account-core/src/core/webSessionIdentity.ts +++ b/packages/account-core/src/core/webSessionIdentity.ts @@ -518,6 +518,7 @@ function createAccountIdentity( let state: WebSessionIdentityState = { phase: 'idle' } let epoch = 0 let signOuts = 0 + let signIns = 0 let cancelRetry: (() => void) | undefined let cancelBeat: (() => void) | undefined let releaseLeadership: (() => void) | undefined @@ -717,11 +718,14 @@ function createAccountIdentity( }, signedIn: async (getProof) => { const signOutsAtStart = signOuts + const signIn = ++signIns const result = await createWebSession(options.session, getProof) if (result.status !== 'ok') return result if (signOuts !== signOutsAtStart) { - void deleteWebSession(options.session) - return revoked + // A later sign-in owns the cookie now; deleting would end its session. + if (signIn !== signIns) return revoked + const cleanup = await deleteWebSession(options.session) + return cleanup.status === 'ok' ? revoked : cleanup } dispatch({ type: 'session_created', session: result.session }) publish('sign_in', result) From 528f52b4005a8461df43da775c78cd40a2bea1b9 Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Sun, 27 Sep 2026 21:18:32 -0400 Subject: [PATCH 3/4] fix(account-core): a stale sign-in skips cleanup only when a newer sign-in holds the session --- .../core/webSessionIdentity.lifecycle.test.ts | 36 +++++++++++++++++++ .../src/core/webSessionIdentity.ts | 5 ++- 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts index 027dd16cefc..14f5dc8677d 100644 --- a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts +++ b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts @@ -346,6 +346,42 @@ describe('tabs of one site', () => { expect(methods(endpoint).slice(afterSecond)).not.toContain('DELETE') }) + it('a stale sign-in still deletes its session when the later sign-in failed', async () => { + const endpoint = liveEndpoint({ kind: 'dead', code: 'no_session' }) + let releaseFirstPost = () => {} + const firstPostHeld = new Promise((resolve) => { + releaseFirstPost = resolve + }) + let posts = 0 + const tab = openTab({ + endpoint, + remembered: null, + fetchImpl: async (input, init) => { + const post = init?.method === 'POST' ? ++posts : 0 + if (post === 1) await firstPostHeld + if (post === 2) return new Response('{}', { status: 503 }) + return endpoint.fetch(input, init) + } + }) + await settle() + + const stale = tab.identity.signedIn(async () => 'first-proof') + await settle() + await tab.identity.signOut() + expect( + await tab.identity.signedIn(async () => 'second-proof') + ).toMatchObject({ status: 'error' }) + releaseFirstPost() + + expect(await stale).toMatchObject({ + status: 'error', + code: 'SESSION_REVOKED' + }) + await settle() + expect(summarize(tab.identity.getState())).toBe('signed_out:signed_out') + expect(endpoint.state.kind).toBe('dead') + }) + it('reports a failed cleanup instead of a clean revocation', async () => { const endpoint = liveEndpoint({ kind: 'dead', code: 'no_session' }) let releasePost = () => {} diff --git a/packages/account-core/src/core/webSessionIdentity.ts b/packages/account-core/src/core/webSessionIdentity.ts index f080aebbe1b..3187299f360 100644 --- a/packages/account-core/src/core/webSessionIdentity.ts +++ b/packages/account-core/src/core/webSessionIdentity.ts @@ -519,6 +519,7 @@ function createAccountIdentity( let epoch = 0 let signOuts = 0 let signIns = 0 + let liveSignIn = 0 let cancelRetry: (() => void) | undefined let cancelBeat: (() => void) | undefined let releaseLeadership: (() => void) | undefined @@ -723,16 +724,18 @@ function createAccountIdentity( if (result.status !== 'ok') return result if (signOuts !== signOutsAtStart) { // A later sign-in owns the cookie now; deleting would end its session. - if (signIn !== signIns) return revoked + if (liveSignIn > signIn) return revoked const cleanup = await deleteWebSession(options.session) return cleanup.status === 'ok' ? revoked : cleanup } + liveSignIn = signIn dispatch({ type: 'session_created', session: result.session }) publish('sign_in', result) return result }, signOut: async () => { signOuts += 1 + liveSignIn = 0 dispatch({ type: 'sign_out_requested' }) const result = await deleteWebSession(options.session) if (result.status === 'ok') publish('sign_out', revoked) From 57e0b180f0e082f45a1877c826acc67a7abbbd1c Mon Sep 17 00:00:00 2001 From: dante01yoon Date: Sun, 27 Sep 2026 23:08:39 -0400 Subject: [PATCH 4/4] fix(account-core): a sibling tab's sign-out invalidates pending sign-ins --- .../core/webSessionIdentity.lifecycle.test.ts | 32 +++++++++++++++++++ .../src/core/webSessionIdentity.ts | 9 ++++-- 2 files changed, 39 insertions(+), 2 deletions(-) diff --git a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts index 14f5dc8677d..185759132b8 100644 --- a/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts +++ b/packages/account-core/src/core/webSessionIdentity.lifecycle.test.ts @@ -316,6 +316,38 @@ describe('tabs of one site', () => { ]) }) + it('a sibling tab signing out invalidates a pending sign-in in this tab', async () => { + const endpoint = liveEndpoint({ kind: 'dead', code: 'no_session' }) + const site = createFakeSiteBus() + let releasePost = () => {} + const postHeld = new Promise((resolve) => { + releasePost = resolve + }) + const acting = openTab({ + endpoint, + site, + remembered: null, + fetchImpl: async (input, init) => { + if (init?.method === 'POST') await postHeld + return endpoint.fetch(input, init) + } + }) + const sibling = openTab({ endpoint, site, remembered: null }) + await settle() + + const signingIn = acting.identity.signedIn(async () => 'fresh-proof') + await settle() + await sibling.identity.signOut() + releasePost() + const answer = await signingIn + await settle() + + expect(answer).toMatchObject({ status: 'error', code: 'SESSION_REVOKED' }) + expect(summarize(acting.identity.getState())).toBe('signed_out:signed_out') + expect(summarize(sibling.identity.getState())).toBe('signed_out:signed_out') + expect(endpoint.state.kind).toBe('dead') + }) + it('a stale sign-in never deletes the session a later sign-in created', async () => { const endpoint = liveEndpoint({ kind: 'dead', code: 'no_session' }) let releaseFirstPost = () => {} diff --git a/packages/account-core/src/core/webSessionIdentity.ts b/packages/account-core/src/core/webSessionIdentity.ts index 3187299f360..247797b9446 100644 --- a/packages/account-core/src/core/webSessionIdentity.ts +++ b/packages/account-core/src/core/webSessionIdentity.ts @@ -576,10 +576,16 @@ function createAccountIdentity( }) } + function invalidatePendingSignIns(): void { + signOuts += 1 + liveSignIn = 0 + } + function adopt(message: unknown): void { const parsed = zSharedMessage.safeParse(message) if (!parsed.success) return const { from, result } = parsed.data + if (from === 'sign_out') invalidatePendingSignIns() const observed = { type: 'session_observed', from: `sibling_${from}` @@ -734,8 +740,7 @@ function createAccountIdentity( return result }, signOut: async () => { - signOuts += 1 - liveSignIn = 0 + invalidatePendingSignIns() dispatch({ type: 'sign_out_requested' }) const result = await deleteWebSession(options.session) if (result.status === 'ok') publish('sign_out', revoked)