@idp.global/sdk 19.4.0 → 19.6.0

package/changelog.md

@@ -1,5 +1,65 @@
 # 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
+
+- pairing a device: `openBearerHandoff({ openerSessionId, codeChallenge, maxAgeSeconds? })` (relyingparty)
+  - An application that has signed a person in opens a bearer session for a second device of theirs, such as a TV or a browser extension, and answers its single-use hand-off code. The device claims the code at the existing `bearer/claim` with the verifier of its challenge, under the rules of a bearer login's code: one claim within at most 60 seconds, never past the session, stored only as a hash, and a reused code, a wrong verifier or an unclaimed code ends the session.
+  - The opener must be a live provider login: not ended or expired, with an active principal and its own `idpSubject`. A session from `openSession` or from `openBearerHandoff` does not qualify, so a paired device cannot pair another. Any other opener throws the new `RelyingPartyError` code `invalid_handoff_opener` (400) and stores nothing; a consumer with an exhaustive switch over `TRelyingPartyErrorCode` adds that case. A malformed challenge throws `invalid_bearer_request`, a `maxAgeSeconds` outside 1 to `sessionMaxAgeSeconds` throws a `RangeError`, and without `bearer` the call throws `login_method_unavailable`. It works in bearer-only mode, and like every way to create a session it sweeps first.
+  - The session acts as the opener's principal, without `idpSubject` or `loginAttemptId`, and lives `maxAgeSeconds` (by default `sessionMaxAgeSeconds`), the same rule as every session. It refreshes without the provider. Its expiry, `endSession`, `endSessionsOfPrincipal`, `bearer/logout` and the reuse of a credential end it. An idp.global logout does not reach it, and `AuthorityObserver` refuses it with `authority_login_required` without ending it; the readme lists what an application does about that.
+  - `refreshBearerTokens` asks the provider exactly when the session stores a provider subject, as every session from a bearer login does, so provider sessions refresh as before.
+- erasing a principal's sessions: `eraseSessionsOfPrincipal(principalId)` (relyingparty)
+  - For deleting an account, after the application's own erasers and before its user record. It ends every session of the principal not revoked yet, an expired one too, as `endSession` does (`onSessionEnded` fires and the provider tokens go back), then deletes every session row of the principal, live or ended, with the login attempt a provider session came out of and, in bearer mode, its hand-offs, claimed or not, and its token generations. It does not wait for a sweep, deletes each session row last so a failed erase can be retried, and answers the counts (`IRelyingPartySessionsErasure`).
+- `onSessionEnded` names the principal of a session it revoked (relyingparty)
+  - The event is `{ sessionId, reason, revokedHere: true, principalId }` when this call revoked the session and `{ sessionId, reason, revokedHere: false }` when it was over already, so an application can end a person's other sessions on `refresh_token_refused` without keeping a table of its own. A handler that reads `sessionId`, `reason` and `revokedHere` compiles unchanged; code that builds the event itself with `revokedHere: true` adds `principalId`.
+- `onProviderSessionOpened` carries the bearer delivery (relyingparty)
+  - A bearer login's session opens with `delivery` (`IRelyingPartyBearerDelivery`: client kind, return target and the client's `state`); a cookie login's has none.
+- `createPkce()` and `claimCode(pkce, code)` on `RelyingPartyBearerClient` (browser)
+  - `createPkce()` makes a verifier and its S256 challenge. `claimCode` claims a code bound to that challenge that reached the client another way than its own login, such as a device pairing. It keeps the client's rules: one claim, never retried, under `requestTimeoutMs`, and the pair replaces the stored one under the Web Lock, ending that pair's session.
+  - A pair is claimed with once; a second call, after a failed claim as well, is `already_received` and sends nothing. A malformed verifier, a challenge that is not the verifier's S256, or a code that is not text throws before anything is sent. Neither method needs a window.
+  - In Chromium 149 the client runs in a Manifest V3 extension's service worker that imports `@idp.global/sdk/browser/bearer`. The extension needs a host permission for the relying party's origin, because the bearer routes answer CORS for popup origins only.
+- the requests of the bearer routes are exported types (relyingparty, browser)
+  - `IRelyingPartyBearerLoginQuery` (the `bearer/login` query by its parameter names), `IRelyingPartyBearerClaimRequest`, `IRelyingPartyBearerRefreshRequest` and `IRelyingPartyBearerLogoutRequest` come from the import-free contract module beside the answer types. `@idp.global/sdk/relyingparty`, `@idp.global/sdk/browser` and `@idp.global/sdk/browser/bearer` export them, and the browser client sends exactly these shapes.
+
+### Maintenance
+
+- release tooling: pnpm 12.14.0
+
 ## 2026-10-22 - 19.4.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts_browser/classes.relyingpartybearerclient.d.ts

@@ -1,5 +1,5 @@
 import { RELYING_PARTY_BEARER_MESSAGE_TYPE, type IRelyingPartyBearerTokenAnswer } from '../dist_ts_relyingparty/contract.bearer.js';
-export type { IRelyingPartyBearerErrorAnswer, IRelyingPartyBearerLogoutAnswer, IRelyingPartyBearerMessage, IRelyingPartyBearerSessionAnswer, IRelyingPartyBearerSessionInfo, IRelyingPartyBearerTokenAnswer, TRelyingPartyBearerDeliveryError, TRelyingPartyBearerErrorCode, } from '../dist_ts_relyingparty/contract.bearer.js';
+export type { IRelyingPartyBearerClaimRequest, IRelyingPartyBearerErrorAnswer, IRelyingPartyBearerLoginQuery, IRelyingPartyBearerLogoutAnswer, IRelyingPartyBearerLogoutRequest, IRelyingPartyBearerMessage, IRelyingPartyBearerRefreshRequest, IRelyingPartyBearerSessionAnswer, IRelyingPartyBearerSessionInfo, IRelyingPartyBearerTokenAnswer, TRelyingPartyBearerDeliveryError, TRelyingPartyBearerErrorCode, } from '../dist_ts_relyingparty/contract.bearer.js';
 export { RELYING_PARTY_BEARER_MESSAGE_TYPE };
 /** The client kinds a browser signs in as; native clients use `loopback` and `custom_scheme` themselves. */
 export type TRelyingPartyBearerBrowserClientKind = 'web' | 'popup';
@@ -35,6 +35,18 @@ export interface IRelyingPartyBearerTokenStorage {
         signal: AbortSignal;
     }): Promise<void>;
 }
+/**
+ * A PKCE pair (RFC 7636): the verifier the client keeps and the S256
+ * challenge it hands out. `codeVerifier` is the secret that makes a code
+ * worth anything; keep it like a pending login, never in a URL, a log or a
+ * message.
+ */
+export interface IRelyingPartyBearerPkce {
+    /** 43 characters from 32 random bytes */
+    codeVerifier: string;
+    /** BASE64URL(SHA-256(codeVerifier)) */
+    codeChallenge: string;
+}
 /**
  * A login on its way: what `createLogin` made and the receiver needs back.
  * A `web` login leaves the page, so the application keeps it until the
@@ -129,7 +141,7 @@ export type TRelyingPartyBearerClientErrorCode =
 'state_mismatch'
 /** the delivery carries no code; `deliveryError` says why */
  | 'login_failed'
-/** this login was received once already; a code is claimed once, never again */
+/** this login, or this PKCE pair, was received once already; a code is claimed once, never again */
  | 'already_received'
 /** the browser opened no popup */
  | 'popup_blocked'
@@ -172,7 +184,9 @@ export declare class RelyingPartyBearerClientError extends Error {
  * request or write never holds the other tabs. A login replaces the stored
  * pair and ends that pair's session. Rotation is strict at the relying
  * party: a refresh token spent once ends the session when it comes back, so
- * nothing here retries a claim or a refresh.
+ * nothing here retries a claim or a refresh. A code that reaches the client
+ * another way, such as a device pairing, is claimed through `createPkce` and
+ * `claimCode` under the same rules, without a window.
  *
  * It needs the Web Locks API and Web Crypto, both of them only in a secure
  * context, and has no fallback for either.
@@ -191,6 +205,27 @@ export declare class RelyingPartyBearerClient {
         clientKind: TRelyingPartyBearerBrowserClientKind;
         returnTarget: string;
     }): Promise<IRelyingPartyBearerClientLogin>;
+    /**
+     * A fresh PKCE pair: a verifier from 32 random bytes and its S256
+     * challenge. For a code the client does not receive through its own login,
+     * such as one the application delivers to a device it pairs: the challenge
+     * goes to the application, and `claimCode` claims the code with the pair.
+     * Needs no window.
+     */
+    createPkce(): Promise<IRelyingPartyBearerPkce>;
+    /**
+     * Claims a hand-off code that was bound to `pkceArg`'s challenge and
+     * reached this client some other way than its own login, such as a device
+     * pairing (`openBearerHandoff` at the relying party). It is received like
+     * a login: one claim, never retried, under `requestTimeoutMs`, and the
+     * claimed pair replaces the stored one under the lock, whose session is
+     * ended then (`IRelyingPartyBearerLoginResult`). A pair is claimed with
+     * once: a second call with it, after a failed claim too, is
+     * `already_received` and sends nothing. A pair that is not one (a
+     * malformed verifier, a challenge that is not its S256) or a code that is
+     * not text is refused before anything is sent. Needs no window.
+     */
+    claimCode(pkceArg: IRelyingPartyBearerPkce, codeArg: string): Promise<IRelyingPartyBearerLoginResult>;
     /**
      * Receives a `web` login on its return target page. The delivery leaves
      * the address first, before anything is checked, so neither a reload nor
@@ -238,6 +273,8 @@ export declare class RelyingPartyBearerClient {
     private isFresh;
     /** Takes a delivery for its login, once, claims its code and stores the pair in place of the one before. */
     private receive;
+    /** Claims a code once with its verifier and stores the pair in place of the one before. */
+    private claim;
     /**
      * Stores a claimed pair in place of the stored one and then ends the
      * session of that one with its tokens, held here, through the logout

package/dist_ts_browser/classes.relyingpartybearerclient.js

@@ -1,4 +1,4 @@
-import { RELYING_PARTY_BEARER_MESSAGE_TYPE, } from '../dist_ts_relyingparty/contract.bearer.js';
+import { isPkceVerifier, RELYING_PARTY_BEARER_MESSAGE_TYPE, } from '../dist_ts_relyingparty/contract.bearer.js';
 export { RELYING_PARTY_BEARER_MESSAGE_TYPE };
 export class RelyingPartyBearerClientError extends Error {
     code;
@@ -99,7 +99,9 @@ const tokenAnswerOf = (answerArg) => {
  * request or write never holds the other tabs. A login replaces the stored
  * pair and ends that pair's session. Rotation is strict at the relying
  * party: a refresh token spent once ends the session when it comes back, so
- * nothing here retries a claim or a refresh.
+ * nothing here retries a claim or a refresh. A code that reaches the client
+ * another way, such as a device pairing, is claimed through `createPkce` and
+ * `claimCode` under the same rules, without a window.
  *
  * It needs the Web Locks API and Web Crypto, both of them only in a secure
  * context, and has no fallback for either.
@@ -117,6 +119,8 @@ export class RelyingPartyBearerClient {
     #now;
     /** the states of the logins received here; a login is received once */
     #receivedStates = new Set();
+    /** the challenges of the pairs `claimCode` claimed with here; a pair is claimed with once */
+    #claimedChallenges = new Set();
     constructor(optionsArg) {
         const origin = optionsArg?.origin;
         let parsedOrigin = null;
@@ -190,16 +194,60 @@ export class RelyingPartyBearerClient {
         if (!isText(returnTarget)) {
             throw new Error('returnTarget must name the configured return target');
         }
-        const codeVerifier = randomBase64Url();
+        const { codeVerifier, codeChallenge } = await this.createPkce();
         const state = randomBase64Url();
+        const query = {
+            client_kind: clientKind,
+            return_target: returnTarget,
+            code_challenge: codeChallenge,
+            code_challenge_method: 'S256',
+            state,
+        };
         const url = new URL(this.#paths.login);
-        url.searchParams.set('client_kind', clientKind);
-        url.searchParams.set('return_target', returnTarget);
-        url.searchParams.set('code_challenge', await pkceChallengeOf(codeVerifier));
-        url.searchParams.set('code_challenge_method', 'S256');
-        url.searchParams.set('state', state);
+        for (const [name, value] of Object.entries(query)) {
+            url.searchParams.set(name, value);
+        }
         return { clientKind, returnTarget, state, codeVerifier, url: url.href };
     }
+    /**
+     * A fresh PKCE pair: a verifier from 32 random bytes and its S256
+     * challenge. For a code the client does not receive through its own login,
+     * such as one the application delivers to a device it pairs: the challenge
+     * goes to the application, and `claimCode` claims the code with the pair.
+     * Needs no window.
+     */
+    async createPkce() {
+        const codeVerifier = randomBase64Url();
+        return { codeVerifier, codeChallenge: await pkceChallengeOf(codeVerifier) };
+    }
+    /**
+     * Claims a hand-off code that was bound to `pkceArg`'s challenge and
+     * reached this client some other way than its own login, such as a device
+     * pairing (`openBearerHandoff` at the relying party). It is received like
+     * a login: one claim, never retried, under `requestTimeoutMs`, and the
+     * claimed pair replaces the stored one under the lock, whose session is
+     * ended then (`IRelyingPartyBearerLoginResult`). A pair is claimed with
+     * once: a second call with it, after a failed claim too, is
+     * `already_received` and sends nothing. A pair that is not one (a
+     * malformed verifier, a challenge that is not its S256) or a code that is
+     * not text is refused before anything is sent. Needs no window.
+     */
+    async claimCode(pkceArg, codeArg) {
+        const codeVerifier = pkceArg?.codeVerifier;
+        const codeChallenge = pkceArg?.codeChallenge;
+        if (!isPkceVerifier(codeVerifier) || typeof codeChallenge !== 'string' || codeChallenge !== await pkceChallengeOf(codeVerifier)) {
+            throw new Error('claimCode needs a PKCE pair: a verifier and its S256 challenge, as createPkce makes them');
+        }
+        if (!isText(codeArg)) {
+            throw new Error('claimCode needs the hand-off code as text');
+        }
+        if (this.#claimedChallenges.has(codeChallenge)) {
+            throw new RelyingPartyBearerClientError('already_received');
+        }
+        // taken before the claim is sent: a failed claim uses the pair up too
+        this.#claimedChallenges.add(codeChallenge);
+        return this.claim(codeArg, codeVerifier);
+    }
     /**
      * Receives a `web` login on its return target page. The delivery leaves
      * the address first, before anything is checked, so neither a reload nor
@@ -349,8 +397,13 @@ export class RelyingPartyBearerClient {
         if (!isText(codeArg)) {
             throw new RelyingPartyBearerClientError('unexpected_answer');
         }
+        return this.claim(codeArg, loginArg.codeVerifier);
+    }
+    /** Claims a code once with its verifier and stores the pair in place of the one before. */
+    async claim(codeArg, codeVerifierArg) {
+        const body = { code: codeArg, codeVerifier: codeVerifierArg };
         // the claim touches no stored pair, so it holds no lock, only its own deadline; a failed one leaves the stored pair as it was
-        const answer = tokenAnswerOf(await this.withDeadline((signalArg) => this.post(this.#paths.claim, { code: codeArg, codeVerifier: loginArg.codeVerifier }, {}, signalArg)));
+        const answer = tokenAnswerOf(await this.withDeadline((signalArg) => this.post(this.#paths.claim, body, {}, signalArg)));
         if (!answer) {
             throw new RelyingPartyBearerClientError('unexpected_answer', { status: 200 });
         }
@@ -475,8 +528,9 @@ export class RelyingPartyBearerClient {
                 return current;
             }
             let answer;
+            const body = { refreshToken: current.refreshToken };
             try {
-                answer = tokenAnswerOf(await this.post(this.#paths.refresh, { refreshToken: current.refreshToken }, {}, signalArg));
+                answer = tokenAnswerOf(await this.post(this.#paths.refresh, body, {}, signalArg));
             }
             catch (error) {
                 if (error instanceof RelyingPartyBearerClientError && error.answerError === 'invalid_bearer_grant') {
@@ -498,7 +552,8 @@ export class RelyingPartyBearerClient {
     }
     /** Ends the session of a pair through the logout route and answers whether that ended a live one. */
     async endSessionOf(pairArg, signalArg) {
-        const answer = await this.post(this.#paths.logout, { refreshToken: pairArg.refreshToken }, { authorization: `Bearer ${pairArg.accessToken}` }, signalArg);
+        const body = { refreshToken: pairArg.refreshToken };
+        const answer = await this.post(this.#paths.logout, body, { authorization: `Bearer ${pairArg.accessToken}` }, signalArg);
         if (!isRecord(answer) || typeof answer.endedLiveSession !== 'boolean') {
             throw new RelyingPartyBearerClientError('unexpected_answer', { status: 200 });
         }
@@ -588,4 +643,4 @@ export class RelyingPartyBearerClient {
         return answer;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.relyingpartybearerclient.js","sourceRoot":"","sources":["../../ts_browser/classes.relyingpartybearerclient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,GAGlC,MAAM,uCAAuC,CAAC;AAY/C,OAAO,EAAE,iCAAiC,EAAE,CAAC;AAwJ7C,MAAM,OAAO,6BAA8B,SAAQ,KAAK;IAQpC,IAAI;IAPN,MAAM,CAAU;IAChC,8EAA8E;IAC9D,WAAW,CAAU;IACrC,0EAA0E;IAC1D,aAAa,CAAU;IAEvC,YACkB,IAAwC,EACxD,UAAU,GAAuF,EAAE;QAEnG,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;oBAHtE,IAAI;QAIpB,IAAI,CAAC,IAAI,GAAG,+BAA+B,CAAC;QAC5C,IAAI,UAAU,CAAC,MAAM,KAAK,SAAS;YAAE,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;QACrE,IAAI,UAAU,CAAC,WAAW,KAAK,SAAS;YAAE,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;QACpF,IAAI,UAAU,CAAC,aAAa,KAAK,SAAS;YAAE,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;IAC5F,CAAC;CACF;AAED,MAAM,yBAAyB,GAAG,QAAQ,CAAC;AAC3C,MAAM,uBAAuB,GAAG,MAAM,CAAC;AACvC,MAAM,0BAA0B,GAAG,MAAM,CAAC;AAC1C,2FAA2F;AAC3F,MAAM,sBAAsB,GAAG,OAAO,CAAC;AACvC,0FAA0F;AAC1F,MAAM,wBAAwB,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;AACjD,MAAM,sBAAsB,GAAG,4BAA4B,CAAC;AAC5D,MAAM,oBAAoB,GAAG,GAAG,CAAC;AACjC,gGAAgG;AAChG,MAAM,qBAAqB,GAAG,KAAK,CAAC;AACpC,0EAA0E;AAC1E,MAAM,YAAY,GAAG,EAAE,CAAC;AACxB,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAU,CAAC;AAE5D,MAAM,SAAS,GAAG,CAAC,QAAoB,EAAU,EAAE;IACjD,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,MAAM,IAAI,IAAI,QAAQ;QAAE,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACjE,OAAO,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AAC/F,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,GAAW,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;AAEjH,6EAA6E;AAC7E,MAAM,eAAe,GAAG,KAAK,EAAE,WAAmB,EAAmB,EAAE,CACrE,SAAS,CAAC,IAAI,UAAU,CAAC,MAAM,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AAErH,MAAM,QAAQ,GAAG,CAAC,QAAiB,EAAuC,EAAE,CAC1E,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEhF,MAAM,MAAM,GAAG,CAAC,QAAiB,EAAsB,EAAE,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;AAE9G,MAAM,MAAM,GAAG,CAAC,QAAiB,EAAsB,EAAE,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AAEpH,uGAAuG;AACvG,MAAM,MAAM,GAAG,CAAC,SAAsB,EAAQ,EAAE;IAC9C,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;QACtB,MAAM,IAAI,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IAC5D,CAAC;AACH,CAAC,CAAC;AAEF,kFAAkF;AAClF,MAAM,WAAW,GAAG,CAAC,SAA0B,EAAE,OAAe,EAAsB,EAAE;IACtF,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACzC,OAAO,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACrD,CAAC,CAAC;AAEF,qEAAqE;AACrE,MAAM,aAAa,GAAG,CAAC,SAAkB,EAAyC,EAAE;IAClF,IACE,CAAC,QAAQ,CAAC,SAAS,CAAC;WACjB,SAAS,CAAC,SAAS,KAAK,QAAQ;WAChC,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC;WAC9B,CAAC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC;WAC/B,CAAC,MAAM,CAAC,SAAS,CAAC,oBAAoB,CAAC;WACvC,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC;WAC5B,SAAS,CAAC,SAAS,IAAI,CAAC;WACxB,CAAC,MAAM,CAAC,SAAS,CAAC,qBAAqB,CAAC;WACxC,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC;WAC5B,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC;WACpC,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,WAAW,CAAC;WACtC,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,EACvC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO;QACL,SAAS,EAAE,QAAQ;QACnB,WAAW,EAAE,SAAS,CAAC,WAAW;QAClC,oBAAoB,EAAE,SAAS,CAAC,oBAAoB;QACpD,SAAS,EAAE,SAAS,CAAC,SAAS;QAC9B,YAAY,EAAE,SAAS,CAAC,YAAY;QACpC,qBAAqB,EAAE,SAAS,CAAC,qBAAqB;QACtD,OAAO,EAAE;YACP,SAAS,EAAE,SAAS,CAAC,OAAO,CAAC,SAAS;YACtC,WAAW,EAAE,SAAS,CAAC,OAAO,CAAC,WAAW;YAC1C,SAAS,EAAE,SAAS,CAAC,OAAO,CAAC,SAAS;SACvC;KACF,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,wBAAwB;IACnB,MAAM,CAAS;IACtB,MAAM,CAAoE;IAC1E,QAAQ,CAAkC;IAC1C,SAAS,CAAS;IAClB,cAAc,CAAS;IACvB,iBAAiB,CAAS;IAC1B,MAAM,CAAc;IACpB,MAAM,CAA0B;IAChC,OAAO,CAA8C;IACrD,IAAI,CAAe;IAC5B,uEAAuE;IAC9D,eAAe,GAAG,IAAI,GAAG,EAAU,CAAC;IAE7C,YAAY,UAA4C;QACtD,MAAM,MAAM,GAAG,UAAU,EAAE,MAAM,CAAC;QAClC,IAAI,YAAY,GAAe,IAAI,CAAC;QACpC,IAAI,CAAC;YACH,YAAY,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACrE,CAAC;QAAC,MAAM,CAAC;YACP,YAAY,GAAG,IAAI,CAAC;QACtB,CAAC;QACD,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC,MAAM,KAAK,MAAM,IAAI,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC5G,MAAM,IAAI,KAAK,CAAC,+EAA+E,CAAC,CAAC;QACnG,CAAC;QACD,MAAM,MAAM,GAAG,UAAU,CAAC,eAAe,IAAI,yBAAyB,CAAC;QACvE,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,8BAA8B,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/E,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;QACD,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QACnC,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,CAAC,GAAG,KAAK,UAAU,IAAI,OAAO,OAAO,CAAC,GAAG,KAAK,UAAU,IAAI,OAAO,OAAO,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;YAC9H,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAC1D,CAAC;QACD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,IAAI,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC;QAC9D,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;YAClD,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;QACxF,CAAC;QACD,IAAI,OAAO,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,UAAU,IAAI,OAAO,UAAU,CAAC,MAAM,CAAC,eAAe,KAAK,UAAU,EAAE,CAAC;YACvH,MAAM,IAAI,KAAK,CAAC,4GAA4G,CAAC,CAAC;QAChI,CAAC;QACD,MAAM,aAAa,GAAG,UAAU,CAAC,KAAK,IAAI,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QAC7E,IAAI,OAAO,aAAa,KAAK,UAAU,EAAE,CAAC;YACxC,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAC1D,CAAC;QACD,MAAM,aAAa,GAAG,UAAU,CAAC,aAAa,IAAI,uBAAuB,CAAC;QAC1E,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,aAAa,GAAG,CAAC,EAAE,CAAC;YAC1D,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC1E,CAAC;QACD,oFAAoF;QACpF,MAAM,gBAAgB,GAAG,UAAU,CAAC,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC,UAAU,CAAC,gBAAgB,CAAC;QAC9H,IACE,OAAO,gBAAgB,KAAK,QAAQ;eACjC,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAC;eAClC,gBAAgB,IAAI,CAAC;eACrB,gBAAgB,GAAG,sBAAsB,EAC5C,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,oDAAoD,sBAAsB,eAAe,CAAC,CAAC;QAC7G,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG;YACZ,KAAK,EAAE,GAAG,MAAM,GAAG,MAAM,cAAc;YACvC,KAAK,EAAE,GAAG,MAAM,GAAG,MAAM,cAAc;YACvC,OAAO,EAAE,GAAG,MAAM,GAAG,MAAM,gBAAgB;YAC3C,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,eAAe;SAC1C,CAAC;QACF,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;QACxB,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,QAAQ,IAAI,yCAAyC,MAAM,EAAE,CAAC;QAC1F,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;QACpC,IAAI,CAAC,iBAAiB,GAAG,gBAAgB,CAAC;QAC1C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC;QAC5B,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,MAAM,IAAK,UAA2D,CAAC,MAAM,CAAC;QACxG,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;IACzC,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,WAAW,CAAC,UAGxB;QACC,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,UAAU,IAAK,EAAwB,CAAC;QAC7E,IAAI,UAAU,KAAK,KAAK,IAAI,UAAU,KAAK,OAAO,EAAE,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QACD,MAAM,YAAY,GAAG,eAAe,EAAE,CAAC;QACvC,MAAM,KAAK,GAAG,eAAe,EAAE,CAAC;QAChC,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;QAChD,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC;QACpD,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC;QAC5E,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,uBAAuB,EAAE,MAAM,CAAC,CAAC;QACtD,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACrC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC;IAC1E,CAAC;IAED;;;;;;;;OAQG;IACI,KAAK,CAAC,qBAAqB,CAChC,QAA2D;QAE3D,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACpC,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;YACtE,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,SAAS,GAAG,GAAG,CAAC,YAAY,CAAC;QACnC,MAAM,IAAI,GAAG,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAC5C,MAAM,KAAK,GAAG,WAAW,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC9C,MAAM,KAAK,GAAG,WAAW,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC9C,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC/B,KAAK,MAAM,IAAI,IAAI,eAAe,EAAE,CAAC;YACnC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;QACD,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,EAAE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/F,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,KAAK,KAAK,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,QAAQ,CAAC,KAAK,EAAE,CAAC;YAClG,MAAM,IAAI,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;QAC5D,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;OAOG;IACI,cAAc,CACnB,QAAwC,EACxC,UAAU,GAAoC,EAAE;QAEhD,IAAI,MAAuC,CAAC;QAC5C,IAAI,CAAC;YACH,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YAC9B,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,UAAU,KAAK,OAAO,EAAE,CAAC;gBACjD,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;YACxD,CAAC;YACD,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC7C,MAAM,IAAI,6BAA6B,CAAC,kBAAkB,CAAC,CAAC;YAC9D,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QACD,IAAI,KAAsC,CAAC;QAC3C,IAAI,CAAC;YACH,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,UAAU,CAAC,cAAc,IAAI,sBAAsB,CAAC,CAAC;QACnG,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;QACD,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,6BAA6B,CAAC,eAAe,CAAC,CAAC,CAAC;QAC5E,CAAC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IAChE,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,WAAW;QACtB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QACzC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACzB,OAAO,MAAM,CAAC,WAAW,CAAC;QAC5B,CAAC;QACD,OAAO,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC,EAAE,WAAW,IAAI,IAAI,CAAC;IAC7E,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,OAAO,CAAC,sBAA+B;QAClD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QACzC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,sBAAsB,IAAI,IAAI,CAAC,CAAC;IAC1E,CAAC;IAED;;;;;;;;;OASG;IACI,KAAK,CAAC,MAAM;QACjB,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,UAAU,GAAG,CAAC,QAAiB,EAAE,EAAE,CAAC,IAAI,6BAA6B,CAAC,qBAAqB,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;QACxH,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;YACrF,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;YAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,OAAO,KAAK,CAAC;YACf,CAAC;YACD,MAAM,CAAC,SAAS,CAAC,CAAC;YAClB,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;YACjD,OAAO,GAAG,IAAI,CAAC;YACf,IAAI,CAAC;gBACH,OAAO,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;YACrD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,UAAU,CAAC,KAAK,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC,EAAE,GAAG,EAAE;YACN,sFAAsF;YACtF,MAAM,OAAO,GAAG,IAAI,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;YACpE,MAAM,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QAChD,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IAEO,aAAa;QACnB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;QACnF,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAEO,OAAO,CAAC,SAA0C;QACxD,MAAM,UAAU,GAAG,SAAS,CAAC,SAAS,GAAG,KAAK,CAAC;QAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,EAAE,UAAU,GAAG,CAAC,CAAC,CAAC;QAC7D,OAAO,IAAI,CAAC,IAAI,EAAE,GAAG,SAAS,CAAC,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;IAClE,CAAC;IAED,4GAA4G;IACpG,KAAK,CAAC,OAAO,CACnB,QAAwC,EACxC,OAAgB,EAChB,QAAiB;QAEjB,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,6BAA6B,CAAC,kBAAkB,CAAC,CAAC;QAC9D,CAAC;QACD,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,MAAM,IAAI,6BAA6B,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,mBAAmB,EAAE;gBACxH,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACzD,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;YACrB,MAAM,IAAI,6BAA6B,CAAC,mBAAmB,CAAC,CAAC;QAC/D,CAAC;QACD,8HAA8H;QAC9H,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,CAAC,SAAS,EAAE,EAAE,CACjE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,CAAC,YAAY,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;QACxG,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,6BAA6B,CAAC,mBAAmB,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;QAChF,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CAAC,EAAE,GAAG,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;OAOG;IACK,WAAW,CAAC,SAA0C;QAC5D,0FAA0F;QAC1F,IAAI,UAAU,GAA0C,IAAI,CAAC;QAC7D,MAAM,UAAU,GAAG,CAAC,QAAiB,EAAkC,EAAE,CAAC,CAAC;YACzE,MAAM,EAAE,SAAS;YACjB,eAAe,EAAE,8BAA8B;YAC/C,oBAAoB,EAAE,QAAQ,YAAY,6BAA6B;gBACrE,CAAC,CAAC,QAAQ;gBACV,CAAC,CAAC,IAAI,6BAA6B,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;SAChF,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAiC,KAAK,EAAE,SAAS,EAAE,EAAE;YACrH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;YAC3C,MAAM,CAAC,SAAS,CAAC,CAAC;YAClB,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;YAC1D,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,qBAAqB,EAAE,CAAC;YACvE,CAAC;YACD,IAAI,QAAQ,CAAC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;gBAC/D,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC;YAChE,CAAC;YACD,UAAU,GAAG,UAAU,CAAC,IAAI,6BAA6B,CAAC,gBAAgB,CAAC,CAAC,CAAC;YAC7E,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;gBAC7C,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,wBAAwB,EAAE,CAAC;YAC1E,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;YAC3B,CAAC;QACH,CAAC,EAAE,GAAG,EAAE;YACN,qFAAqF;YACrF,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,MAAM,IAAI,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;YAC5D,CAAC;YACD,OAAO,UAAU,CAAC;QACpB,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IAEO,YAAY,CAClB,SAA0C,EAC1C,QAAkC,EAClC,QAAwC,EACxC,UAA2C;QAE3C,OAAO,IAAI,OAAO,CAAiC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrE,MAAM,QAAQ,GAAsB,EAAE,CAAC;YACvC,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,MAAM,MAAM,GAAG,CAAC,SAAqB,EAAE,EAAE;gBACvC,IAAI,OAAO,EAAE,CAAC;oBACZ,OAAO;gBACT,CAAC;gBACD,OAAO,GAAG,IAAI,CAAC;gBACf,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;oBAC/B,OAAO,EAAE,CAAC;gBACZ,CAAC;gBACD,SAAS,EAAE,CAAC;YACd,CAAC,CAAC;YACF,MAAM,IAAI,GAAG,CAAC,QAAiB,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YAEnE,MAAM,SAAS,GAAG,CAAC,QAAyC,EAAE,EAAE;gBAC9D,MAAM,IAAI,GAAY,QAAQ,EAAE,IAAI,CAAC;gBACrC,IACE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC,MAAM;uBAC7B,QAAQ,CAAC,MAAM,KAAK,QAAQ;uBAC5B,CAAC,QAAQ,CAAC,IAAI,CAAC;uBACf,IAAI,CAAC,IAAI,KAAK,iCAAiC;uBAC/C,IAAI,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK,EAChC,CAAC;oBACD,OAAO;gBACT,CAAC;gBACD,MAAM,CAAC,GAAG,EAAE;oBACV,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;gBACtE,CAAC,CAAC,CAAC;YACL,CAAC,CAAC;YACF,SAAS,CAAC,gBAAgB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;YACjD,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,mBAAmB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;YAEzE,MAAM,OAAO,GAAG,UAAU,CACxB,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,6BAA6B,CAAC,eAAe,CAAC,CAAC,EAC9D,UAAU,CAAC,SAAS,IAAI,wBAAwB,CACjD,CAAC;YACF,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;YAC3C,IAAI,WAAsD,CAAC;YAC3D,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE;gBAClC,IAAI,QAAQ,CAAC,MAAM,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;oBACjD,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,6BAA6B,CAAC,cAAc,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC;gBACjH,CAAC;YACH,CAAC,EAAE,oBAAoB,CAAC,CAAC;YACzB,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE;gBACjB,aAAa,CAAC,UAAU,CAAC,CAAC;gBAC1B,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;oBAC9B,YAAY,CAAC,WAAW,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;YACjC,IAAI,MAAM,EAAE,CAAC;gBACX,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;oBACpB,OAAO;gBACT,CAAC;gBACD,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBAC1C,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;gBAC1D,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;YACpE,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACK,MAAM,CACZ,mBAA2B,EAC3B,sBAAqC;QAErC,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;YACrF,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;YAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,OAAO,IAAI,CAAC;YACd,CAAC;YACD,IACE,OAAO,CAAC,YAAY,KAAK,mBAAmB;mBACzC,CAAC,sBAAsB,KAAK,IAAI,IAAI,OAAO,CAAC,WAAW,KAAK,sBAAsB,CAAC,EACtF,CAAC;gBACD,OAAO,OAAO,CAAC;YACjB,CAAC;YACD,IAAI,MAA6C,CAAC;YAClD,IAAI,CAAC;gBACH,MAAM,GAAG,aAAa,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC;YACtH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,KAAK,YAAY,6BAA6B,IAAI,KAAK,CAAC,WAAW,KAAK,sBAAsB,EAAE,CAAC;oBACnG,wDAAwD;oBACxD,MAAM,CAAC,SAAS,CAAC,CAAC;oBAClB,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;oBACjD,OAAO,IAAI,CAAC;gBACd,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;YACD,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,IAAI,6BAA6B,CAAC,mBAAmB,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;YAChF,CAAC;YACD,MAAM,MAAM,GAAoC,EAAE,GAAG,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;YACvF,MAAM,CAAC,SAAS,CAAC,CAAC;YAClB,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;YACvD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IAED,qGAAqG;IAC7F,KAAK,CAAC,YAAY,CAAC,OAAwC,EAAE,SAAsB;QACzF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAC5B,IAAI,CAAC,MAAM,CAAC,MAAM,EAClB,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,EAAE,EACtC,EAAE,aAAa,EAAE,UAAU,OAAO,CAAC,WAAW,EAAE,EAAE,EAClD,SAAS,CACV,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,OAAO,MAAM,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACtE,MAAM,IAAI,6BAA6B,CAAC,mBAAmB,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;QAChF,CAAC;QACD,OAAQ,MAAqD,CAAC,gBAAgB,CAAC;IACjF,CAAC;IAED;;;;;;OAMG;IACK,KAAK,CAAC,YAAY,CACxB,UAAkD,EAClD,aAAa,GAAY,GAAG,EAAE;QAC5B,MAAM,IAAI,6BAA6B,CAAC,gBAAgB,CAAC,CAAC;IAC5D,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,IAAI,KAAgD,CAAC;QACrD,MAAM,QAAQ,GAAG,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAClD,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;gBACtB,UAAU,CAAC,KAAK,CAAC,IAAI,6BAA6B,CAAC,gBAAgB,CAAC,CAAC,CAAC;gBACtE,IAAI,CAAC;oBACH,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;gBAC3B,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,KAAK,CAAC,CAAC;gBAChB,CAAC;YACH,CAAC,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,MAAM,OAAO,GAAG,UAAU,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAC9C,qGAAqG;QACrG,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC/B,IAAI,CAAC;YACH,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;QACjD,CAAC;gBAAS,CAAC;YACT,YAAY,CAAC,KAAK,CAAC,CAAC;QACtB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,IAAI,CAChB,MAAc,EACd,OAA+B,EAC/B,UAAU,GAA2B,EAAE,EACvC,SAAuB;QAEvB,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,CAAC,SAAS,CAAC,CAAC;QACpB,CAAC;QACD,IAAI,QAAkB,CAAC;QACvB,IAAI,CAAC;YACH,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;gBACnC,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE,GAAG,UAAU,EAAE;gBAC9D,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;gBAC7B,WAAW,EAAE,MAAM;gBACnB,KAAK,EAAE,UAAU;gBACjB,QAAQ,EAAE,OAAO;gBACjB,cAAc,EAAE,aAAa;gBAC7B,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAC5C,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,6BAA6B,CAAC,gBAAgB,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;QAC9E,CAAC;QACD,IAAI,MAAe,CAAC;QACpB,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QACjC,CAAC;QAAC,MAAM,CAAC;YACP,2DAA2D;YAC3D,MAAM,GAAG,SAAS,CAAC;YACnB,IAAI,SAAS,EAAE,CAAC;gBACd,MAAM,CAAC,SAAS,CAAC,CAAC;YACpB,CAAC;YACD,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;gBAC5B,MAAM,IAAI,6BAA6B,CAAC,mBAAmB,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;YAChF,CAAC;QACH,CAAC;QACD,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,CAAC,SAAS,CAAC,CAAC;QACpB,CAAC;QACD,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;YAC5B,MAAM,IAAI,6BAA6B,CAAC,iBAAiB,EAAE;gBACzD,MAAM,EAAE,QAAQ,CAAC,MAAM;gBACvB,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACnF,CAAC,CAAC;QACL,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.relyingpartybearerclient.js","sourceRoot":"","sources":["../../ts_browser/classes.relyingpartybearerclient.ts"],"names":[],"mappings":"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"}

package/dist_ts_relyingparty/classes.errors.d.ts

@@ -8,6 +8,8 @@ export type TRelyingPartyErrorCode = 'login_method_unavailable' | 'invalid_login
  | 'invalid_bearer_handoff'
 /** a refresh token that is unknown, rotated, expired, or of a session that is over */
  | 'invalid_bearer_grant'
+/** `openBearerHandoff` named an opener that is no live provider login: unknown, ended, expired, of an inactive principal, or without a provider login of its own */
+ | 'invalid_handoff_opener'
 /** a `sessionsOfPrincipal` cursor that no page of it answered */
  | 'invalid_sessions_cursor';
 /** A request the login flow refuses; the code is safe to answer, the browser learns nothing more. */

package/dist_ts_relyingparty/classes.errors.js

@@ -8,6 +8,7 @@ const RELYING_PARTY_ERROR_STATUS = {
     return_target_not_allowed: 400,
     invalid_bearer_handoff: 400,
     invalid_bearer_grant: 400,
+    invalid_handoff_opener: 400,
     invalid_sessions_cursor: 400,
 };
 /** A request the login flow refuses; the code is safe to answer, the browser learns nothing more. */
@@ -71,4 +72,4 @@ export class RelyingPartyDatabaseUnavailableError extends Error {
         this.name = 'RelyingPartyDatabaseUnavailableError';
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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;