@idp.global/sdk 19.5.0 → 19.6.0

package/changelog.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 2026-11-11 - 19.6.0
+
+### Features
+
+- a lost refresh answer no longer signs the person out: `bearer.refreshReuseGraceSeconds` (relyingparty)
+  - A spent bearer refresh token that comes back within the window of its rotation (60 seconds by default, 0 turns it off, at most 300; the constructor refuses anything else), while its successor was never presented, revokes that successor and answers a new pair; the `bearer_refresh_reissued` event reports it. Presented means the successor's access token authenticated a request or its refresh token was sent to `bearer/refresh`; the first presentation is recorded on the token generation (`firstUsedAt`), and a rotation names its successor (`successorId`). Only hashes are stored, so the lost pair is replaced, never repeated.
+  - Once the successor was presented, after the window (counted from the rotation, however often the retry's answer is lost too), and for the second of two retries at once, the spent token is reuse and ends the session as before (`refresh_token_reused`). Generations stored before this release carry neither field and are handled as before.
+  - `bearer/logout` (`endBearerSession`) judges a spent refresh token as the refresh does: one that would be a lost answer there ends the session as a `logout`, so signing out after a lost refresh answer reports no `bearer_credential_reused` and no `refresh_token_reused`.
+  - The browser client needs no change: after a lost refresh its next refresh with the stored pair recovers within the window. A relying party that wants the strict rotation of 19.5.0 sets `refreshReuseGraceSeconds: 0`.
+  - `TRelyingPartyEventName` gains `bearer_refresh_reissued`; a consumer that switches over it exhaustively adds the case.
+  - The first request with each new access token now writes once to record its presentation.
+- a cookie policy for framed applications: `cookiePolicy: { sameSite, partitioned }` (relyingparty)
+  - `sameSite` is `'Lax'` (the default, unchanged) or `'None'`; `partitioned: true` adds the CHIPS `Partitioned` attribute and is valid only with `'None'`. One policy goes on the session and the intent cookie, on every `Set-Cookie` that sets or clears them: the login start, the opened session, `openSession`, `clearSessionCookie` and `clearIntentCookie`.
+  - The constructor refuses `partitioned` without `sameSite: 'None'`, `sameSite: 'None'` on an http `publicOrigin` (a `SameSite=None` cookie must be `Secure`), any other value, and `cookiePolicy` in bearer-only mode. `sessions.cookiePolicy` answers the resolved policy.
+  - `serializeCookie` takes `partitioned` and throws when it is given without `secure`.
+- typed provider errors: `OidcProviderError` with `code` and `oauthError` (relyingparty)
+  - An application classifies a failure of the provider half without importing openid-client. `code` (`TOidcProviderErrorCode`, listed in `OIDC_PROVIDER_ERROR_CODES`) is `token_exchange_refused`, `login_mismatch`, `invalid_response`, `provider_unreachable` or `refresh_refused`; `oauthError` is the provider's own OAuth error code when it sent one, such as `invalid_grant`, kept only when it is a short token and never with its description.
+  - `OidcCompletionError`, `OidcRefreshRefusedError` and `OidcAuthorityUnavailableError` now extend `OidcProviderError`; their names, `stage`, `reason` and constructors stay, and `OidcCompletionError` takes the code as an optional third argument (without it, the code is read from the cause). `IdpOidcProvider` maps openid-client's failures to the codes, and the provider double of `/relyingparty/testing` answers with the codes idp.global's would.
+  - `IdpOidcProvider.completeAuthorization` refuses a callback whose one `state` is not the login's (`login_mismatch`) before it asks the provider. A refresh whose answer fails openid-client's checks is now `OidcAuthorityUnavailableError` with the reason `invalid_response` instead of `unavailable`; both fail closed as before.
+
+### Fixes
+
+- a swept session takes its bearer rows with it, and `endSessionsOfPrincipal` leaves expired sessions alone (relyingparty)
+  - The session sweep now deletes a session's bearer hand-offs and token generations by `sessionId` before the session row. Before, a session revoked early was swept an hour after its revocation while its generations stayed until an hour after its original expiry, with no row left that named the principal, so `eraseSessionsOfPrincipal` could not reach them. A sweep that fails between the two leaves the session row, and the next sweep finishes it.
+  - The bearer hand-off and bearer token models declare a `sessionId` index, which the sweep and `eraseSessionsOfPrincipal` read; it is built on first use like the `expiresAt` index. On the test suite's engine a token write cost 3.68 instead of 3.22 ms in memory and 9.38 instead of 9.23 ms on file storage, and a delete by session took 5 instead of 54 ms (4,000 rows, memory) and 16 instead of 88 ms (600 rows, file).
+  - `endSessionsOfPrincipal` reads only sessions that have not expired: an expired one is over already and is no longer revoked, handed back to the provider or counted. `eraseSessionsOfPrincipal` still ends it.
+- ID tokens are verified against idp.global's signing keys (relyingparty)
+  - Before, `IdpOidcProvider` accepted the ID token of a code exchange or a refresh on the trust of the TLS connection to the token endpoint alone and never checked its signature. Discovery now turns on openid-client's `enableNonRepudiationChecks`, so every ID token of both grants is checked against the issuer's `jwks_uri` (RS256), fetched through the provider's own transport (`trustedCaPem` or `fetch` included) and cached by openid-client.
+  - A code exchange whose ID token is signed by a key outside the JWKS fails as `OidcCompletionError` at the `token_exchange` stage, and a refresh as `OidcAuthorityUnavailableError`, which ends nothing and fails closed. The first login after a start fetches the JWKS once more.
+
+### Maintenance
+
+- release tooling: `@git.zone/tsrepo` ^1.1.1 → ^2.1.0 (2.0.0 makes `@push.rocks/smartmongo` an optional peer of its tapbundle; the sdk's tests do not call `createSmartmongo()`), `@types/node` 26.6.5 → 26.6.6 and pnpm 12.14.0 → 12.17.0; the re-resolved tooling (`@push.rocks/smartfile` 13.2.4 with `@push.rocks/smartcrypto` 3.1.0) no longer installs `node-forge`; `brace-expansion` 2.1.2 → 2.1.7 (through `minimatch` 9.0.9 in the production closure) clears its high advisories.
+
 ## 2026-10-26 - 19.5.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@idp.global/sdk',
-    version: '19.5.0',
+    version: '19.6.0',
     description: 'Reusable browser and server SDK for idp.global authentication.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxpQkFBaUI7SUFDdkIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLGdFQUFnRTtDQUM5RSxDQUFBIn0=

package/dist_ts_relyingparty/classes.idpoidcprovider.d.ts

@@ -56,22 +56,80 @@ export interface IOidcRefreshedTokens {
     /** epoch milliseconds; `0` when the token response named no lifetime */
     accessTokenExpiresAt: number;
 }
+/**
+ * What failed when the provider was asked, as an application tells the cases
+ * apart; never why access was refused, which only an authority answer says.
+ */
+export type TOidcProviderErrorCode = 
+/**
+ * The provider refused the login: an OAuth error in the callback, for the
+ * code at the token endpoint, or for its token at UserInfo. `oauthError`
+ * names it, such as `invalid_grant` for a code that was used or expired.
+ */
+'token_exchange_refused'
+/**
+ * The callback or its ID token is not this login's: a `state` that is not
+ * the login's, or an ID token claim that does not match it (the nonce, and
+ * likewise the issuer, the audience or the authorized party).
+ */
+ | 'login_mismatch'
+/**
+ * The provider answered outside its contract: an ID token whose signature
+ * does not verify against the JWKS or that has expired, no subject, another
+ * subject at UserInfo, or a body that is no OAuth answer.
+ */
+ | 'invalid_response'
+/** The provider could not be asked: no answer in time, a transport failure, a 5xx, or no discovery yet. */
+ | 'provider_unreachable'
+/** The refresh grant answered `invalid_grant`: the refresh family is revoked, expired or was reused. */
+ | 'refresh_refused';
+export declare const OIDC_PROVIDER_ERROR_CODES: readonly TOidcProviderErrorCode[];
+/**
+ * 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 declare class OidcProviderError extends Error {
+    readonly code: TOidcProviderErrorCode;
+    readonly oauthError?: string;
+    constructor(messageArg: string, detailArg: {
+        code: TOidcProviderErrorCode;
+        oauthError?: string;
+    }, causeArg?: unknown);
+}
 /** Why an observation or a refresh could not be made; never why access was refused. */
 export type TOidcAuthorityFailure = 'unavailable' | 'invalid_response';
-/** The provider could not be asked, or did not answer in its own contract. The caller fails closed on it. */
-export declare class OidcAuthorityUnavailableError extends Error {
+/**
+ * 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 declare class OidcAuthorityUnavailableError extends OidcProviderError {
     readonly reason: TOidcAuthorityFailure;
     constructor(reason: TOidcAuthorityFailure, causeArg?: unknown);
 }
-/** The provider refused the refresh with `invalid_grant`: the refresh family is revoked, expired or was reused. */
-export declare 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 declare class OidcRefreshRefusedError extends OidcProviderError {
     constructor(causeArg?: unknown);
 }
 export type TOidcTokenHint = 'access_token' | 'refresh_token';
 export type TOidcCompletionFailureStage = 'token_exchange' | 'token_validation' | 'userinfo';
-export declare 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 declare class OidcCompletionError extends OidcProviderError {
     readonly stage: TOidcCompletionFailureStage;
-    constructor(stage: TOidcCompletionFailureStage, causeArg: unknown);
+    constructor(stage: TOidcCompletionFailureStage, causeArg: unknown, detailArg?: {
+        code: TOidcProviderErrorCode;
+        oauthError?: string;
+    });
 }
 /**
  * What the session layer needs from the provider. `IdpOidcProvider` is the
@@ -115,7 +173,7 @@ export interface IIdpOidcProviderOptions {
     /** the registered callback, on the application's public origin */
     redirectUri: URL;
     scopes?: string;
-    /** deadline of discovery, token, UserInfo, refresh and revocation requests */
+    /** deadline of discovery, token, JWKS, UserInfo, refresh and revocation requests */
     requestTimeoutSeconds?: number;
     /** deadline of one introspection; the introspection client's default applies when absent */
     introspectionTimeoutMs?: number;
@@ -129,7 +187,7 @@ export interface IIdpOidcProviderOptions {
     trustedCaPem?: string | readonly string[];
     /**
      * Advanced: the fetch that carries every request of this provider —
-     * discovery, token, UserInfo, refresh, revocation and introspection.
+     * discovery, token, JWKS, UserInfo, refresh, revocation and introspection.
      * It owns the transport's trust decisions; https-only still holds. Not
      * combined with `trustedCaPem`.
      */
@@ -144,9 +202,9 @@ export declare const readOrganizationClaims: (valueArg: unknown) => IOidcOrganiz
 /**
  * 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 declare class IdpOidcProvider implements IOidcProvider {
     #private;

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, IRelyingPartyBearerHandoffOpening, IRelyingPartyBearerLoginRequest, IRelyingPartyBearerLoginStart, IRelyingPartyBearerOptions, IRelyingPartyBearerReturnTargets, IRelyingPartyBearerTokens, IRelyingPartyHooks, IRelyingPartyLiveSession, IRelyingPartyLoginOptions, IRelyingPartyLoginStart, IRelyingPartySession, IRelyingPartySessionOpening, IRelyingPartySessionsErasure, 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,13 +90,14 @@ 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 comes from a live provider login, directly or through a hand-off opened from one */
     provider: IOidcProvider;
@@ -92,6 +105,7 @@ export interface IRelyingPartyBearerOnlySessionsOptions<TPrincipal extends objec
     csrfKey?: never;
     csrfLabel?: never;
     cookieNames?: never;
+    cookiePolicy?: never;
 }
 /**
  * The relying-party session layer: provider logins through the authorization
@@ -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,6 +197,7 @@ 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;
@@ -308,15 +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 of a bearer login is checked on the way: a login
-     * idp.global ended ends the session here (`invalid_bearer_grant`), an
+     * 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
@@ -328,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>;
     /**
@@ -377,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;
@@ -396,7 +447,7 @@ export declare class RelyingPartySessions<TPrincipal extends object | undefined
      * `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; none of them is stored in the clear. */
+    /** 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;
@@ -470,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;