@idp.global/sdk 19.4.0 → 19.6.0

package/dist_ts_relyingparty/classes.idpoidcprovider.js

@@ -2,26 +2,123 @@ import * as plugins from './plugins.js';
 import { OidcIntrospectionClient, OidcIntrospectionError, } from '../dist_ts_server/classes.oidc-introspection-client.js';
 import { createTrustedCaFetch } from '../dist_ts_server/helpers.trusted-ca-fetch.js';
 export const OIDC_PROMPTS = ['none', 'login', 'consent'];
-/** The provider could not be asked, or did not answer in its own contract. The caller fails closed on it. */
-export class OidcAuthorityUnavailableError extends Error {
+export const OIDC_PROVIDER_ERROR_CODES = [
+    'token_exchange_refused',
+    'login_mismatch',
+    'invalid_response',
+    'provider_unreachable',
+    'refresh_refused',
+];
+/** An OAuth error code is a short token; anything else a provider sends there is dropped, never kept. */
+const OAUTH_ERROR_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/;
+const oauthErrorOf = (valueArg) => typeof valueArg === 'string' && OAUTH_ERROR_PATTERN.test(valueArg) ? valueArg : undefined;
+/** The OAuth error and HTTP status of an openid-client failure that is the provider's own answer; `null` for any other failure. */
+const providerAnswerOf = (errorArg) => {
+    const openidClient = plugins.openidClient;
+    if (errorArg instanceof openidClient.ResponseBodyError) {
+        return { oauthError: oauthErrorOf(errorArg.error), status: errorArg.status };
+    }
+    if (errorArg instanceof openidClient.AuthorizationResponseError) {
+        return { oauthError: oauthErrorOf(errorArg.error) };
+    }
+    if (errorArg instanceof openidClient.WWWAuthenticateChallengeError) {
+        return { oauthError: oauthErrorOf(errorArg.cause[0]?.parameters.error), status: errorArg.status };
+    }
+    return null;
+};
+/** openid-client's codes (`ClientError.code`) for a provider that did not answer in time or within HTTP's own contract. */
+const UNREACHABLE_CLIENT_ERROR_CODES = ['OAUTH_TIMEOUT', 'OAUTH_ABORT', 'OAUTH_RESPONSE_IS_NOT_CONFORM'];
+/** openid-client's code for a JWT claim that is not the expected one: the nonce, the issuer, the audience or the authorized party. */
+const JWT_CLAIM_COMPARISON_CODE = 'OAUTH_JWT_CLAIM_COMPARISON_FAILED';
+/**
+ * The class of an openid-client failure of the code exchange or of UserInfo.
+ * The provider's own OAuth error answer is a refusal, or unreachable on a 5xx;
+ * a claim that does not match is not this login's; every other failure of
+ * openid-client's checks is an invalid response; and anything else (a
+ * transport failure is fetch's `TypeError`) is an unreachable provider.
+ */
+const classifyCompletionFailure = (errorArg) => {
+    if (errorArg instanceof OidcProviderError) {
+        return { code: errorArg.code, oauthError: errorArg.oauthError };
+    }
+    const answer = providerAnswerOf(errorArg);
+    if (answer) {
+        const code = answer.status !== undefined && answer.status >= 500
+            ? 'provider_unreachable'
+            : 'token_exchange_refused';
+        return { code, oauthError: answer.oauthError };
+    }
+    if (errorArg instanceof plugins.openidClient.ClientError) {
+        if (errorArg.code === JWT_CLAIM_COMPARISON_CODE) {
+            return { code: 'login_mismatch' };
+        }
+        return { code: errorArg.code !== undefined && UNREACHABLE_CLIENT_ERROR_CODES.includes(errorArg.code) ? 'provider_unreachable' : 'invalid_response' };
+    }
+    return { code: 'provider_unreachable' };
+};
+/** Why a refresh could not be made: openid-client's checks failed on the answer, or the provider could not be asked. */
+const refreshFailureReasonOf = (errorArg) => errorArg instanceof plugins.openidClient.ClientError
+    && !(errorArg.code !== undefined && UNREACHABLE_CLIENT_ERROR_CODES.includes(errorArg.code))
+    ? 'invalid_response'
+    : 'unavailable';
+/**
+ * Every failure of the provider this module throws: its `code` says which
+ * case it is, `oauthError` the provider's own OAuth error code where it sent
+ * one (a short token, never its description). An application classifies a
+ * failure by these and never by openid-client's classes; `cause` keeps the
+ * original for a debugger, not for a log line.
+ */
+export class OidcProviderError extends Error {
+    code;
+    oauthError;
+    constructor(messageArg, detailArg, causeArg) {
+        super(messageArg, { cause: causeArg });
+        this.name = 'OidcProviderError';
+        if (!OIDC_PROVIDER_ERROR_CODES.includes(detailArg?.code)) {
+            throw new TypeError('OidcProviderError needs one of OIDC_PROVIDER_ERROR_CODES');
+        }
+        this.code = detailArg.code;
+        const oauthError = oauthErrorOf(detailArg.oauthError);
+        if (oauthError !== undefined) {
+            this.oauthError = oauthError;
+        }
+    }
+}
+/**
+ * The provider could not be asked, or did not answer in its own contract. The
+ * caller fails closed on it. `code` is `provider_unreachable` or
+ * `invalid_response`, after `reason`.
+ */
+export class OidcAuthorityUnavailableError extends OidcProviderError {
     reason;
     constructor(reason, causeArg) {
-        super('The identity provider could not be observed', { cause: causeArg });
+        super('The identity provider could not be observed', {
+            code: reason === 'invalid_response' ? 'invalid_response' : 'provider_unreachable',
+            oauthError: providerAnswerOf(causeArg)?.oauthError,
+        }, causeArg);
         this.reason = reason;
         this.name = 'OidcAuthorityUnavailableError';
     }
 }
-/** The provider refused the refresh with `invalid_grant`: the refresh family is revoked, expired or was reused. */
-export class OidcRefreshRefusedError extends Error {
+/**
+ * The provider refused the refresh with `invalid_grant`: the refresh family is
+ * revoked, expired or was reused. `code` is `refresh_refused`.
+ */
+export class OidcRefreshRefusedError extends OidcProviderError {
     constructor(causeArg) {
-        super('The identity provider refused the refresh', { cause: causeArg });
+        super('The identity provider refused the refresh', { code: 'refresh_refused', oauthError: 'invalid_grant' }, causeArg);
         this.name = 'OidcRefreshRefusedError';
     }
 }
-export class OidcCompletionError extends Error {
+/**
+ * A login the provider half could not complete. `stage` says where it
+ * stopped, `code` what it was; without a `detailArg` the code is read from
+ * the cause, an openid-client failure.
+ */
+export class OidcCompletionError extends OidcProviderError {
     stage;
-    constructor(stage, causeArg) {
-        super('OIDC completion failed', { cause: causeArg });
+    constructor(stage, causeArg, detailArg) {
+        super('OIDC completion failed', detailArg ?? classifyCompletionFailure(causeArg), causeArg);
         this.stage = stage;
         this.name = 'OidcCompletionError';
     }
@@ -68,9 +165,9 @@ export const readOrganizationClaims = (valueArg) => {
 /**
  * The relying-party side of the authorization code flow with S256 PKCE on
  * `openid-client`, in the profile idp.global supports: code responses, S256
- * challenges, RS256 ID tokens and `client_secret_basic` for a confidential
- * client. Live organization authority is observed with the sdk's
- * `OidcIntrospectionClient`.
+ * challenges, RS256 ID tokens whose signature is verified against the
+ * issuer's JWKS, and `client_secret_basic` for a confidential client. Live
+ * organization authority is observed with the sdk's `OidcIntrospectionClient`.
  */
 export class IdpOidcProvider {
     requestTimeoutSeconds;
@@ -114,13 +211,18 @@ export class IdpOidcProvider {
         }
         const options = this.#options;
         // the timeout and the fetch given to discovery apply to discovery itself
-        // and stay on the resolved configuration for every later request
+        // and stay on the resolved configuration for every later request.
+        // `enableNonRepudiationChecks` verifies the signature of every ID token the
+        // code grant and the refresh grant answer against the issuer's JWKS
+        // (`jwks_uri`, fetched through the same fetch), so an ID token is never
+        // accepted on the trust of the TLS connection alone
         const configuration = await plugins.openidClient.discovery(options.issuer, options.clientId, {
             client_secret: options.clientSecret,
             token_endpoint_auth_method: 'client_secret_basic',
             id_token_signed_response_alg: 'RS256',
         }, plugins.openidClient.ClientSecretBasic(options.clientSecret), {
             timeout: this.requestTimeoutSeconds,
+            execute: [plugins.openidClient.enableNonRepudiationChecks],
             ...(this.#fetch ? { [plugins.openidClient.customFetch]: this.#fetch } : {}),
         });
         const metadata = configuration.serverMetadata();
@@ -164,6 +266,11 @@ export class IdpOidcProvider {
         });
     }
     async completeAuthorization(optionsArg) {
+        // the one state of the callback is the login's, or nothing is exchanged
+        const states = optionsArg.callbackUrl.searchParams.getAll('state');
+        if (states.length !== 1 || states[0] !== optionsArg.state) {
+            throw new OidcCompletionError('token_exchange', new Error('The callback state is not the state of this login'), { code: 'login_mismatch' });
+        }
         let tokens;
         try {
             tokens = await plugins.openidClient.authorizationCodeGrant(this.configuration, optionsArg.callbackUrl, {
@@ -185,7 +292,7 @@ export class IdpOidcProvider {
             subject = claims.sub;
         }
         catch (error) {
-            throw new OidcCompletionError('token_validation', error);
+            throw new OidcCompletionError('token_validation', error, { code: 'invalid_response' });
         }
         // UserInfo is the current view of profile and organization claims; the ID
         // token proves the login. Both are read, and the subjects must agree.
@@ -197,7 +304,7 @@ export class IdpOidcProvider {
             throw new OidcCompletionError('userinfo', error);
         }
         if (userInfo.sub !== subject) {
-            throw new OidcCompletionError('token_validation', new Error('The UserInfo subject does not match the ID token'));
+            throw new OidcCompletionError('token_validation', new Error('The UserInfo subject does not match the ID token'), { code: 'invalid_response' });
         }
         return {
             subject,
@@ -263,7 +370,10 @@ export class IdpOidcProvider {
             if (error instanceof plugins.openidClient.ResponseBodyError && error.error === 'invalid_grant') {
                 throw new OidcRefreshRefusedError(error);
             }
-            throw new OidcAuthorityUnavailableError('unavailable', error);
+            // everything else fails closed: another OAuth error (`invalid_client` for a
+            // deactivated app) or a transport failure is unreachable, an answer that
+            // fails openid-client's checks (an ID token that does not verify) is invalid
+            throw new OidcAuthorityUnavailableError(refreshFailureReasonOf(error), error);
         }
         return {
             accessToken: tokens.access_token,
@@ -272,4 +382,4 @@ export class IdpOidcProvider {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.idpoidcprovider.js","sourceRoot":"","sources":["../../ts_relyingparty/classes.idpoidcprovider.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.idpoidcprovider.js","sourceRoot":"","sources":["../../ts_relyingparty/classes.idpoidcprovider.ts"],"names":[],"mappings":"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"}

package/dist_ts_relyingparty/classes.relyingpartysessions.d.ts

@@ -1,6 +1,6 @@
 import { type IOidcProvider } from './classes.idpoidcprovider.js';
 import type { IRelyingPartyModels } from './classes.rpmodels.js';
-import type { IAuthorityTokenSource, IProviderToken, IRelyingPartyBearerDelivery, IRelyingPartyBearerHandoff, IRelyingPartyBearerLoginRequest, IRelyingPartyBearerLoginStart, IRelyingPartyBearerOptions, IRelyingPartyBearerReturnTargets, IRelyingPartyBearerTokens, IRelyingPartyHooks, IRelyingPartyLiveSession, IRelyingPartyLoginOptions, IRelyingPartyLoginStart, IRelyingPartySession, IRelyingPartySessionOpening, IRelyingPartySessionsPage, IRelyingPartySessionsPageOptions, IResolvedRelyingPartySession, TRelyingPartyPrincipals, TRelyingPartySessionEndReason } from './interfaces.js';
+import type { IAuthorityTokenSource, IProviderToken, IRelyingPartyBearerDelivery, IRelyingPartyBearerHandoff, IRelyingPartyBearerHandoffOpening, IRelyingPartyBearerLoginRequest, IRelyingPartyBearerLoginStart, IRelyingPartyBearerOptions, IRelyingPartyBearerReturnTargets, IRelyingPartyBearerTokens, IRelyingPartyCookiePolicy, IRelyingPartyHooks, IRelyingPartyLiveSession, IRelyingPartyLoginOptions, IRelyingPartyLoginStart, IRelyingPartySession, IRelyingPartySessionOpening, IRelyingPartySessionsErasure, IRelyingPartySessionsPage, IRelyingPartySessionsPageOptions, IResolvedRelyingPartySession, TRelyingPartyPrincipals, TRelyingPartySessionEndReason } from './interfaces.js';
 export declare const RELYING_PARTY_DEFAULT_SESSION_MAX_AGE_SECONDS: number;
 export declare const RELYING_PARTY_DEFAULT_LOGIN_PATH_PREFIX = "/auth/";
 /** The label the CSRF HMAC starts with unless the application names its own. */
@@ -17,6 +17,10 @@ export declare const RELYING_PARTY_MAX_SESSIONS_PAGE_LIMIT = 1000;
 export declare const BEARER_HANDOFF_MAX_AGE_SECONDS = 60;
 /** How long a bearer access token lives unless `bearer.accessTokenMaxAgeSeconds` says otherwise. */
 export declare const RELYING_PARTY_DEFAULT_BEARER_ACCESS_TOKEN_MAX_AGE_SECONDS: number;
+/** How long a spent refresh token may come back as a lost answer unless `bearer.refreshReuseGraceSeconds` says otherwise. */
+export declare const RELYING_PARTY_DEFAULT_REFRESH_REUSE_GRACE_SECONDS = 60;
+/** The longest `bearer.refreshReuseGraceSeconds`: a spent token that comes back later is always reuse. */
+export declare const RELYING_PARTY_MAX_REFRESH_REUSE_GRACE_SECONDS = 300;
 /**
  * How long ending a session waits for the provider to take its tokens back.
  * The local session is already revoked when that call runs.
@@ -62,6 +66,14 @@ export interface IRelyingPartySessionsOptions<TPrincipal extends object | undefi
         session?: string;
         intent?: string;
     };
+    /**
+     * How the session and intent cookies go across sites: `{ sameSite: 'Lax' }`
+     * by default. A page framed on another site needs `sameSite: 'None'` (an
+     * https `publicOrigin` only), with `partitioned: true` where the browser
+     * keeps third-party cookies per top-level site. The constructor refuses
+     * every other combination.
+     */
+    cookiePolicy?: IRelyingPartyCookiePolicy;
     /** the prefix of the login routes; a login never returns into it */
     loginPathPrefix?: string;
     /**
@@ -78,20 +90,22 @@ export interface IRelyingPartySessionsOptions<TPrincipal extends object | undefi
  * sign in through bearer hand-off and nothing else. The relying party never
  * reads or sets a cookie — not even the clearing intent cookie of a callback
  * that is no bearer login — so it has no CSRF token and takes no CSRF key:
- * `csrfKey`, `csrfLabel` and `cookieNames` are refused, not ignored. The
+ * `csrfKey`, `csrfLabel`, `cookieNames` and `cookiePolicy` are refused, not
+ * ignored. The
  * cookie steps (`openSession`, `startLogin`, `completeLogin`, `abandonLogin`,
  * `finalizeLogin`, `clearSessionCookie`, `clearIntentCookie`) throw
  * `RelyingPartyError('login_method_unavailable')` and `resolveCookieSession`
  * answers `null`.
  */
-export interface IRelyingPartyBearerOnlySessionsOptions<TPrincipal extends object | undefined = undefined> extends Omit<IRelyingPartySessionsOptions<TPrincipal>, 'provider' | 'csrfKey' | 'csrfLabel' | 'cookieNames' | 'cookieSessions' | 'bearer'> {
+export interface IRelyingPartyBearerOnlySessionsOptions<TPrincipal extends object | undefined = undefined> extends Omit<IRelyingPartySessionsOptions<TPrincipal>, 'provider' | 'csrfKey' | 'csrfLabel' | 'cookieNames' | 'cookiePolicy' | 'cookieSessions' | 'bearer'> {
     cookieSessions: false;
-    /** every bearer session is a provider login */
+    /** every bearer session comes from a live provider login, directly or through a hand-off opened from one */
     provider: IOidcProvider;
     bearer: IRelyingPartyBearerOptions;
     csrfKey?: never;
     csrfLabel?: never;
     cookieNames?: never;
+    cookiePolicy?: never;
 }
 /**
  * The relying-party session layer: provider logins through the authorization
@@ -106,10 +120,10 @@ export interface IRelyingPartyBearerOnlySessionsOptions<TPrincipal extends objec
  * ended sessions are swept one bounded batch at a time when a login starts or
  * the application opens a session, and the only timer — the revocation
  * budget — is unreferenced and cleared on every path. Every session comes
- * from a login start or from `openSession`, and each of those sweeps a batch
- * of at least one first, so removal keeps pace with creation and the ended
- * sessions kept stay bounded. Nothing here does I/O while it is constructed,
- * so it is built before the database connects.
+ * from a login start, `openSession` or `openBearerHandoff`, and each of those
+ * sweeps a batch of at least one first, so removal keeps pace with creation
+ * and the ended sessions kept stay bounded. Nothing here does I/O while it is
+ * constructed, so it is built before the database connects.
  *
  * `TPrincipal` is what a `principals.resolve` answers; with `isActive`
  * principals it stays `undefined`.
@@ -120,6 +134,8 @@ export declare class RelyingPartySessions<TPrincipal extends object | undefined
     readonly secureCookies: boolean;
     readonly sessionCookieName: string;
     readonly intentCookieName: string;
+    /** how the session and intent cookies go across sites, as the constructor resolved `cookiePolicy` */
+    readonly cookiePolicy: Readonly<Required<IRelyingPartyCookiePolicy>>;
     readonly loginPathPrefix: string;
     readonly sessionMaxAgeSeconds: number;
     constructor(optionsArg: IRelyingPartySessionsOptions<TPrincipal> | IRelyingPartyBearerOnlySessionsOptions<TPrincipal>);
@@ -181,10 +197,29 @@ export declare class RelyingPartySessions<TPrincipal extends object | undefined
     /**
      * Ends every live session of a principal but `keepSessionId` (a password
      * change keeps the session that asked for it) and answers how many ended.
+     * A session that expired is over already and is neither ended nor counted.
      */
     endSessionsOfPrincipal(principalIdArg: string, optionsArg?: {
         keepSessionId?: string;
     }): Promise<number>;
+    /**
+     * Erases every session of a principal, live or ended, and every row that
+     * belongs to one, without waiting for a sweep: what an application runs
+     * when it deletes an account, after its own erasers and before its user
+     * record.
+     *
+     * First each session not revoked yet, an expired one too, ends as
+     * `endSession` ends it: its tokens stop working at once, `onSessionEnded`
+     * names the principal, and its provider tokens go back to idp.global,
+     * which a deleted row could no longer do. Then each session's rows go: in
+     * bearer mode its hand-offs, claimed or not, and its token generations;
+     * the login attempt a provider session came out of; and the session row
+     * last, because it is the only link from the principal to the others, so
+     * an erase that fails half way leaves a retry everything it needs. A
+     * session opened or a token issued while the erase runs is not covered;
+     * it works only while the principal is active.
+     */
+    eraseSessionsOfPrincipal(principalIdArg: string): Promise<IRelyingPartySessionsErasure>;
     /**
      * One page of a principal's live sessions, newest first: the ones neither
      * ended nor expired, and none at all while the principal is not active —
@@ -248,6 +283,35 @@ export declare class RelyingPartySessions<TPrincipal extends object | undefined
      * at most and only its hash is stored. A code nobody claims ends its session.
      */
     completeBearerLogin(callbackUrlArg: URL): Promise<IRelyingPartyBearerHandoff>;
+    /**
+     * Opens a bearer session for a device the application pairs to a person
+     * who is signed in here, and answers its single-use hand-off code, which
+     * the device claims at `bearer/claim` with the verifier of `codeChallenge`,
+     * exactly like the code of a bearer login.
+     *
+     * `openerSessionId` names the session that confirmed the pairing, taken
+     * from the application's own record, never from the device. It must be a
+     * live provider login: not ended, not expired, its principal active, and
+     * with a provider login of its own. A session the application opened
+     * itself or one opened here does not qualify, so a paired device never
+     * pairs another one. Anything else throws
+     * `RelyingPartyError('invalid_handoff_opener')`.
+     *
+     * The new session acts as the opener's principal and has no provider login
+     * of its own: it ends by its expiry, `endSession`, `endSessionsOfPrincipal`,
+     * `bearer/logout` or the reuse of one of its credentials, never by an
+     * idp.global logout, and `AuthorityObserver` refuses it
+     * (`authority_login_required`). `maxAgeSeconds` is a whole number from 1 to
+     * `sessionMaxAgeSeconds`, the default, as for `openSession`. The code lives
+     * `BEARER_HANDOFF_MAX_AGE_SECONDS` at most and never past the session, and
+     * only its hash is stored; a code nobody claims ends its session. Nothing
+     * is stored for a refused opening.
+     */
+    openBearerHandoff(optionsArg: {
+        openerSessionId: string;
+        codeChallenge: string;
+        maxAgeSeconds?: number;
+    }): Promise<IRelyingPartyBearerHandoffOpening>;
     /** `abandonLogin` for a bearer login: the provider came back without a code. */
     abandonBearerLogin(callbackUrlArg: URL): Promise<void>;
     /**
@@ -261,13 +325,45 @@ export declare class RelyingPartySessions<TPrincipal extends object | undefined
     /**
      * Rotates a bearer session's tokens: the refresh token is spent, a new
      * access and refresh token answer, and the old access token stops working.
-     * Rotation is strict — a client serializes its refreshes — because a
-     * refresh token that comes back after it was spent ends the whole session.
-     * The provider login is checked on the way: a login idp.global ended ends
-     * the session here (`invalid_bearer_grant`), an unreachable provider fails
-     * with `AuthorityTokenError('authority_unavailable')` and spends nothing.
+     * A client serializes its refreshes, because a refresh token that comes
+     * back after it was spent ends the whole session, with one exception for
+     * an answer that never reached the client: within
+     * `bearer.refreshReuseGraceSeconds` of its rotation (60 by default), a
+     * spent refresh token whose successor was never presented — neither its
+     * access token nor its refresh token — revokes that successor and answers a
+     * new pair (`bearer_refresh_reissued`). Only hashes are stored, so the lost
+     * pair is replaced, never repeated. Once the successor was presented, after
+     * the window, or for a second retry that loses the race to the first, it is
+     * reuse. The provider login of a bearer login is checked on the way: a
+     * login idp.global ended ends the session here (`invalid_bearer_grant`), an
+     * unreachable provider fails with `AuthorityTokenError('authority_unavailable')`
+     * and spends nothing. A session `openBearerHandoff` opened has no provider
+     * login (no `idpSubject` is stored) and rotates without the provider.
      */
     refreshBearerTokens(refreshTokenArg: unknown): Promise<IRelyingPartyBearerTokens>;
+    /**
+     * The successor of a spent generation when its answer may have been lost:
+     * the rotation is at most `refreshReuseGraceMs` old, and the successor is
+     * still current and was never presented. `null` otherwise, which is reuse.
+     */
+    private lostSuccessorOf;
+    /**
+     * Issues a pair again for a spent generation whose answer was lost. The
+     * successor that answer carried is revoked first, by one conditional write
+     * that needs it current and unpresented: of two retries at once exactly one
+     * takes it, and the other is reuse, as is a successor presented in the
+     * meantime. Then the new generation is stored and the spent one names it,
+     * so a retry after this answer is lost too finds it within the same window
+     * (counted from the original rotation). A failure after the revocation
+     * leaves the session without a current generation; its retry is reuse.
+     */
+    private reissueLostRotation;
+    /**
+     * Records the first presentation of a current generation's access or refresh
+     * token, once. Answers whether the generation is still current: `false`
+     * when a lost answer of its predecessor revoked it just now.
+     */
+    private markBearerGenerationPresented;
     /**
      * The live session behind a bearer access token, or `null`: the token of the
      * session's current generation, not expired, its session live and its
@@ -279,7 +375,9 @@ export declare class RelyingPartySessions<TPrincipal extends object | undefined
     /**
      * Ends the session of a bearer token — a live access token or the current
      * refresh token — like `endSession`. A refresh token that was already spent
-     * is reuse and ends the session as such. Answers whether this call ended it.
+     * is reuse and ends the session as such, unless `refreshBearerTokens` would
+     * take it as a lost answer (`lostSuccessorOf`): then it is a logout like the
+     * current one. Answers whether this call ended it.
      */
     endBearerSession(tokenArg: unknown): Promise<boolean>;
     /**
@@ -328,6 +426,8 @@ export declare class RelyingPartySessions<TPrincipal extends object | undefined
      */
     private openProviderLogin;
     private newSessionDoc;
+    /** The attributes every session and intent cookie is set and cleared with: one policy for all of them. */
+    private cookieAttributes;
     private csrfTokenOf;
     private opening;
     private snapshot;
@@ -341,7 +441,13 @@ export declare class RelyingPartySessions<TPrincipal extends object | undefined
     private createProviderSession;
     /** Where a bearer attempt's outcome goes, while its return target is still configured; `null` otherwise. */
     private bearerDeliveryOfAttempt;
-    /** Stores the next token generation of a live session and answers its tokens; none of them is stored in the clear. */
+    /**
+     * Stores a new hand-off of a session, bound to the client's challenge, and
+     * answers its code, which is stored only as a hash. The code lives
+     * `BEARER_HANDOFF_MAX_AGE_SECONDS` at most and never past the session.
+     */
+    private storeBearerHandoff;
+    /** Stores the next token generation of a live session and answers its tokens and its id; no token is stored in the clear. */
     private issueBearerTokens;
     /** A spent hand-off code or refresh token came back: whoever holds it, the session ends. */
     private bearerCredentialReused;
@@ -415,9 +521,13 @@ export declare class RelyingPartySessions<TPrincipal extends object | undefined
      * page per login start and per session the application opens. An ended
      * session's expiry is its revocation at the latest, so the expiry index
      * finds expired and revoked sessions alike. Each of them ended already: the
-     * row goes without an end, a hook or a provider call. A row is deleted only
-     * while its expiry is still past the cutoff, so a row whose expiry moved
-     * after the page was read stays. A sweep that cannot run never blocks a
+     * row goes without an end, a hook or a provider call. Its children go
+     * first: in bearer mode its hand-offs and token generations, by their
+     * `sessionId` index, and only then the session row, which is the only link
+     * from a principal to them; a sweep that fails half way leaves the session
+     * row, and the next sweep finds it and deletes the rest. Expiry never moves
+     * later, so a session past the cutoff stays past it, and its row is deleted
+     * only while that still holds. A sweep that cannot run never blocks a
      * sign-in.
      */
     private sweepEndedSessions;