@idp.global/sdk 19.3.0 → 19.5.0

package/dist_ts_browser/classes.relyingpartybearerclient.js

@@ -0,0 +1,646 @@
+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;
+    status;
+    /** the `error` the relying party answered (`TRelyingPartyBearerErrorCode`) */
+    answerError;
+    /** the `error` a delivery carried (`TRelyingPartyBearerDeliveryError`) */
+    deliveryError;
+    constructor(code, detailsArg = {}) {
+        super(code, detailsArg.cause !== undefined ? { cause: detailsArg.cause } : undefined);
+        this.code = code;
+        this.name = 'RelyingPartyBearerClientError';
+        if (detailsArg.status !== undefined)
+            this.status = detailsArg.status;
+        if (detailsArg.answerError !== undefined)
+            this.answerError = detailsArg.answerError;
+        if (detailsArg.deliveryError !== undefined)
+            this.deliveryError = detailsArg.deliveryError;
+    }
+}
+const DEFAULT_LOGIN_PATH_PREFIX = '/auth/';
+const DEFAULT_REFRESH_SKEW_MS = 60_000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+/** Every tab of the origin waits on the lock while a section runs: two minutes at most. */
+const MAX_REQUEST_TIMEOUT_MS = 120_000;
+/** The life of a login attempt at the relying party (`LOGIN_ATTEMPT_MAX_AGE_SECONDS`). */
+const DEFAULT_POPUP_TIMEOUT_MS = 10 * 60 * 1_000;
+const DEFAULT_POPUP_FEATURES = 'popup,width=480,height=720';
+const POPUP_CLOSED_POLL_MS = 500;
+/** A popup posts and closes at once; its message can arrive after the opener sees it closed. */
+const POPUP_CLOSED_GRACE_MS = 1_000;
+/** 32 random bytes: a 43-character verifier and state (RFC 7636 §4.1). */
+const RANDOM_BYTES = 32;
+const DELIVERY_PARAMS = ['code', 'error', 'state'];
+const base64Url = (bytesArg) => {
+    let binary = '';
+    for (const byte of bytesArg)
+        binary += String.fromCharCode(byte);
+    return globalThis.btoa(binary).replace(/\+/gu, '-').replace(/\//gu, '_').replace(/=+$/u, '');
+};
+const randomBase64Url = () => base64Url(globalThis.crypto.getRandomValues(new Uint8Array(RANDOM_BYTES)));
+/** The S256 challenge of a verifier: BASE64URL(SHA-256(ASCII(verifier))). */
+const pkceChallengeOf = async (verifierArg) => base64Url(new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(verifierArg))));
+const isRecord = (valueArg) => typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+const isText = (valueArg) => typeof valueArg === 'string' && valueArg.length > 0;
+const isTime = (valueArg) => typeof valueArg === 'number' && Number.isFinite(valueArg);
+/** Throws `request_failed` once a section's deadline has fired: nothing is sent or written past it. */
+const inTime = (signalArg) => {
+    if (signalArg.aborted) {
+        throw new RelyingPartyBearerClientError('request_failed');
+    }
+};
+/** The one value of a parameter, or `undefined` when it is absent or repeated. */
+const singleParam = (paramsArg, nameArg) => {
+    const values = paramsArg.getAll(nameArg);
+    return values.length === 1 ? values[0] : undefined;
+};
+/** A token answer exactly as the bearer contract says, or `null`. */
+const tokenAnswerOf = (answerArg) => {
+    if (!isRecord(answerArg)
+        || answerArg.tokenType !== 'Bearer'
+        || !isText(answerArg.accessToken)
+        || !isText(answerArg.refreshToken)
+        || !isTime(answerArg.accessTokenExpiresAt)
+        || !isTime(answerArg.expiresIn)
+        || answerArg.expiresIn <= 0
+        || !isTime(answerArg.refreshTokenExpiresAt)
+        || !isRecord(answerArg.session)
+        || !isText(answerArg.session.sessionId)
+        || !isText(answerArg.session.principalId)
+        || !isTime(answerArg.session.expiresAt)) {
+        return null;
+    }
+    return {
+        tokenType: 'Bearer',
+        accessToken: answerArg.accessToken,
+        accessTokenExpiresAt: answerArg.accessTokenExpiresAt,
+        expiresIn: answerArg.expiresIn,
+        refreshToken: answerArg.refreshToken,
+        refreshTokenExpiresAt: answerArg.refreshTokenExpiresAt,
+        session: {
+            sessionId: answerArg.session.sessionId,
+            principalId: answerArg.session.principalId,
+            expiresAt: answerArg.session.expiresAt,
+        },
+    };
+};
+/**
+ * The browser side of bearer hand-off (`@idp.global/sdk/relyingparty`
+ * `bearer`): it starts a `web` or `popup` login with PKCE and a state,
+ * receives the delivery, claims the code once and keeps the token pair in
+ * the application's storage. Every refresh, logout and store of a claimed
+ * pair holds one Web Lock, so the tabs of an origin rotate the pair one at a
+ * time: inside the lock the pair is read from storage again, a pair another
+ * tab rotated is used as it is, and a rotated pair is stored before the lock
+ * is released and before its access token is handed out. Each claim and
+ * each section that holds the lock ends by `requestTimeoutMs`, so a hanging
+ * 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. 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.
+ */
+export class RelyingPartyBearerClient {
+    origin;
+    #paths;
+    #storage;
+    #lockName;
+    #refreshSkewMs;
+    #requestTimeoutMs;
+    #locks;
+    #fetch;
+    #window;
+    #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;
+        try {
+            parsedOrigin = typeof origin === 'string' ? new URL(origin) : null;
+        }
+        catch {
+            parsedOrigin = null;
+        }
+        if (!parsedOrigin || parsedOrigin.origin !== origin || !['https:', 'http:'].includes(parsedOrigin.protocol)) {
+            throw new Error('origin must be the relying party\'s exact origin, such as https://app.example');
+        }
+        const prefix = optionsArg.loginPathPrefix ?? DEFAULT_LOGIN_PATH_PREFIX;
+        if (typeof prefix !== 'string' || !/^\/(?:[A-Za-z0-9._~-]+\/)*$/u.test(prefix)) {
+            throw new Error('loginPathPrefix must be a path that starts and ends with /');
+        }
+        const storage = optionsArg.storage;
+        if (!storage || typeof storage.get !== 'function' || typeof storage.set !== 'function' || typeof storage.clear !== 'function') {
+            throw new Error('storage must have get, set and clear');
+        }
+        const locks = optionsArg.locks ?? globalThis.navigator?.locks;
+        if (!locks || typeof locks.request !== 'function') {
+            throw new Error('RelyingPartyBearerClient needs the Web Locks API (navigator.locks)');
+        }
+        if (typeof globalThis.crypto?.subtle?.digest !== 'function' || typeof globalThis.crypto.getRandomValues !== 'function') {
+            throw new Error('RelyingPartyBearerClient needs Web Crypto (crypto.subtle), which a browser offers only in a secure context');
+        }
+        const fetchFunction = optionsArg.fetch ?? globalThis.fetch?.bind(globalThis);
+        if (typeof fetchFunction !== 'function') {
+            throw new Error('RelyingPartyBearerClient needs fetch');
+        }
+        const refreshSkewMs = optionsArg.refreshSkewMs ?? DEFAULT_REFRESH_SKEW_MS;
+        if (!Number.isInteger(refreshSkewMs) || refreshSkewMs < 0) {
+            throw new Error('refreshSkewMs must be a whole number of milliseconds');
+        }
+        // only an absent deadline takes the default: any other value that is not one throws
+        const requestTimeoutMs = optionsArg.requestTimeoutMs === undefined ? DEFAULT_REQUEST_TIMEOUT_MS : optionsArg.requestTimeoutMs;
+        if (typeof requestTimeoutMs !== 'number'
+            || !Number.isFinite(requestTimeoutMs)
+            || requestTimeoutMs <= 0
+            || requestTimeoutMs > MAX_REQUEST_TIMEOUT_MS) {
+            throw new Error(`requestTimeoutMs must be more than 0 and at most ${MAX_REQUEST_TIMEOUT_MS} milliseconds`);
+        }
+        this.origin = origin;
+        this.#paths = {
+            login: `${origin}${prefix}bearer/login`,
+            claim: `${origin}${prefix}bearer/claim`,
+            refresh: `${origin}${prefix}bearer/refresh`,
+            logout: `${origin}${prefix}bearer/logout`,
+        };
+        this.#storage = storage;
+        this.#lockName = optionsArg.lockName ?? `idp.global/relyingparty:bearer-tokens ${origin}`;
+        this.#refreshSkewMs = refreshSkewMs;
+        this.#requestTimeoutMs = requestTimeoutMs;
+        this.#locks = locks;
+        this.#fetch = fetchFunction;
+        this.#window = optionsArg.window ?? globalThis.window;
+        this.#now = optionsArg.now ?? Date.now;
+    }
+    /**
+     * A new login: a fresh verifier, its S256 challenge and a state, each from
+     * 32 random bytes, and the URL that starts it. Make a popup login before
+     * the click that opens it: this is async, and a browser opens a popup only
+     * within the user's gesture.
+     */
+    async createLogin(optionsArg) {
+        const { clientKind, returnTarget } = optionsArg ?? {};
+        if (clientKind !== 'web' && clientKind !== 'popup') {
+            throw new Error('a browser signs in as a web or popup client');
+        }
+        if (!isText(returnTarget)) {
+            throw new Error('returnTarget must name the configured return target');
+        }
+        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);
+        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
+     * the history holds the code. A delivery whose state is not the login's is
+     * refused unclaimed; a code is claimed once, and a failed claim is not
+     * retried. The claimed pair replaces the stored one, whose session is
+     * ended then (`IRelyingPartyBearerLoginResult`). Answers `null` on a page
+     * that holds no delivery.
+     */
+    async completeRedirectLogin(loginArg) {
+        const window = this.requireWindow();
+        const url = new URL(window.location.href);
+        if (!DELIVERY_PARAMS.some((nameArg) => url.searchParams.has(nameArg))) {
+            return null;
+        }
+        const delivered = url.searchParams;
+        const code = singleParam(delivered, 'code');
+        const error = singleParam(delivered, 'error');
+        const state = singleParam(delivered, 'state');
+        const kept = new URL(url.href);
+        for (const name of DELIVERY_PARAMS) {
+            kept.searchParams.delete(name);
+        }
+        window.history.replaceState(window.history.state, '', kept.pathname + kept.search + kept.hash);
+        if (!loginArg || loginArg.clientKind !== 'web' || state === undefined || state !== loginArg.state) {
+            throw new RelyingPartyBearerClientError('state_mismatch');
+        }
+        return this.receive(loginArg, code, error);
+    }
+    /**
+     * Opens a `popup` login and receives what its page posts: a message is
+     * taken only from the relying party's origin, from this very popup, of the
+     * bearer message type and with the login's state; any other is ignored.
+     * The popup opens before this returns, so call it in the click handler
+     * itself, with a login made beforehand. The claimed pair replaces the
+     * stored one like `completeRedirectLogin`'s.
+     */
+    openPopupLogin(loginArg, optionsArg = {}) {
+        let window;
+        try {
+            window = this.requireWindow();
+            if (!loginArg || loginArg.clientKind !== 'popup') {
+                throw new Error('openPopupLogin needs a popup login');
+            }
+            if (this.#receivedStates.has(loginArg.state)) {
+                throw new RelyingPartyBearerClientError('already_received');
+            }
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        let popup;
+        try {
+            popup = window.open(loginArg.url, '_blank', optionsArg.windowFeatures ?? DEFAULT_POPUP_FEATURES);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        if (!popup) {
+            return Promise.reject(new RelyingPartyBearerClientError('popup_blocked'));
+        }
+        return this.receivePopup(window, popup, loginArg, optionsArg);
+    }
+    /**
+     * An access token to send right now, or `null` when there is no session.
+     * One that is about to end is rotated first, by one tab for all of them.
+     */
+    async accessToken() {
+        const stored = await this.#storage.get();
+        if (!stored) {
+            return null;
+        }
+        if (this.isFresh(stored)) {
+            return stored.accessToken;
+        }
+        return (await this.rotate(stored.refreshToken, null))?.accessToken ?? null;
+    }
+    /**
+     * Rotates the pair now — after the relying party refused
+     * `rejectedAccessTokenArg`, say — unless another tab already did, and
+     * answers the pair to use: `null` once the session is over, which clears
+     * the storage. A relying party that cannot refresh right now
+     * (`authority_unavailable`) keeps the pair as it is; try again later.
+     */
+    async refresh(rejectedAccessTokenArg) {
+        const stored = await this.#storage.get();
+        if (!stored) {
+            return null;
+        }
+        return this.rotate(stored.refreshToken, rejectedAccessTokenArg ?? null);
+    }
+    /**
+     * Clears the storage and then ends the session at the relying party with
+     * the pair it held, and answers whether that ended a live session. When the
+     * relying party cannot be reached, refuses or gives no answer by
+     * `requestTimeoutMs`, the call throws `session_not_revoked` with that
+     * failure as its `cause`: this device is signed out, and the session may
+     * live on at the relying party until it expires, so tell the user they are
+     * signed out on this device only. A deadline that fires before the storage
+     * is cleared throws `request_failed`, and the pair stays.
+     */
+    async logout() {
+        let cleared = false;
+        const notRevoked = (errorArg) => new RelyingPartyBearerClientError('session_not_revoked', { cause: errorArg });
+        return this.#locks.request(this.#lockName, () => this.withDeadline(async (signalArg) => {
+            const current = await this.#storage.get();
+            if (!current) {
+                return false;
+            }
+            inTime(signalArg);
+            await this.#storage.clear({ signal: signalArg });
+            cleared = true;
+            try {
+                return await this.endSessionOf(current, signalArg);
+            }
+            catch (error) {
+                throw notRevoked(error);
+            }
+        }, () => {
+            // once the pair is cleared this device is signed out, whatever the request still does
+            const failure = new RelyingPartyBearerClientError('request_failed');
+            throw cleared ? notRevoked(failure) : failure;
+        }));
+    }
+    requireWindow() {
+        if (!this.#window) {
+            throw new Error('the login receivers of RelyingPartyBearerClient need a window');
+        }
+        return this.#window;
+    }
+    isFresh(storedArg) {
+        const lifetimeMs = storedArg.expiresIn * 1_000;
+        const skewMs = Math.min(this.#refreshSkewMs, lifetimeMs / 2);
+        return this.#now() < storedArg.receivedAt + lifetimeMs - skewMs;
+    }
+    /** Takes a delivery for its login, once, claims its code and stores the pair in place of the one before. */
+    async receive(loginArg, codeArg, errorArg) {
+        if (this.#receivedStates.has(loginArg.state)) {
+            throw new RelyingPartyBearerClientError('already_received');
+        }
+        this.#receivedStates.add(loginArg.state);
+        if (errorArg !== undefined) {
+            throw new RelyingPartyBearerClientError(isText(errorArg) && codeArg === undefined ? 'login_failed' : 'unexpected_answer', {
+                ...(isText(errorArg) ? { deliveryError: errorArg } : {}),
+            });
+        }
+        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, body, {}, signalArg)));
+        if (!answer) {
+            throw new RelyingPartyBearerClientError('unexpected_answer', { status: 200 });
+        }
+        return this.replacePair({ ...answer, receivedAt: this.#now() });
+    }
+    /**
+     * 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
+     * route. Both run under the lock a refresh holds, so no tab rotates the
+     * replaced pair meanwhile. A session that cannot be ended is the result's
+     * `previous_session_not_revoked`, neither thrown nor dropped: the new pair
+     * is stored by then.
+     */
+    replacePair(tokensArg) {
+        /** what the login answers if the deadline fires now: nothing before the pair is stored */
+        let atDeadline = null;
+        const notRevoked = (errorArg) => ({
+            tokens: tokensArg,
+            previousSession: 'previous_session_not_revoked',
+            previousSessionError: errorArg instanceof RelyingPartyBearerClientError
+                ? errorArg
+                : new RelyingPartyBearerClientError('unexpected_answer', { cause: errorArg }),
+        });
+        return this.#locks.request(this.#lockName, () => this.withDeadline(async (signalArg) => {
+            const previous = await this.#storage.get();
+            inTime(signalArg);
+            await this.#storage.set(tokensArg, { signal: signalArg });
+            if (!previous) {
+                return { tokens: tokensArg, previousSession: 'no_previous_session' };
+            }
+            if (previous.session.sessionId === tokensArg.session.sessionId) {
+                return { tokens: tokensArg, previousSession: 'same_session' };
+            }
+            atDeadline = notRevoked(new RelyingPartyBearerClientError('request_failed'));
+            try {
+                await this.endSessionOf(previous, signalArg);
+                return { tokens: tokensArg, previousSession: 'previous_session_ended' };
+            }
+            catch (error) {
+                return notRevoked(error);
+            }
+        }, () => {
+            // past its write the login stands; only the end of the previous session is cut short
+            if (!atDeadline) {
+                throw new RelyingPartyBearerClientError('request_failed');
+            }
+            return atDeadline;
+        }));
+    }
+    receivePopup(windowArg, popupArg, loginArg, optionsArg) {
+        return new Promise((resolve, reject) => {
+            const cleanups = [];
+            let settled = false;
+            const settle = (actionArg) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                for (const cleanup of cleanups) {
+                    cleanup();
+                }
+                actionArg();
+            };
+            const fail = (errorArg) => settle(() => reject(errorArg));
+            const onMessage = (eventArg) => {
+                const data = eventArg?.data;
+                if (eventArg?.origin !== this.origin
+                    || eventArg.source !== popupArg
+                    || !isRecord(data)
+                    || data.type !== RELYING_PARTY_BEARER_MESSAGE_TYPE
+                    || data.state !== loginArg.state) {
+                    return;
+                }
+                settle(() => {
+                    this.receive(loginArg, data.code, data.error).then(resolve, reject);
+                });
+            };
+            windowArg.addEventListener('message', onMessage);
+            cleanups.push(() => windowArg.removeEventListener('message', onMessage));
+            const timeout = setTimeout(() => fail(new RelyingPartyBearerClientError('popup_timeout')), optionsArg.timeoutMs ?? DEFAULT_POPUP_TIMEOUT_MS);
+            cleanups.push(() => clearTimeout(timeout));
+            let closedGrace;
+            const closedPoll = setInterval(() => {
+                if (popupArg.closed && closedGrace === undefined) {
+                    closedGrace = setTimeout(() => fail(new RelyingPartyBearerClientError('popup_closed')), POPUP_CLOSED_GRACE_MS);
+                }
+            }, POPUP_CLOSED_POLL_MS);
+            cleanups.push(() => {
+                clearInterval(closedPoll);
+                if (closedGrace !== undefined) {
+                    clearTimeout(closedGrace);
+                }
+            });
+            const signal = optionsArg.signal;
+            if (signal) {
+                if (signal.aborted) {
+                    fail(signal.reason);
+                    return;
+                }
+                const onAbort = () => fail(signal.reason);
+                signal.addEventListener('abort', onAbort, { once: true });
+                cleanups.push(() => signal.removeEventListener('abort', onAbort));
+            }
+        });
+    }
+    /**
+     * One rotation under the lock. The pair is read again inside it: one
+     * whose refresh token is no longer `seenRefreshTokenArg`, or whose access
+     * token is no longer `rejectedAccessTokenArg`, was rotated already and is
+     * used as it is. A rotated pair is stored before the lock is released. The
+     * whole section has one deadline: past it, the lock is released with
+     * `request_failed` and an answer that still arrives is dropped unstored.
+     */
+    rotate(seenRefreshTokenArg, rejectedAccessTokenArg) {
+        return this.#locks.request(this.#lockName, () => this.withDeadline(async (signalArg) => {
+            const current = await this.#storage.get();
+            if (!current) {
+                return null;
+            }
+            if (current.refreshToken !== seenRefreshTokenArg
+                || (rejectedAccessTokenArg !== null && current.accessToken !== rejectedAccessTokenArg)) {
+                return current;
+            }
+            let answer;
+            const body = { refreshToken: current.refreshToken };
+            try {
+                answer = tokenAnswerOf(await this.post(this.#paths.refresh, body, {}, signalArg));
+            }
+            catch (error) {
+                if (error instanceof RelyingPartyBearerClientError && error.answerError === 'invalid_bearer_grant') {
+                    // the session is over: this pair opens nothing any more
+                    inTime(signalArg);
+                    await this.#storage.clear({ signal: signalArg });
+                    return null;
+                }
+                throw error;
+            }
+            if (!answer) {
+                throw new RelyingPartyBearerClientError('unexpected_answer', { status: 200 });
+            }
+            const stored = { ...answer, receivedAt: this.#now() };
+            inTime(signalArg);
+            await this.#storage.set(stored, { signal: signalArg });
+            return stored;
+        }));
+    }
+    /** Ends the session of a pair through the logout route and answers whether that ended a live one. */
+    async endSessionOf(pairArg, 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 });
+        }
+        return answer.endedLiveSession;
+    }
+    /**
+     * Runs one operation, a claim or a section that holds the lock, under
+     * `requestTimeoutMs`. When the deadline fires, the section's signal aborts
+     * its request and its storage write and keeps it from writing anything
+     * more (`inTime`), and the call answers `onDeadlineArg()` at once, so the
+     * lock is released whatever the request or the storage still does.
+     */
+    async withDeadline(sectionArg, onDeadlineArg = () => {
+        throw new RelyingPartyBearerClientError('request_failed');
+    }) {
+        const controller = new AbortController();
+        let timer;
+        const deadline = new Promise((resolve, reject) => {
+            timer = setTimeout(() => {
+                controller.abort(new RelyingPartyBearerClientError('request_failed'));
+                try {
+                    resolve(onDeadlineArg());
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }, this.#requestTimeoutMs);
+        });
+        const section = sectionArg(controller.signal);
+        // past the deadline the section's own end, its aborted request among them, has nobody left to answer
+        section.catch(() => undefined);
+        try {
+            return await Promise.race([section, deadline]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * A bearer API call: JSON in, JSON out, no cookie, no cache, no redirect.
+     * With `signalArg` none is sent past the deadline and an answer that
+     * arrives after it counts as none.
+     */
+    async post(urlArg, bodyArg, headersArg = {}, signalArg) {
+        if (signalArg) {
+            inTime(signalArg);
+        }
+        let response;
+        try {
+            response = await this.#fetch(urlArg, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', ...headersArg },
+                body: JSON.stringify(bodyArg),
+                credentials: 'omit',
+                cache: 'no-store',
+                redirect: 'error',
+                referrerPolicy: 'no-referrer',
+                ...(signalArg ? { signal: signalArg } : {}),
+            });
+        }
+        catch (error) {
+            throw new RelyingPartyBearerClientError('request_failed', { cause: error });
+        }
+        let answer;
+        try {
+            answer = await response.json();
+        }
+        catch {
+            // the parse error is not kept: its message quotes the body
+            answer = undefined;
+            if (signalArg) {
+                inTime(signalArg);
+            }
+            if (response.status === 200) {
+                throw new RelyingPartyBearerClientError('unexpected_answer', { status: 200 });
+            }
+        }
+        if (signalArg) {
+            inTime(signalArg);
+        }
+        if (response.status !== 200) {
+            throw new RelyingPartyBearerClientError('request_refused', {
+                status: response.status,
+                ...(isRecord(answer) && isText(answer.error) ? { answerError: answer.error } : {}),
+            });
+        }
+        return answer;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.relyingpartybearerclient.js","sourceRoot":"","sources":["../../ts_browser/classes.relyingpartybearerclient.ts"],"names":[],"mappings":"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"}