LCOV - code coverage report
Current view: top level - packages/account-core/src/core - webSessionIdentity.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 3.4 % 267 9
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : /**
       2              :  * The session-backed identity source: boots a site from `GET /auth/session`
       3              :  * and follows the server's answer. It keeps no record of past sessions, and
       4              :  * the remembered provider login is an opaque port, so no provider leaks in.
       5              :  */
       6              : import { z } from 'zod'
       7              : 
       8              : import type {
       9              :   CrossTabRefreshPort,
      10              :   WebSession,
      11              :   WebSessionCommandResult,
      12              :   WebSessionFailure,
      13              :   WebSessionResult
      14              : } from './sessionContracts'
      15              : import type { WebSessionOptions } from './webSession'
      16              : import {
      17              :   createWebSession,
      18              :   deleteWebSession,
      19              :   readWebSession
      20              : } from './webSession'
      21              : 
      22              : export interface RememberedLogin {
      23              :   /** The Comfy user id of the login this browser remembers, or null. */
      24              :   currentUserId: () => Promise<string | null>
      25              :   /** Null when the provider has no usable login; a throw is transient. */
      26              :   getProof: () => Promise<string | null>
      27              :   signOutLocally: () => Promise<void>
      28              : }
      29              : 
      30              : export type WebSessionPrincipal =
      31              :   | { readonly kind: 'account'; readonly rememberedLogin: RememberedLogin }
      32              :   | { readonly kind: 'api_key' }
      33              : 
      34              : export type WebSessionBootOutcome =
      35              :   | 'signed_in'
      36              :   | 'restored'
      37              :   | 'signed_out'
      38              :   | 'revoked'
      39              :   | 'restore_failed'
      40              : 
      41              : export interface WebSessionBootstrapEvent {
      42              :   readonly outcome: WebSessionBootOutcome
      43              :   readonly origin: string
      44              : }
      45              : 
      46              : type SignedOutOutcome = Exclude<WebSessionBootOutcome, 'signed_in' | 'restored'>
      47              : 
      48              : /** The account this tab holds changed under it, or went away. */
      49              : export type WebSessionAccountChange =
      50              :   | { readonly reason: 'user_changed'; readonly session: WebSession }
      51              :   | { readonly reason: 'signed_out'; readonly outcome: SignedOutOutcome }
      52              : 
      53              : export type WebSessionIdentityState =
      54              :   | { readonly phase: 'idle' }
      55              :   | { readonly phase: 'api_key' }
      56              :   | {
      57              :       readonly phase: 'reading' | 'retry_wait' | 'restoring'
      58              :       readonly failures: number
      59              :     }
      60              :   | { readonly phase: 'signed_in'; readonly session: WebSession }
      61              :   | { readonly phase: 'signed_out'; readonly outcome: SignedOutOutcome }
      62              : 
      63              : /** Only a sibling's sign-in is news to a tab that has signed out. */
      64              : export type SessionObservedFrom =
      65              :   | 'this_tab'
      66              :   | 'sibling_heartbeat'
      67              :   | 'sibling_sign_in'
      68              :   | 'sibling_sign_out'
      69              : 
      70              : export type WebSessionIdentityEvent =
      71              :   | { readonly type: 'boot' }
      72              :   | {
      73              :       readonly type: 'read_answered' | 'restore_answered'
      74              :       readonly result: WebSessionResult
      75              :       readonly rememberedUserId: string | null
      76              :     }
      77              :   | { readonly type: 'proof_missing' | 'proof_errored' | 'login_errored' }
      78              :   | { readonly type: 'retry_due' }
      79              :   /** A heartbeat answer, this tab's or one a sibling tab published. */
      80              :   | {
      81              :       readonly type: 'session_observed'
      82              :       readonly from: SessionObservedFrom
      83              :       readonly result: WebSessionResult
      84              :       readonly rememberedUserId: string | null
      85              :     }
      86              :   | { readonly type: 'session_created'; readonly session: WebSession }
      87              :   | { readonly type: 'sign_out_requested' }
      88              : 
      89              : export type WebSessionIdentityEffect =
      90              :   | { readonly type: 'read' }
      91              :   | { readonly type: 'restore'; readonly expectedUserId: string }
      92              :   | { readonly type: 'schedule_retry'; readonly failures: number }
      93              :   | { readonly type: 'sign_out_locally' }
      94              :   | { readonly type: 'report'; readonly outcome: WebSessionBootOutcome }
      95              :   | {
      96              :       readonly type: 'account_changed'
      97              :       readonly change: WebSessionAccountChange
      98              :     }
      99              :   | { readonly type: 'report_signed_out_remotely' }
     100              : 
     101              : export interface WebSessionIdentityTransition {
     102              :   readonly state: WebSessionIdentityState
     103              :   readonly effects: readonly WebSessionIdentityEffect[]
     104              : }
     105              : 
     106         2356 : const read: WebSessionIdentityEffect = { type: 'read' }
     107         2356 : const signOutLocally: WebSessionIdentityEffect = { type: 'sign_out_locally' }
     108              : 
     109            0 : function signOutDifferentLogin(
     110              :   session: WebSession,
     111              :   rememberedUserId: string | null
     112              : ): WebSessionIdentityEffect[] {
     113            0 :   return rememberedUserId !== null && rememberedUserId !== session.user.id
     114              :     ? [signOutLocally]
     115              :     : []
     116              : }
     117              : 
     118            0 : function settleSignedIn(
     119              :   session: WebSession,
     120              :   rememberedUserId: string | null,
     121              :   outcome: 'signed_in' | 'restored'
     122              : ): WebSessionIdentityTransition {
     123            0 :   return {
     124              :     state: { phase: 'signed_in', session },
     125              :     effects: [
     126              :       ...signOutDifferentLogin(session, rememberedUserId),
     127              :       { type: 'report', outcome }
     128              :     ]
     129              :   }
     130              : }
     131              : 
     132            0 : function settleSignedOut(
     133              :   outcome: SignedOutOutcome
     134              : ): WebSessionIdentityTransition {
     135            0 :   return {
     136              :     state: { phase: 'signed_out', outcome },
     137              :     effects: [
     138              :       ...(outcome === 'revoked' ? [signOutLocally] : []),
     139              :       { type: 'report', outcome }
     140              :     ]
     141              :   }
     142              : }
     143              : 
     144            0 : function waitToRetry(failures: number): WebSessionIdentityTransition {
     145            0 :   return {
     146              :     state: { phase: 'retry_wait', failures },
     147              :     effects: [{ type: 'schedule_retry', failures }]
     148              :   }
     149              : }
     150              : 
     151            0 : function isNoLiveSession(failure: WebSessionFailure): boolean {
     152            0 :   return failure.code === 'NO_SESSION' || failure.code === 'SESSION_EXPIRED'
     153              : }
     154              : 
     155            0 : function applyReadAnswered(
     156              :   failures: number,
     157              :   result: WebSessionResult,
     158              :   rememberedUserId: string | null
     159              : ): WebSessionIdentityTransition {
     160            0 :   if (result.status === 'ok') {
     161            0 :     return settleSignedIn(result.session, rememberedUserId, 'signed_in')
     162              :   }
     163            0 :   if (result.retryable) return waitToRetry(failures + 1)
     164            0 :   if (result.code === 'SESSION_REVOKED') return settleSignedOut('revoked')
     165            0 :   if (!isNoLiveSession(result)) return settleSignedOut('signed_out')
     166            0 :   if (rememberedUserId === null) return settleSignedOut('signed_out')
     167            0 :   return {
     168              :     state: { phase: 'restoring', failures },
     169              :     effects: [{ type: 'restore', expectedUserId: rememberedUserId }]
     170              :   }
     171              : }
     172              : 
     173            0 : function applyRestoreAnswered(
     174              :   failures: number,
     175              :   result: WebSessionResult,
     176              :   rememberedUserId: string | null
     177              : ): WebSessionIdentityTransition {
     178            0 :   if (result.status === 'ok') {
     179            0 :     return settleSignedIn(result.session, rememberedUserId, 'restored')
     180              :   }
     181            0 :   if (result.retryable) return waitToRetry(failures + 1)
     182            0 :   if (result.code === 'SESSION_REVOKED') return settleSignedOut('revoked')
     183            0 :   return settleSignedOut('restore_failed')
     184              : }
     185              : 
     186            0 : function leaveAccount(
     187              :   outcome: SignedOutOutcome,
     188              :   effects: readonly WebSessionIdentityEffect[] = []
     189              : ): WebSessionIdentityTransition {
     190            0 :   return {
     191              :     state: { phase: 'signed_out', outcome },
     192              :     effects: [
     193              :       ...effects,
     194              :       { type: 'account_changed', change: { reason: 'signed_out', outcome } }
     195              :     ]
     196              :   }
     197              : }
     198              : 
     199            0 : function replaceSession(
     200              :   held: WebSession,
     201              :   session: WebSession,
     202              :   effects: readonly WebSessionIdentityEffect[] = []
     203              : ): WebSessionIdentityTransition {
     204            0 :   const state: WebSessionIdentityState = { phase: 'signed_in', session }
     205            0 :   if (session.user.id === held.user.id) return { state, effects: [] }
     206            0 :   return {
     207              :     state,
     208              :     effects: [
     209              :       ...effects,
     210              :       { type: 'account_changed', change: { reason: 'user_changed', session } }
     211              :     ]
     212              :   }
     213              : }
     214              : 
     215              : /** A read never signs out on doubt: only revoked or no live session does. */
     216            0 : function observeWhileSignedIn(
     217              :   state: Extract<WebSessionIdentityState, { phase: 'signed_in' }>,
     218              :   result: WebSessionResult,
     219              :   rememberedUserId: string | null,
     220              :   restored: boolean,
     221              :   ownRead: boolean
     222              : ): WebSessionIdentityTransition {
     223            0 :   if (result.status === 'ok') {
     224            0 :     return replaceSession(
     225              :       state.session,
     226              :       result.session,
     227              :       signOutDifferentLogin(result.session, rememberedUserId)
     228              :     )
     229              :   }
     230            0 :   if (result.retryable) return { state, effects: [] }
     231            0 :   if (result.code === 'SESSION_REVOKED') {
     232            0 :     return leaveAccount(
     233              :       'revoked',
     234              :       ownRead
     235              :         ? [signOutLocally, { type: 'report_signed_out_remotely' }]
     236              :         : [signOutLocally]
     237              :     )
     238              :   }
     239            0 :   if (restored) return leaveAccount('restore_failed')
     240            0 :   if (!isNoLiveSession(result)) return { state, effects: [] }
     241            0 :   if (rememberedUserId === null) return leaveAccount('signed_out')
     242            0 :   return {
     243              :     state,
     244              :     effects: [{ type: 'restore', expectedUserId: rememberedUserId }]
     245              :   }
     246              : }
     247              : 
     248            0 : function transitionSignedIn(
     249              :   state: Extract<WebSessionIdentityState, { phase: 'signed_in' }>,
     250              :   event: WebSessionIdentityEvent
     251              : ): WebSessionIdentityTransition {
     252            0 :   switch (event.type) {
     253              :     case 'session_observed':
     254            0 :       return observeWhileSignedIn(
     255              :         state,
     256              :         event.result,
     257              :         event.rememberedUserId,
     258              :         false,
     259              :         event.from === 'this_tab'
     260              :       )
     261              :     case 'restore_answered':
     262            0 :       return observeWhileSignedIn(
     263              :         state,
     264              :         event.result,
     265              :         event.rememberedUserId,
     266              :         true,
     267              :         true
     268              :       )
     269              :     case 'session_created':
     270            0 :       return replaceSession(state.session, event.session)
     271              :     case 'proof_missing':
     272            0 :       return leaveAccount('restore_failed')
     273              :     case 'sign_out_requested':
     274            0 :       return leaveAccount('signed_out', [signOutLocally])
     275              :     default:
     276            0 :       return { state, effects: [] }
     277              :   }
     278              : }
     279              : 
     280              : type SettlingState = Exclude<
     281              :   WebSessionIdentityState,
     282              :   { readonly phase: 'idle' | 'api_key' | 'signed_in' }
     283              : >
     284              : 
     285            0 : function transitionRestoring(
     286              :   state: Extract<SettlingState, { readonly failures: number }>,
     287              :   event: WebSessionIdentityEvent
     288              : ): WebSessionIdentityTransition {
     289            0 :   switch (event.type) {
     290              :     case 'restore_answered':
     291            0 :       return applyRestoreAnswered(
     292              :         state.failures,
     293              :         event.result,
     294              :         event.rememberedUserId
     295              :       )
     296              :     case 'proof_missing':
     297            0 :       return settleSignedOut('restore_failed')
     298              :     case 'proof_errored':
     299              :     case 'login_errored':
     300            0 :       return waitToRetry(state.failures + 1)
     301              :     default:
     302            0 :       return { state, effects: [] }
     303              :   }
     304              : }
     305              : 
     306            0 : function transitionBoot(
     307              :   state: SettlingState,
     308              :   event: WebSessionIdentityEvent
     309              : ): WebSessionIdentityTransition {
     310            0 :   switch (state.phase) {
     311              :     case 'reading':
     312            0 :       if (event.type === 'login_errored') return waitToRetry(state.failures + 1)
     313            0 :       return event.type === 'read_answered'
     314              :         ? applyReadAnswered(
     315              :             state.failures,
     316              :             event.result,
     317              :             event.rememberedUserId
     318              :           )
     319              :         : { state, effects: [] }
     320              :     case 'retry_wait':
     321            0 :       return event.type === 'retry_due'
     322              :         ? { state: { ...state, phase: 'reading' }, effects: [read] }
     323              :         : { state, effects: [] }
     324              :     case 'restoring':
     325            0 :       return transitionRestoring(state, event)
     326              :     default:
     327            0 :       return { state, effects: [] }
     328              :   }
     329              : }
     330              : 
     331            0 : function transitionSettling(
     332              :   state: SettlingState,
     333              :   event: WebSessionIdentityEvent
     334              : ): WebSessionIdentityTransition {
     335            0 :   switch (event.type) {
     336              :     case 'session_observed': {
     337            0 :       const { result } = event
     338            0 :       const adoptable =
     339              :         state.phase === 'retry_wait' ||
     340              :         (state.phase === 'signed_out' && event.from === 'sibling_sign_in')
     341            0 :       if (result.status !== 'ok' || !adoptable) return { state, effects: [] }
     342            0 :       return {
     343              :         state: { phase: 'signed_in', session: result.session },
     344              :         effects: signOutDifferentLogin(result.session, event.rememberedUserId)
     345              :       }
     346              :     }
     347              :     case 'session_created':
     348            0 :       return {
     349              :         state: { phase: 'signed_in', session: event.session },
     350              :         effects: []
     351              :       }
     352              :     case 'sign_out_requested':
     353            0 :       return state.phase === 'signed_out'
     354              :         ? { state, effects: [] }
     355              :         : {
     356              :             state: { phase: 'signed_out', outcome: 'signed_out' },
     357              :             effects: [signOutLocally]
     358              :           }
     359              :     default:
     360            0 :       return transitionBoot(state, event)
     361              :   }
     362              : }
     363              : 
     364              : /** Pure: an event that means nothing in the current phase changes nothing. */
     365            0 : export function transitionWebSessionIdentity(
     366              :   state: WebSessionIdentityState,
     367              :   event: WebSessionIdentityEvent
     368              : ): WebSessionIdentityTransition {
     369            0 :   switch (state.phase) {
     370              :     case 'idle':
     371            0 :       return event.type === 'boot'
     372              :         ? { state: { phase: 'reading', failures: 0 }, effects: [read] }
     373              :         : { state, effects: [] }
     374              :     case 'api_key':
     375            0 :       return { state, effects: [] }
     376              :     case 'signed_in':
     377            0 :       return transitionSignedIn(state, event)
     378              :     default:
     379            0 :       return transitionSettling(state, event)
     380              :   }
     381              : }
     382              : 
     383              : export type ScheduleRetry = (run: () => void, delayMs: number) => () => void
     384              : 
     385              : export interface VisibilityPort {
     386              :   isVisible: () => boolean
     387              :   onChange: (listener: (visible: boolean) => void) => () => void
     388              : }
     389              : 
     390              : export interface WebSessionHeartbeatOptions {
     391              :   readonly visibility: VisibilityPort
     392              :   /** Without it every tab reads for itself. */
     393              :   readonly crossTab?: CrossTabRefreshPort<WebSessionSharedMessage>
     394              :   readonly intervalMs?: number
     395              : }
     396              : 
     397              : export interface WebSessionIdentityOptions {
     398              :   readonly session: WebSessionOptions
     399              :   readonly principal: WebSessionPrincipal
     400              :   /** The site reporting the boot, e.g. `https://www.comfy.org`. */
     401              :   readonly origin: string
     402              :   readonly onBootstrap?: (event: WebSessionBootstrapEvent) => void
     403              :   /** Telemetry for `session_signed_out_remotely`. */
     404              :   readonly onSignedOutRemotely?: (event: { readonly origin: string }) => void
     405              :   /** The host drops pending actions and user-scoped state here. */
     406              :   readonly onAccountChanged?: (
     407              :     change: WebSessionAccountChange & { readonly epoch: number }
     408              :   ) => void
     409              :   readonly heartbeat?: WebSessionHeartbeatOptions
     410              :   readonly schedule?: ScheduleRetry
     411              :   readonly retryBaseMs?: number
     412              :   readonly retryMaxMs?: number
     413              : }
     414              : 
     415              : export interface WebSessionIdentity {
     416              :   getState: () => WebSessionIdentityState
     417              :   /** Delivers the current state at once, then every change. */
     418              :   subscribe: (listener: (state: WebSessionIdentityState) => void) => () => void
     419              :   /** Starts the boot and the heartbeat; a no-op unless idle. */
     420              :   boot: () => void
     421              :   /** Only after an interactive sign-in; a token refresh must never call it. */
     422              :   signedIn: (getProof: () => Promise<string>) => Promise<WebSessionResult>
     423              :   signOut: () => Promise<WebSessionCommandResult>
     424              :   /**
     425              :    * Reads the session now, as a heartbeat would, and resolves once the answer
     426              :    * and any restore it starts have settled. Reads nothing unless signed in as
     427              :    * `expectedUserId` (any user when omitted).
     428              :    */
     429              :   refresh: (expectedUserId?: string) => Promise<WebSessionIdentityState>
     430              :   /** Changes with the account; an answer started under an older epoch is stale. */
     431              :   getEpoch: () => number
     432              :   /** Cancels timers, ignores answers in flight, and returns to idle. */
     433              :   dispose: () => void
     434              : }
     435              : 
     436         2356 : const HEARTBEAT_KEY = '@comfyorg/account-core web-session heartbeat'
     437         2356 : const HEARTBEAT_INTERVAL_MS = 10 * 60 * 1000
     438         2356 : const PROOF_TIMEOUT_MS = 15_000
     439              : 
     440         2356 : const zSharedResult = z.discriminatedUnion('status', [
     441              :   z.object({
     442              :     status: z.literal('ok'),
     443              :     session: z.object({
     444              :       user: z.object({
     445              :         id: z.string(),
     446              :         email: z.string(),
     447              :         name: z.string().optional(),
     448              :         emailVerified: z.boolean(),
     449              :         signInProvider: z.string().optional(),
     450              :         hasPersonalWorkspace: z.boolean().optional()
     451              :       }),
     452              :       csrfToken: z.string(),
     453              :       expiresAt: z.number(),
     454              :       absoluteExpiresAt: z.number()
     455              :     })
     456              :   }),
     457              :   z.object({
     458              :     status: z.literal('error'),
     459              :     code: z.literal('SESSION_REVOKED'),
     460              :     retryable: z.literal(false)
     461              :   })
     462              : ])
     463              : 
     464              : /**
     465              :  * Every tab of a site reads the same host-only cookie, so a sibling's answer
     466              :  * is this tab's own session observed elsewhere; that is what makes adopting
     467              :  * it safe. A per-tab session scope would break this assumption.
     468              :  */
     469         2356 : const zSharedMessage = z.object({
     470              :   from: z.enum(['heartbeat', 'sign_in', 'sign_out']),
     471              :   result: zSharedResult
     472              : })
     473              : 
     474              : type SharedFrom = z.infer<typeof zSharedMessage>['from']
     475              : 
     476              : /** What one tab of a site tells its siblings, and why. */
     477              : export interface WebSessionSharedMessage {
     478              :   readonly from: SharedFrom
     479              :   readonly result: WebSessionResult
     480              : }
     481              : 
     482         2356 : const revoked: WebSessionResult = {
     483              :   status: 'error',
     484              :   code: 'SESSION_REVOKED',
     485              :   retryable: false
     486              : }
     487              : 
     488         2356 : const scheduleWithTimer: ScheduleRetry = (run, delayMs) => {
     489            0 :   const timer = setTimeout(run, delayMs)
     490            0 :   return () => clearTimeout(timer)
     491              : }
     492              : 
     493            0 : function reportLocalSignOutFailure(error: unknown): void {
     494            0 :   console.warn('webSessionIdentity: local sign-out failed', error)
     495              : }
     496              : 
     497            0 : function createApiKeyIdentity(): WebSessionIdentity {
     498            0 :   const state: WebSessionIdentityState = { phase: 'api_key' }
     499            0 :   return {
     500              :     getState: () => state,
     501              :     subscribe: (listener) => {
     502            0 :       listener(state)
     503            0 :       return () => undefined
     504              :     },
     505              :     boot: () => undefined,
     506              :     signedIn: async () => ({
     507              :       status: 'error',
     508              :       code: 'SESSION_REQUEST_REFUSED',
     509              :       retryable: false
     510              :     }),
     511              :     signOut: async () => ({ status: 'ok' }),
     512              :     refresh: async () => state,
     513              :     getEpoch: () => 0,
     514              :     dispose: () => undefined
     515              :   }
     516              : }
     517              : 
     518            0 : function createAccountIdentity(
     519              :   options: WebSessionIdentityOptions,
     520              :   login: RememberedLogin
     521              : ): WebSessionIdentity {
     522            0 :   const schedule = options.schedule ?? scheduleWithTimer
     523            0 :   const retryBaseMs = options.retryBaseMs ?? 1000
     524            0 :   const retryMaxMs = options.retryMaxMs ?? 60_000
     525            0 :   const heartbeat = options.heartbeat
     526            0 :   const listeners = new Set<(state: WebSessionIdentityState) => void>()
     527            0 :   let state: WebSessionIdentityState = { phase: 'idle' }
     528            0 :   let epoch = 0
     529            0 :   let signOuts = 0
     530            0 :   let signIns = 0
     531            0 :   let liveSignIn = 0
     532            0 :   let cancelRetry: (() => void) | undefined
     533            0 :   let cancelProofRetry: (() => void) | undefined
     534            0 :   let cancelBeat: (() => void) | undefined
     535            0 :   let releaseLeadership: (() => void) | undefined
     536            0 :   let stopWatching: (() => void)[] = []
     537            0 :   let restoring = { epoch, settled: Promise.resolve(), inFlight: false }
     538              : 
     539            0 :   function dispatch(event: WebSessionIdentityEvent): void {
     540            0 :     const next = transitionWebSessionIdentity(state, event)
     541            0 :     const changed = next.state !== state
     542            0 :     if (changed) {
     543            0 :       cancelProofRetry?.()
     544            0 :       cancelProofRetry = undefined
     545              :     }
     546            0 :     state = next.state
     547            0 :     next.effects.forEach(run)
     548            0 :     if (changed) listeners.forEach((listener) => listener(state))
     549            0 :     syncLeadership()
     550              :   }
     551              : 
     552            0 :   function publish(from: SharedFrom, result: WebSessionResult): void {
     553            0 :     heartbeat?.crossTab?.publishCredential(HEARTBEAT_KEY, { from, result })
     554              :   }
     555              : 
     556              :   type Answered =
     557              :     | { readonly type: 'read_answered' | 'restore_answered' }
     558              :     | { readonly type: 'session_observed'; readonly from: SessionObservedFrom }
     559              : 
     560            0 :   async function answer(
     561              :     started: number,
     562              :     answered: Answered,
     563              :     request: () => Promise<WebSessionResult>
     564              :   ): Promise<void> {
     565            0 :     const result = await request()
     566            0 :     const remembered = await login.currentUserId().then(
     567              :       (value) => ({ value }),
     568              :       () => undefined
     569              :     )
     570            0 :     if (started !== epoch) return
     571              :     // A failed lookup matters only without a live session to adopt: with one,
     572              :     // it can skip nothing but the different-user sign-out.
     573            0 :     if (remembered === undefined && result.status !== 'ok') {
     574            0 :       return dispatch({ type: 'login_errored' })
     575              :     }
     576            0 :     dispatch({
     577              :       ...answered,
     578              :       result,
     579              :       rememberedUserId: remembered?.value ?? null
     580              :     })
     581              :   }
     582              : 
     583            0 :   function beat(): Promise<void> {
     584            0 :     const started = epoch
     585              :     const observed = { type: 'session_observed', from: 'this_tab' } as const
     586            0 :     return answer(started, observed, async () => {
     587            0 :       const result = await readWebSession(options.session)
     588              :       const shared = result.status === 'ok' || result.code === 'SESSION_REVOKED'
     589            0 :       if (shared && started === epoch) publish('heartbeat', result)
     590            0 :       return result
     591              :     })
     592              :   }
     593              : 
     594            0 :   function invalidatePendingSignIns(): void {
     595            0 :     signOuts += 1
     596            0 :     liveSignIn = 0
     597              :   }
     598              : 
     599            0 :   function adopt(message: unknown): void {
     600            0 :     const parsed = zSharedMessage.safeParse(message)
     601            0 :     if (!parsed.success) return
     602            0 :     const { from, result } = parsed.data
     603            0 :     if (from === 'sign_out') invalidatePendingSignIns()
     604            0 :     const observed = {
     605              :       type: 'session_observed',
     606              :       from: `sibling_${from}`
     607              :     } as const
     608            0 :     void answer(epoch, observed, async () => result)
     609              :   }
     610              : 
     611            0 :   function wantsBeat(): boolean {
     612            0 :     return (
     613              :       stopWatching.length > 0 &&
     614              :       state.phase === 'signed_in' &&
     615              :       heartbeat?.visibility.isVisible() === true
     616              :     )
     617              :   }
     618              : 
     619            0 :   function armBeat(): void {
     620            0 :     cancelBeat = schedule(() => {
     621            0 :       void beat()
     622            0 :       armBeat()
     623              :     }, heartbeat?.intervalMs ?? HEARTBEAT_INTERVAL_MS)
     624              :   }
     625              : 
     626            0 :   function lead(): void {
     627            0 :     if (wantsBeat() && cancelBeat === undefined) armBeat()
     628              :   }
     629              : 
     630            0 :   function syncLeadership(): void {
     631            0 :     const wanted = wantsBeat()
     632            0 :     if (wanted && releaseLeadership === undefined) {
     633            0 :       const port = heartbeat?.crossTab
     634            0 :       if (port) {
     635            0 :         releaseLeadership = port.requestLeadership(HEARTBEAT_KEY, lead)
     636              :       } else {
     637            0 :         releaseLeadership = () => undefined
     638            0 :         lead()
     639              :       }
     640            0 :     } else if (!wanted && releaseLeadership !== undefined) {
     641            0 :       releaseLeadership()
     642            0 :       releaseLeadership = undefined
     643            0 :       cancelBeat?.()
     644            0 :       cancelBeat = undefined
     645              :     }
     646              :   }
     647              : 
     648            0 :   function watch(): void {
     649            0 :     if (heartbeat === undefined) return
     650            0 :     const { visibility, crossTab } = heartbeat
     651            0 :     stopWatching = [
     652              :       visibility.onChange((visible) => {
     653            0 :         if (visible && state.phase === 'signed_in') void beat()
     654            0 :         syncLeadership()
     655              :       }),
     656              :       ...(crossTab ? [crossTab.onCredential(HEARTBEAT_KEY, adopt)] : [])
     657              :     ]
     658              :   }
     659              : 
     660            0 :   function proofWithinTimeout(): Promise<{ value: string | null } | undefined> {
     661            0 :     return new Promise((resolve) => {
     662            0 :       const cancel = schedule(() => resolve(undefined), PROOF_TIMEOUT_MS)
     663            0 :       login.getProof().then(
     664              :         (value) => {
     665            0 :           cancel()
     666            0 :           resolve({ value })
     667              :         },
     668              :         () => {
     669            0 :           cancel()
     670            0 :           resolve(undefined)
     671              :         }
     672              :       )
     673              :     })
     674              :   }
     675              : 
     676            0 :   async function restore(
     677              :     started: number,
     678              :     expectedUserId: string,
     679              :     retried: boolean
     680              :   ): Promise<void> {
     681            0 :     const proof = await proofWithinTimeout()
     682            0 :     if (started !== epoch) return
     683            0 :     if (proof === undefined) {
     684            0 :       if (!retried && state.phase === 'signed_in') {
     685            0 :         cancelProofRetry?.()
     686            0 :         cancelProofRetry = schedule(() => {
     687            0 :           cancelProofRetry = undefined
     688            0 :           if (started === epoch && state.phase === 'signed_in') {
     689            0 :             startRestore(expectedUserId, true)
     690              :           }
     691              :         }, retryBaseMs)
     692              :       }
     693            0 :       return dispatch({ type: 'proof_errored' })
     694              :     }
     695            0 :     const { value } = proof
     696            0 :     if (value === null) return dispatch({ type: 'proof_missing' })
     697            0 :     await answer(started, { type: 'restore_answered' }, () =>
     698              :       createWebSession(options.session, async () => value, { expectedUserId })
     699              :     )
     700              :   }
     701              : 
     702            0 :   function startRestore(expectedUserId: string, retried: boolean): void {
     703            0 :     if (restoring.inFlight && restoring.epoch === epoch) return
     704            0 :     const settled = restore(epoch, expectedUserId, retried).finally(() => {
     705            0 :       if (restoring.settled === settled) {
     706            0 :         restoring = { ...restoring, inFlight: false }
     707              :       }
     708              :     })
     709            0 :     restoring = { epoch, settled, inFlight: true }
     710              :   }
     711              : 
     712            0 :   function run(effect: WebSessionIdentityEffect): void {
     713            0 :     switch (effect.type) {
     714              :       case 'read':
     715            0 :         void answer(epoch, { type: 'read_answered' }, () =>
     716              :           readWebSession(options.session)
     717              :         )
     718            0 :         return
     719              :       case 'restore':
     720            0 :         startRestore(effect.expectedUserId, false)
     721            0 :         return
     722              :       case 'schedule_retry':
     723            0 :         cancelRetry = schedule(
     724              :           () => {
     725            0 :             cancelRetry = undefined
     726            0 :             dispatch({ type: 'retry_due' })
     727              :           },
     728              :           Math.min(retryBaseMs * 2 ** (effect.failures - 1), retryMaxMs)
     729              :         )
     730            0 :         return
     731              :       case 'sign_out_locally':
     732            0 :         login.signOutLocally().catch(reportLocalSignOutFailure)
     733            0 :         return
     734              :       default:
     735            0 :         notify(effect)
     736              :     }
     737              :   }
     738              : 
     739            0 :   function notify(effect: WebSessionIdentityEffect): void {
     740            0 :     switch (effect.type) {
     741              :       case 'report':
     742            0 :         options.onBootstrap?.({
     743              :           outcome: effect.outcome,
     744              :           origin: options.origin
     745              :         })
     746            0 :         return
     747              :       case 'account_changed':
     748            0 :         epoch += 1
     749            0 :         options.onAccountChanged?.({ ...effect.change, epoch })
     750            0 :         return
     751              :       case 'report_signed_out_remotely':
     752            0 :         options.onSignedOutRemotely?.({ origin: options.origin })
     753              :     }
     754              :   }
     755              : 
     756            0 :   function stopHeartbeat(): void {
     757            0 :     stopWatching.forEach((stop) => stop())
     758            0 :     stopWatching = []
     759            0 :     syncLeadership()
     760              :   }
     761              : 
     762            0 :   return {
     763              :     getState: () => state,
     764              :     subscribe: (listener) => {
     765            0 :       listeners.add(listener)
     766            0 :       listener(state)
     767            0 :       return () => {
     768            0 :         listeners.delete(listener)
     769              :       }
     770              :     },
     771              :     boot: () => {
     772            0 :       if (state.phase !== 'idle') return
     773            0 :       watch()
     774            0 :       dispatch({ type: 'boot' })
     775              :     },
     776              :     signedIn: async (getProof) => {
     777            0 :       const signOutsAtStart = signOuts
     778            0 :       const signIn = ++signIns
     779            0 :       const result = await createWebSession(options.session, getProof)
     780            0 :       if (result.status !== 'ok') return result
     781            0 :       if (signOuts !== signOutsAtStart) {
     782              :         // A later sign-in owns the cookie now; deleting would end its session.
     783            0 :         if (liveSignIn > signIn) return revoked
     784            0 :         const cleanup = await deleteWebSession(options.session)
     785            0 :         return cleanup.status === 'ok' ? revoked : cleanup
     786              :       }
     787            0 :       liveSignIn = signIn
     788            0 :       dispatch({ type: 'session_created', session: result.session })
     789            0 :       publish('sign_in', result)
     790            0 :       return result
     791              :     },
     792              :     signOut: async () => {
     793            0 :       invalidatePendingSignIns()
     794            0 :       dispatch({ type: 'sign_out_requested' })
     795            0 :       const result = await deleteWebSession(options.session)
     796            0 :       if (result.status === 'ok') publish('sign_out', revoked)
     797            0 :       return result
     798              :     },
     799              :     refresh: async (expectedUserId) => {
     800            0 :       if (state.phase !== 'signed_in') return state
     801            0 :       if ((expectedUserId ?? state.session.user.id) !== state.session.user.id) {
     802            0 :         return state
     803              :       }
     804            0 :       await beat()
     805            0 :       if (restoring.epoch === epoch) await restoring.settled
     806            0 :       return state
     807              :     },
     808              :     getEpoch: () => epoch,
     809              :     dispose: () => {
     810            0 :       epoch += 1
     811            0 :       cancelRetry?.()
     812            0 :       cancelRetry = undefined
     813            0 :       cancelProofRetry?.()
     814            0 :       cancelProofRetry = undefined
     815            0 :       stopHeartbeat()
     816            0 :       state = { phase: 'idle' }
     817            0 :       listeners.forEach((listener) => listener(state))
     818              :     }
     819              :   }
     820              : }
     821              : 
     822              : /** Inert until `boot()`: constructing it sends no request and arms no timer. */
     823            0 : export function createWebSessionIdentity(
     824              :   options: WebSessionIdentityOptions
     825              : ): WebSessionIdentity {
     826            0 :   return options.principal.kind === 'api_key'
     827              :     ? createApiKeyIdentity()
     828              :     : createAccountIdentity(options, options.principal.rememberedLogin)
     829              : }
        

Generated by: LCOV version 2.0-1