oauth4webapi 2.17.0 → 3.0.0

package/build/index.js

@@ -1,7 +1,7 @@
 let USER_AGENT;
 if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
     const NAME = 'oauth4webapi';
-    const VERSION = 'v2.17.0';
+    const VERSION = 'v3.0.0';
     USER_AGENT = `${NAME}/${VERSION}`;
 }
 function looseInstanceOf(input, expected) {
@@ -16,13 +16,20 @@ function looseInstanceOf(input, expected) {
         return false;
     }
 }
+const ERR_INVALID_ARG_VALUE = 'ERR_INVALID_ARG_VALUE';
+const ERR_INVALID_ARG_TYPE = 'ERR_INVALID_ARG_TYPE';
+function CodedTypeError(message, code, cause) {
+    const err = new TypeError(message, { cause });
+    Object.assign(err, { code });
+    return err;
+}
+export const allowInsecureRequests = Symbol();
 export const clockSkew = Symbol();
 export const clockTolerance = Symbol();
 export const customFetch = Symbol();
 export const modifyAssertion = Symbol();
 export const jweDecrypt = Symbol();
 export const jwksCache = Symbol();
-export const useMtlsAlias = Symbol();
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 function buf(input) {
@@ -52,7 +59,7 @@ function decodeBase64Url(input) {
         return bytes;
     }
     catch (cause) {
-        throw new OPE('The input to be decoded is not correctly encoded.', { cause });
+        throw CodedTypeError('The input to be decoded is not correctly encoded.', ERR_INVALID_ARG_VALUE, cause);
     }
 }
 function b64u(input) {
@@ -61,98 +68,45 @@ function b64u(input) {
     }
     return encodeBase64Url(input);
 }
-class LRU {
-    constructor(maxSize) {
-        this.cache = new Map();
-        this._cache = new Map();
-        this.maxSize = maxSize;
-    }
-    get(key) {
-        let v = this.cache.get(key);
-        if (v) {
-            return v;
-        }
-        if ((v = this._cache.get(key))) {
-            this.update(key, v);
-            return v;
-        }
-        return undefined;
-    }
-    has(key) {
-        return this.cache.has(key) || this._cache.has(key);
-    }
-    set(key, value) {
-        if (this.cache.has(key)) {
-            this.cache.set(key, value);
-        }
-        else {
-            this.update(key, value);
-        }
-        return this;
-    }
-    delete(key) {
-        if (this.cache.has(key)) {
-            return this.cache.delete(key);
-        }
-        if (this._cache.has(key)) {
-            return this._cache.delete(key);
-        }
-        return false;
-    }
-    update(key, value) {
-        this.cache.set(key, value);
-        if (this.cache.size >= this.maxSize) {
-            this._cache = this.cache;
-            this.cache = new Map();
-        }
-    }
-}
 export class UnsupportedOperationError extends Error {
-    constructor(message) {
-        super(message ?? 'operation not supported');
+    code;
+    constructor(message, options) {
+        super(message, options);
         this.name = this.constructor.name;
+        this.code = UNSUPPORTED_OPERATION;
         Error.captureStackTrace?.(this, this.constructor);
     }
 }
 export class OperationProcessingError extends Error {
+    code;
     constructor(message, options) {
         super(message, options);
         this.name = this.constructor.name;
+        if (options?.code) {
+            this.code = options?.code;
+        }
         Error.captureStackTrace?.(this, this.constructor);
     }
 }
-const OPE = OperationProcessingError;
-const dpopNonces = new LRU(100);
-function isCryptoKey(key) {
-    return key instanceof CryptoKey;
-}
-function isPrivateKey(key) {
-    return isCryptoKey(key) && key.type === 'private';
-}
-function isPublicKey(key) {
-    return isCryptoKey(key) && key.type === 'public';
-}
-const SUPPORTED_JWS_ALGS = [
-    'PS256',
-    'ES256',
-    'RS256',
-    'PS384',
-    'ES384',
-    'RS384',
-    'PS512',
-    'ES512',
-    'RS512',
-    'EdDSA',
-];
-function processDpopNonce(response) {
-    try {
-        const nonce = response.headers.get('dpop-nonce');
-        if (nonce) {
-            dpopNonces.set(new URL(response.url).origin, nonce);
-        }
+function OPE(message, code, cause) {
+    return new OperationProcessingError(message, { code, cause });
+}
+function assertCryptoKey(key, it) {
+    if (!(key instanceof CryptoKey)) {
+        throw CodedTypeError(`${it} must be a private CryptoKey`, ERR_INVALID_ARG_TYPE);
+    }
+}
+function assertPrivateKey(key, it) {
+    assertCryptoKey(key, it);
+    if (key.type !== 'private') {
+        throw CodedTypeError(`${it} must be a private CryptoKey`, ERR_INVALID_ARG_VALUE);
+    }
+}
+function assertPublicKey(key, it) {
+    assertCryptoKey(key, it);
+    if (key.type !== 'public') {
+        throw CodedTypeError(`${it} must be a public CryptoKey`, ERR_INVALID_ARG_VALUE);
     }
-    catch { }
-    return response;
 }
 function normalizeTyp(value) {
     return value.toLowerCase().replace(/^application\//, '');
@@ -172,10 +126,10 @@ function prepareHeaders(input) {
         headers.set('user-agent', USER_AGENT);
     }
     if (headers.has('authorization')) {
-        throw new TypeError('"options.headers" must not include the "authorization" header name');
+        throw CodedTypeError('"options.headers" must not include the "authorization" header name', ERR_INVALID_ARG_VALUE);
     }
     if (headers.has('dpop')) {
-        throw new TypeError('"options.headers" must not include the "dpop" header name');
+        throw CodedTypeError('"options.headers" must not include the "dpop" header name', ERR_INVALID_ARG_VALUE);
     }
     return headers;
 }
@@ -184,17 +138,15 @@ function signal(value) {
         value = value();
     }
     if (!(value instanceof AbortSignal)) {
-        throw new TypeError('"options.signal" must return or be an instance of AbortSignal');
+        throw CodedTypeError('"options.signal" must return or be an instance of AbortSignal', ERR_INVALID_ARG_TYPE);
     }
     return value;
 }
 export async function discoveryRequest(issuerIdentifier, options) {
     if (!(issuerIdentifier instanceof URL)) {
-        throw new TypeError('"issuerIdentifier" must be an instance of URL');
-    }
-    if (issuerIdentifier.protocol !== 'https:' && issuerIdentifier.protocol !== 'http:') {
-        throw new TypeError('"issuer.protocol" must be "https:" or "http:"');
+        throw CodedTypeError('"issuerIdentifier" must be an instance of URL', ERR_INVALID_ARG_TYPE);
     }
+    checkProtocol(issuerIdentifier, options?.[allowInsecureRequests] !== true);
     const url = new URL(issuerIdentifier.href);
     switch (options?.algorithm) {
         case undefined:
@@ -210,49 +162,110 @@ export async function discoveryRequest(issuerIdentifier, options) {
             }
             break;
         default:
-            throw new TypeError('"options.algorithm" must be "oidc" (default), or "oauth2"');
+            throw CodedTypeError('"options.algorithm" must be "oidc" (default), or "oauth2"', ERR_INVALID_ARG_VALUE);
     }
     const headers = prepareHeaders(options?.headers);
     headers.set('accept', 'application/json');
     return (options?.[customFetch] || fetch)(url.href, {
+        body: undefined,
         headers: Object.fromEntries(headers.entries()),
         method: 'GET',
         redirect: 'manual',
-        signal: options?.signal ? signal(options.signal) : null,
-    }).then(processDpopNonce);
+        signal: options?.signal ? signal(options.signal) : undefined,
+    });
 }
-function validateString(input) {
-    return typeof input === 'string' && input.length !== 0;
+function assertNumber(input, allow0, it, code, cause) {
+    try {
+        if (typeof input !== 'number' || !Number.isFinite(input)) {
+            throw CodedTypeError(`${it} must be a number`, ERR_INVALID_ARG_TYPE, cause);
+        }
+        if (input > 0)
+            return;
+        if (allow0 && input !== 0) {
+            throw CodedTypeError(`${it} must be a non-negative number`, ERR_INVALID_ARG_VALUE, cause);
+        }
+        throw CodedTypeError(`${it} must be a positive number`, ERR_INVALID_ARG_VALUE, cause);
+    }
+    catch (err) {
+        if (code) {
+            throw OPE(err.message, code, cause);
+        }
+        throw err;
+    }
+}
+function assertString(input, it, code, cause) {
+    try {
+        if (typeof input !== 'string') {
+            throw CodedTypeError(`${it} must be a string`, ERR_INVALID_ARG_TYPE, cause);
+        }
+        if (input.length === 0) {
+            throw CodedTypeError(`${it} must not be empty`, ERR_INVALID_ARG_VALUE, cause);
+        }
+    }
+    catch (err) {
+        if (code) {
+            throw OPE(err.message, code, cause);
+        }
+        throw err;
+    }
 }
 export async function processDiscoveryResponse(expectedIssuerIdentifier, response) {
-    if (!(expectedIssuerIdentifier instanceof URL)) {
-        throw new TypeError('"expectedIssuer" must be an instance of URL');
+    if (!(expectedIssuerIdentifier instanceof URL) &&
+        expectedIssuerIdentifier !== _nodiscoverycheck) {
+        throw CodedTypeError('"expectedIssuer" must be an instance of URL', ERR_INVALID_ARG_TYPE);
     }
     if (!looseInstanceOf(response, Response)) {
-        throw new TypeError('"response" must be an instance of Response');
+        throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE);
     }
     if (response.status !== 200) {
-        throw new OPE('"response" is not a conform Authorization Server Metadata response');
+        throw OPE('"response" is not a conform Authorization Server Metadata response', RESPONSE_IS_NOT_CONFORM, response);
     }
     assertReadableResponse(response);
+    assertApplicationJson(response);
     let json;
     try {
         json = await response.json();
     }
     catch (cause) {
-        throw new OPE('failed to parse "response" body as JSON', { cause });
+        throw OPE('failed to parse "response" body as JSON', PARSE_ERROR, cause);
     }
     if (!isJsonObject(json)) {
-        throw new OPE('"response" body must be a top level object');
-    }
-    if (!validateString(json.issuer)) {
-        throw new OPE('"response" body "issuer" property must be a non-empty string');
+        throw OPE('"response" body must be a top level object', INVALID_RESPONSE, { body: json });
     }
-    if (new URL(json.issuer).href !== expectedIssuerIdentifier.href) {
-        throw new OPE('"response" body "issuer" does not match "expectedIssuer"');
+    assertString(json.issuer, '"response" body "issuer" property', INVALID_RESPONSE, { body: json });
+    if (new URL(json.issuer).href !== expectedIssuerIdentifier.href &&
+        expectedIssuerIdentifier !== _nodiscoverycheck) {
+        throw OPE('"response" body "issuer" property does not match the expected value', JSON_ATTRIBUTE_COMPARISON, { expected: expectedIssuerIdentifier.href, body: json, attribute: 'issuer' });
     }
     return json;
 }
+function assertApplicationJson(response) {
+    assertContentType(response, 'application/json');
+}
+function notJson(response, ...types) {
+    let msg = '"response" content-type must be ';
+    if (types.length > 2) {
+        const last = types.pop();
+        msg += `${types.join(', ')}, or ${last}`;
+    }
+    else if (types.length === 2) {
+        msg += `${types[0]} or ${types[1]}`;
+    }
+    else {
+        msg += types[0];
+    }
+    return OPE(msg, RESPONSE_IS_NOT_JSON, response);
+}
+function assertContentTypes(response, ...types) {
+    if (!types.includes(getContentType(response))) {
+        throw notJson(response, ...types);
+    }
+}
+function assertContentType(response, contentType) {
+    if (getContentType(response) !== contentType) {
+        throw notJson(response, contentType);
+    }
+}
 function randomBytes() {
     return b64u(crypto.getRandomValues(new Uint8Array(32)));
 }
@@ -266,9 +279,7 @@ export function generateRandomNonce() {
     return randomBytes();
 }
 export async function calculatePKCECodeChallenge(codeVerifier) {
-    if (!validateString(codeVerifier)) {
-        throw new TypeError('"codeVerifier" must be a non-empty string');
-    }
+    assertString(codeVerifier, 'codeVerifier');
     return b64u(await crypto.subtle.digest('SHA-256', buf(codeVerifier)));
 }
 function getKeyAndKid(input) {
@@ -278,24 +289,14 @@ function getKeyAndKid(input) {
     if (!(input?.key instanceof CryptoKey)) {
         return {};
     }
-    if (input.kid !== undefined && !validateString(input.kid)) {
-        throw new TypeError('"kid" must be a non-empty string');
+    if (input.kid !== undefined) {
+        assertString(input.kid, '"kid"');
     }
     return {
         key: input.key,
         kid: input.kid,
-        modifyAssertion: input[modifyAssertion],
     };
 }
-function formUrlEncode(token) {
-    return encodeURIComponent(token).replace(/%20/g, '+');
-}
-function clientSecretBasic(clientId, clientSecret) {
-    const username = formUrlEncode(clientId);
-    const password = formUrlEncode(clientSecret);
-    const credentials = btoa(`${username}:${password}`);
-    return `Basic ${credentials}`;
-}
 function psAlg(key) {
     switch (key.algorithm.hash.name) {
         case 'SHA-256':
@@ -305,7 +306,9 @@ function psAlg(key) {
         case 'SHA-512':
             return 'PS512';
         default:
-            throw new UnsupportedOperationError('unsupported RsaHashedKeyAlgorithm hash name');
+            throw new UnsupportedOperationError('unsupported RsaHashedKeyAlgorithm hash name', {
+                cause: key,
+            });
     }
 }
 function rsAlg(key) {
@@ -317,7 +320,9 @@ function rsAlg(key) {
         case 'SHA-512':
             return 'RS512';
         default:
-            throw new UnsupportedOperationError('unsupported RsaHashedKeyAlgorithm hash name');
+            throw new UnsupportedOperationError('unsupported RsaHashedKeyAlgorithm hash name', {
+                cause: key,
+            });
     }
 }
 function esAlg(key) {
@@ -329,7 +334,7 @@ function esAlg(key) {
         case 'P-521':
             return 'ES512';
         default:
-            throw new UnsupportedOperationError('unsupported EcKeyAlgorithm namedCurve');
+            throw new UnsupportedOperationError('unsupported EcKeyAlgorithm namedCurve', { cause: key });
     }
 }
 function keyToJws(key) {
@@ -341,10 +346,10 @@ function keyToJws(key) {
         case 'ECDSA':
             return esAlg(key);
         case 'Ed25519':
-        case 'Ed448':
-            return 'EdDSA';
+        case 'EdDSA':
+            return 'Ed25519';
         default:
-            throw new UnsupportedOperationError('unsupported CryptoKey algorithm name');
+            throw new UnsupportedOperationError('unsupported CryptoKey algorithm name', { cause: key });
     }
 }
 function getClockSkew(client) {
@@ -360,11 +365,59 @@ function getClockTolerance(client) {
 function epochTime() {
     return Math.floor(Date.now() / 1000);
 }
-function clientAssertion(as, client) {
+function assertAs(as) {
+    if (typeof as !== 'object' || as === null) {
+        throw CodedTypeError('"as" must be an object', ERR_INVALID_ARG_TYPE);
+    }
+    assertString(as.issuer, '"as.issuer"');
+}
+function assertClient(client) {
+    if (typeof client !== 'object' || client === null) {
+        throw CodedTypeError('"client" must be an object', ERR_INVALID_ARG_TYPE);
+    }
+    assertString(client.client_id, '"client.client_id"');
+}
+function formUrlEncode(token) {
+    return encodeURIComponent(token).replace(/(?:[-_.!~*'()]|%20)/g, (substring) => {
+        switch (substring) {
+            case '-':
+            case '_':
+            case '.':
+            case '!':
+            case '~':
+            case '*':
+            case "'":
+            case '(':
+            case ')':
+                return `%${substring.charCodeAt(0).toString(16).toUpperCase()}`;
+            case '%20':
+                return '+';
+            default:
+                throw new Error();
+        }
+    });
+}
+export function ClientSecretPost(clientSecret) {
+    assertString(clientSecret, '"clientSecret"');
+    return (_as, client, body, _headers) => {
+        body.set('client_id', client.client_id);
+        body.set('client_secret', clientSecret);
+    };
+}
+export function ClientSecretBasic(clientSecret) {
+    assertString(clientSecret, '"clientSecret"');
+    return (_as, client, _body, headers) => {
+        const username = formUrlEncode(client.client_id);
+        const password = formUrlEncode(clientSecret);
+        const credentials = btoa(`${username}:${password}`);
+        headers.set('authorization', `Basic ${credentials}`);
+    };
+}
+function clientAssertionPayload(as, client) {
     const now = epochTime() + getClockSkew(client);
     return {
         jti: randomBytes(),
-        aud: [as.issuer, as.token_endpoint],
+        aud: as.issuer,
         exp: now + 60,
         iat: now,
         nbf: now,
@@ -372,105 +425,56 @@ function clientAssertion(as, client) {
         sub: client.client_id,
     };
 }
-async function privateKeyJwt(as, client, key, kid, modifyAssertion) {
-    const header = { alg: keyToJws(key), kid };
-    const payload = clientAssertion(as, client);
-    modifyAssertion?.(header, payload);
-    return jwt(header, payload, key);
-}
-function assertAs(as) {
-    if (typeof as !== 'object' || as === null) {
-        throw new TypeError('"as" must be an object');
-    }
-    if (!validateString(as.issuer)) {
-        throw new TypeError('"as.issuer" property must be a non-empty string');
-    }
-    return true;
-}
-function assertClient(client) {
-    if (typeof client !== 'object' || client === null) {
-        throw new TypeError('"client" must be an object');
-    }
-    if (!validateString(client.client_id)) {
-        throw new TypeError('"client.client_id" property must be a non-empty string');
-    }
-    return true;
-}
-function assertClientSecret(clientSecret) {
-    if (!validateString(clientSecret)) {
-        throw new TypeError('"client.client_secret" property must be a non-empty string');
-    }
-    return clientSecret;
+export function PrivateKeyJwt(clientPrivateKey, options) {
+    const { key, kid } = getKeyAndKid(clientPrivateKey);
+    assertPrivateKey(key, '"clientPrivateKey.key"');
+    return async (as, client, body, _headers) => {
+        const header = { alg: keyToJws(key), kid };
+        const payload = clientAssertionPayload(as, client);
+        options?.[modifyAssertion]?.(header, payload);
+        body.set('client_id', client.client_id);
+        body.set('client_assertion_type', 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer');
+        body.set('client_assertion', await signJwt(header, payload, key));
+    };
 }
-function assertNoClientPrivateKey(clientAuthMethod, clientPrivateKey) {
-    if (clientPrivateKey !== undefined) {
-        throw new TypeError(`"options.clientPrivateKey" property must not be provided when ${clientAuthMethod} client authentication method is used.`);
-    }
+export function ClientSecretJwt(clientSecret, options) {
+    assertString(clientSecret, '"clientSecret"');
+    const modify = options?.[modifyAssertion];
+    let key;
+    return async (as, client, body, _headers) => {
+        key ||= await crypto.subtle.importKey('raw', buf(clientSecret), { hash: 'SHA-256', name: 'HMAC' }, false, ['sign']);
+        const header = { alg: 'HS256' };
+        const payload = clientAssertionPayload(as, client);
+        modify?.(header, payload);
+        const data = `${b64u(buf(JSON.stringify(header)))}.${b64u(buf(JSON.stringify(payload)))}`;
+        const hmac = await crypto.subtle.sign(key.algorithm, key, buf(data));
+        body.set('client_id', client.client_id);
+        body.set('client_assertion_type', 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer');
+        body.set('client_assertion', `${data}.${b64u(new Uint8Array(hmac))}`);
+    };
 }
-function assertNoClientSecret(clientAuthMethod, clientSecret) {
-    if (clientSecret !== undefined) {
-        throw new TypeError(`"client.client_secret" property must not be provided when ${clientAuthMethod} client authentication method is used.`);
-    }
+export function None() {
+    return (_as, client, body, _headers) => {
+        body.set('client_id', client.client_id);
+    };
 }
-async function clientAuthentication(as, client, body, headers, clientPrivateKey) {
-    body.delete('client_secret');
-    body.delete('client_assertion_type');
-    body.delete('client_assertion');
-    switch (client.token_endpoint_auth_method) {
-        case undefined:
-        case 'client_secret_basic': {
-            assertNoClientPrivateKey('client_secret_basic', clientPrivateKey);
-            headers.set('authorization', clientSecretBasic(client.client_id, assertClientSecret(client.client_secret)));
-            break;
-        }
-        case 'client_secret_post': {
-            assertNoClientPrivateKey('client_secret_post', clientPrivateKey);
-            body.set('client_id', client.client_id);
-            body.set('client_secret', assertClientSecret(client.client_secret));
-            break;
-        }
-        case 'private_key_jwt': {
-            assertNoClientSecret('private_key_jwt', client.client_secret);
-            if (clientPrivateKey === undefined) {
-                throw new TypeError('"options.clientPrivateKey" must be provided when "client.token_endpoint_auth_method" is "private_key_jwt"');
-            }
-            const { key, kid, modifyAssertion } = getKeyAndKid(clientPrivateKey);
-            if (!isPrivateKey(key)) {
-                throw new TypeError('"options.clientPrivateKey.key" must be a private CryptoKey');
-            }
-            body.set('client_id', client.client_id);
-            body.set('client_assertion_type', 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer');
-            body.set('client_assertion', await privateKeyJwt(as, client, key, kid, modifyAssertion));
-            break;
-        }
-        case 'tls_client_auth':
-        case 'self_signed_tls_client_auth':
-        case 'none': {
-            assertNoClientSecret(client.token_endpoint_auth_method, client.client_secret);
-            assertNoClientPrivateKey(client.token_endpoint_auth_method, clientPrivateKey);
-            body.set('client_id', client.client_id);
-            break;
-        }
-        default:
-            throw new UnsupportedOperationError('unsupported client token_endpoint_auth_method');
-    }
+export function TlsClientAuth() {
+    return None();
 }
-async function jwt(header, payload, key) {
+async function signJwt(header, payload, key) {
     if (!key.usages.includes('sign')) {
-        throw new TypeError('CryptoKey instances used for signing assertions must include "sign" in their "usages"');
+        throw CodedTypeError('CryptoKey instances used for signing assertions must include "sign" in their "usages"', ERR_INVALID_ARG_VALUE);
     }
     const input = `${b64u(buf(JSON.stringify(header)))}.${b64u(buf(JSON.stringify(payload)))}`;
     const signature = b64u(await crypto.subtle.sign(keyToSubtle(key), key, buf(input)));
     return `${input}.${signature}`;
 }
-export async function issueRequestObject(as, client, parameters, privateKey) {
+export async function issueRequestObject(as, client, parameters, privateKey, options) {
     assertAs(as);
     assertClient(client);
     parameters = new URLSearchParams(parameters);
-    const { key, kid, modifyAssertion } = getKeyAndKid(privateKey);
-    if (!isPrivateKey(key)) {
-        throw new TypeError('"privateKey.key" must be a private CryptoKey');
-    }
+    const { key, kid } = getKeyAndKid(privateKey);
+    assertPrivateKey(key, '"privateKey.key"');
     parameters.set('client_id', client.client_id);
     const now = epochTime() + getClockSkew(client);
     const claims = {
@@ -492,9 +496,7 @@ export async function issueRequestObject(as, client, parameters, privateKey) {
         let value = parameters.get('max_age');
         if (value !== null) {
             claims.max_age = parseInt(value, 10);
-            if (!Number.isFinite(claims.max_age)) {
-                throw new OPE('"max_age" parameter must be a number');
-            }
+            assertNumber(claims.max_age, true, '"max_age" parameter');
         }
     }
     {
@@ -504,10 +506,10 @@ export async function issueRequestObject(as, client, parameters, privateKey) {
                 claims.claims = JSON.parse(value);
             }
             catch (cause) {
-                throw new OPE('failed to parse the "claims" parameter as JSON', { cause });
+                throw OPE('failed to parse the "claims" parameter as JSON', PARSE_ERROR, cause);
             }
             if (!isJsonObject(claims.claims)) {
-                throw new OPE('"claims" parameter must be a JSON with a top level object');
+                throw CodedTypeError('"claims" parameter must be a JSON with a top level object', ERR_INVALID_ARG_VALUE);
             }
         }
     }
@@ -518,10 +520,10 @@ export async function issueRequestObject(as, client, parameters, privateKey) {
                 claims.authorization_details = JSON.parse(value);
             }
             catch (cause) {
-                throw new OPE('failed to parse the "authorization_details" parameter as JSON', { cause });
+                throw OPE('failed to parse the "authorization_details" parameter as JSON', PARSE_ERROR, cause);
             }
             if (!Array.isArray(claims.authorization_details)) {
-                throw new OPE('"authorization_details" parameter must be a JSON with a top level array');
+                throw CodedTypeError('"authorization_details" parameter must be a JSON with a top level array', ERR_INVALID_ARG_VALUE);
             }
         }
     }
@@ -530,39 +532,8 @@ export async function issueRequestObject(as, client, parameters, privateKey) {
         typ: 'oauth-authz-req+jwt',
         kid,
     };
-    modifyAssertion?.(header, claims);
-    return jwt(header, claims, key);
-}
-async function dpopProofJwt(headers, options, url, htm, clockSkew, accessToken) {
-    const { privateKey, publicKey, nonce = dpopNonces.get(url.origin) } = options;
-    if (!isPrivateKey(privateKey)) {
-        throw new TypeError('"DPoP.privateKey" must be a private CryptoKey');
-    }
-    if (!isPublicKey(publicKey)) {
-        throw new TypeError('"DPoP.publicKey" must be a public CryptoKey');
-    }
-    if (nonce !== undefined && !validateString(nonce)) {
-        throw new TypeError('"DPoP.nonce" must be a non-empty string or undefined');
-    }
-    if (!publicKey.extractable) {
-        throw new TypeError('"DPoP.publicKey.extractable" must be true');
-    }
-    const now = epochTime() + clockSkew;
-    const header = {
-        alg: keyToJws(privateKey),
-        typ: 'dpop+jwt',
-        jwk: await publicJwk(publicKey),
-    };
-    const payload = {
-        iat: now,
-        jti: randomBytes(),
-        htm,
-        nonce,
-        htu: `${url.origin}${url.pathname}`,
-        ath: accessToken ? b64u(await crypto.subtle.digest('SHA-256', buf(accessToken))) : undefined,
-    };
-    options[modifyAssertion]?.(header, payload);
-    headers.set('dpop', await jwt(header, payload, privateKey));
+    options?.[modifyAssertion]?.(header, claims);
+    return signJwt(header, claims, key);
 }
 let jwkCache;
 async function getSetPublicJwkCache(key) {
@@ -572,49 +543,185 @@ async function getSetPublicJwkCache(key) {
     return jwk;
 }
 async function publicJwk(key) {
-    jwkCache || (jwkCache = new WeakMap());
+    jwkCache ||= new WeakMap();
     return jwkCache.get(key) || getSetPublicJwkCache(key);
 }
-function validateEndpoint(value, endpoint, useMtlsAlias) {
-    if (typeof value !== 'string') {
-        if (useMtlsAlias) {
-            throw new TypeError(`"as.mtls_endpoint_aliases.${endpoint}" must be a string`);
+const URLParse = URL.parse
+    ?
+        (url, base) => URL.parse(url, base)
+    : (url, base) => {
+        try {
+            return new URL(url, base);
         }
-        throw new TypeError(`"as.${endpoint}" must be a string`);
+        catch {
+            return null;
+        }
+    };
+export function checkProtocol(url, enforceHttps) {
+    if (enforceHttps && url.protocol !== 'https:') {
+        throw OPE('only requests to HTTPS are allowed', HTTP_REQUEST_FORBIDDEN, url);
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw OPE('only HTTP and HTTPS requests are allowed', REQUEST_PROTOCOL_FORBIDDEN, url);
     }
-    return new URL(value);
 }
-function resolveEndpoint(as, endpoint, useMtlsAlias = false) {
-    if (useMtlsAlias && as.mtls_endpoint_aliases && endpoint in as.mtls_endpoint_aliases) {
-        return validateEndpoint(as.mtls_endpoint_aliases[endpoint], endpoint, useMtlsAlias);
+function validateEndpoint(value, endpoint, useMtlsAlias, enforceHttps) {
+    let url;
+    if (typeof value !== 'string' || !(url = URLParse(value))) {
+        throw OPE(`authorization server metadata does not contain a valid ${useMtlsAlias ? `"as.mtls_endpoint_aliases.${endpoint}"` : `"as.${endpoint}"`}`, value === undefined ? MISSING_SERVER_METADATA : INVALID_SERVER_METADATA, { attribute: useMtlsAlias ? `mtls_endpoint_aliases.${endpoint}` : endpoint });
     }
-    return validateEndpoint(as[endpoint], endpoint, useMtlsAlias);
+    checkProtocol(url, enforceHttps);
+    return url;
 }
-function alias(client, options) {
-    if (client.use_mtls_endpoint_aliases || options?.[useMtlsAlias]) {
-        return true;
+export function resolveEndpoint(as, endpoint, useMtlsAlias, enforceHttps) {
+    if (useMtlsAlias && as.mtls_endpoint_aliases && endpoint in as.mtls_endpoint_aliases) {
+        return validateEndpoint(as.mtls_endpoint_aliases[endpoint], endpoint, useMtlsAlias, enforceHttps);
     }
-    return false;
+    return validateEndpoint(as[endpoint], endpoint, useMtlsAlias, enforceHttps);
 }
-export async function pushedAuthorizationRequest(as, client, parameters, options) {
+export async function pushedAuthorizationRequest(as, client, clientAuthentication, parameters, options) {
     assertAs(as);
     assertClient(client);
-    const url = resolveEndpoint(as, 'pushed_authorization_request_endpoint', alias(client, options));
+    const url = resolveEndpoint(as, 'pushed_authorization_request_endpoint', client.use_mtls_endpoint_aliases, options?.[allowInsecureRequests] !== true);
     const body = new URLSearchParams(parameters);
     body.set('client_id', client.client_id);
     const headers = prepareHeaders(options?.headers);
     headers.set('accept', 'application/json');
     if (options?.DPoP !== undefined) {
-        await dpopProofJwt(headers, options.DPoP, url, 'POST', getClockSkew(client));
+        assertDPoP(options.DPoP);
+        await options.DPoP.addProof(url, headers, 'POST');
     }
-    return authenticatedRequest(as, client, 'POST', url, body, headers, options);
+    const response = await authenticatedRequest(as, client, clientAuthentication, url, body, headers, options);
+    options?.DPoP?.cacheNonce(response);
+    return response;
 }
-export function isOAuth2Error(input) {
-    const value = input;
-    if (typeof value !== 'object' || Array.isArray(value) || value === null) {
-        return false;
+class DPoPHandler {
+    #header;
+    #privateKey;
+    #publicKey;
+    #clockSkew;
+    #modifyAssertion;
+    #map;
+    constructor(client, keyPair, options) {
+        assertPrivateKey(keyPair?.privateKey, '"DPoP.privateKey"');
+        assertPublicKey(keyPair?.publicKey, '"DPoP.publicKey"');
+        if (!keyPair.publicKey.extractable) {
+            throw CodedTypeError('"DPoP.publicKey.extractable" must be true', ERR_INVALID_ARG_VALUE);
+        }
+        this.#modifyAssertion = options?.[modifyAssertion];
+        this.#clockSkew = getClockSkew(client);
+        this.#privateKey = keyPair.privateKey;
+        this.#publicKey = keyPair.publicKey;
+        branded.add(this);
+    }
+    #get(key) {
+        this.#map ||= new Map();
+        let item = this.#map.get(key);
+        if (item) {
+            this.#map.delete(key);
+            this.#map.set(key, item);
+        }
+        return item;
+    }
+    #set(key, val) {
+        this.#map ||= new Map();
+        this.#map.delete(key);
+        if (this.#map.size === 100) {
+            this.#map.delete(this.#map.keys().next().value);
+        }
+        this.#map.set(key, val);
+    }
+    async addProof(url, headers, htm, accessToken) {
+        this.#header ||= {
+            alg: keyToJws(this.#privateKey),
+            typ: 'dpop+jwt',
+            jwk: await publicJwk(this.#publicKey),
+        };
+        const nonce = this.#get(url.origin);
+        const now = epochTime() + this.#clockSkew;
+        const payload = {
+            iat: now,
+            jti: randomBytes(),
+            htm,
+            nonce,
+            htu: `${url.origin}${url.pathname}`,
+            ath: accessToken ? b64u(await crypto.subtle.digest('SHA-256', buf(accessToken))) : undefined,
+        };
+        this.#modifyAssertion?.(this.#header, payload);
+        headers.set('dpop', await signJwt(this.#header, payload, this.#privateKey));
+    }
+    cacheNonce(response) {
+        try {
+            const nonce = response.headers.get('dpop-nonce');
+            if (nonce) {
+                this.#set(new URL(response.url).origin, nonce);
+            }
+        }
+        catch { }
+    }
+}
+export function isDPoPNonceError(err) {
+    if (err instanceof WWWAuthenticateChallengeError) {
+        const { 0: challenge, length } = err.cause;
+        return (length === 1 && challenge.scheme === 'dpop' && challenge.parameters.error === 'use_dpop_nonce');
+    }
+    if (err instanceof ResponseBodyError) {
+        return err.error === 'use_dpop_nonce';
+    }
+    return false;
+}
+export function DPoP(client, keyPair, options) {
+    return new DPoPHandler(client, keyPair, options);
+}
+export class ResponseBodyError extends Error {
+    cause;
+    code;
+    error;
+    status;
+    error_description;
+    response;
+    constructor(message, options) {
+        super(message, options);
+        this.name = this.constructor.name;
+        this.code = RESPONSE_BODY_ERROR;
+        this.cause = options.cause;
+        this.error = options.cause.error;
+        this.status = options.response.status;
+        this.error_description = options.cause.error_description;
+        Object.defineProperty(this, 'response', { enumerable: false, value: options.response });
+        Error.captureStackTrace?.(this, this.constructor);
+    }
+}
+export class AuthorizationResponseError extends Error {
+    cause;
+    code;
+    error;
+    error_description;
+    constructor(message, options) {
+        super(message, options);
+        this.name = this.constructor.name;
+        this.code = AUTHORIZATION_RESPONSE_ERROR;
+        this.cause = options.cause;
+        this.error = options.cause.get('error');
+        this.error_description = options.cause.get('error_description') ?? undefined;
+        Error.captureStackTrace?.(this, this.constructor);
+    }
+}
+export class WWWAuthenticateChallengeError extends Error {
+    cause;
+    code;
+    response;
+    status;
+    constructor(message, options) {
+        super(message, options);
+        this.name = this.constructor.name;
+        this.code = WWW_AUTHENTICATE_CHALLENGE;
+        this.cause = options.cause;
+        this.status = options.response.status;
+        this.response = options.response;
+        Object.defineProperty(this, 'response', { enumerable: false });
+        Error.captureStackTrace?.(this, this.constructor);
     }
-    return value.error !== undefined;
 }
 function unquote(value) {
     if (value.length >= 2 && value[0] === '"' && value[value.length - 1] === '"') {
@@ -646,9 +753,9 @@ function wwwAuth(scheme, params) {
         parameters,
     };
 }
-export function parseWwwAuthenticateChallenges(response) {
+function parseWwwAuthenticateChallenges(response) {
     if (!looseInstanceOf(response, Response)) {
-        throw new TypeError('"response" must be an instance of Response');
+        throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE);
     }
     const header = response.headers.get('www-authenticate');
     if (header === null) {
@@ -678,61 +785,86 @@ export async function processPushedAuthorizationResponse(as, client, response) {
     assertAs(as);
     assertClient(client);
     if (!looseInstanceOf(response, Response)) {
-        throw new TypeError('"response" must be an instance of Response');
+        throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE);
+    }
+    let challenges;
+    if ((challenges = parseWwwAuthenticateChallenges(response))) {
+        throw new WWWAuthenticateChallengeError('server responded with a challenge in the WWW-Authenticate HTTP Header', { cause: challenges, response });
     }
     if (response.status !== 201) {
         let err;
         if ((err = await handleOAuthBodyError(response))) {
-            return err;
+            await response.body?.cancel();
+            throw new ResponseBodyError('server responded with an error in the response body', {
+                cause: err,
+                response,
+            });
         }
-        throw new OPE('"response" is not a conform Pushed Authorization Request Endpoint response');
+        throw OPE('"response" is not a conform Pushed Authorization Request Endpoint response', RESPONSE_IS_NOT_CONFORM, response);
     }
     assertReadableResponse(response);
+    assertApplicationJson(response);
     let json;
     try {
         json = await response.json();
     }
     catch (cause) {
-        throw new OPE('failed to parse "response" body as JSON', { cause });
+        throw OPE('failed to parse "response" body as JSON', PARSE_ERROR, cause);
     }
     if (!isJsonObject(json)) {
-        throw new OPE('"response" body must be a top level object');
-    }
-    if (!validateString(json.request_uri)) {
-        throw new OPE('"response" body "request_uri" property must be a non-empty string');
-    }
-    if (typeof json.expires_in !== 'number' || json.expires_in <= 0) {
-        throw new OPE('"response" body "expires_in" property must be a positive number');
+        throw OPE('"response" body must be a top level object', INVALID_RESPONSE, { body: json });
     }
+    assertString(json.request_uri, '"response" body "request_uri" property', INVALID_RESPONSE, {
+        body: json,
+    });
+    assertNumber(json.expires_in, false, '"response" body "expires_in" property', INVALID_RESPONSE, {
+        body: json,
+    });
     return json;
 }
-export async function protectedResourceRequest(accessToken, method, url, headers, body, options) {
-    if (!validateString(accessToken)) {
-        throw new TypeError('"accessToken" must be a non-empty string');
+function assertDPoP(option) {
+    if (!branded.has(option)) {
+        throw CodedTypeError('"options.DPoP" is not a valid DPoPHandle', ERR_INVALID_ARG_VALUE);
     }
+}
+async function resourceRequest(accessToken, method, url, headers, body, options) {
+    assertString(accessToken, '"accessToken"');
     if (!(url instanceof URL)) {
-        throw new TypeError('"url" must be an instance of URL');
+        throw CodedTypeError('"url" must be an instance of URL', ERR_INVALID_ARG_TYPE);
     }
+    checkProtocol(url, options?.[allowInsecureRequests] !== true);
     headers = prepareHeaders(headers);
-    if (options?.DPoP === undefined) {
-        headers.set('authorization', `Bearer ${accessToken}`);
+    if (options?.DPoP) {
+        assertDPoP(options.DPoP);
+        await options.DPoP.addProof(url, headers, method.toUpperCase(), accessToken);
+        headers.set('authorization', `DPoP ${accessToken}`);
     }
     else {
-        await dpopProofJwt(headers, options.DPoP, url, method.toUpperCase(), getClockSkew({ [clockSkew]: options?.[clockSkew] }), accessToken);
-        headers.set('authorization', `DPoP ${accessToken}`);
+        headers.set('authorization', `Bearer ${accessToken}`);
     }
-    return (options?.[customFetch] || fetch)(url.href, {
+    const response = await (options?.[customFetch] || fetch)(url.href, {
         body,
         headers: Object.fromEntries(headers.entries()),
         method,
         redirect: 'manual',
-        signal: options?.signal ? signal(options.signal) : null,
-    }).then(processDpopNonce);
+        signal: options?.signal ? signal(options.signal) : undefined,
+    });
+    options?.DPoP?.cacheNonce(response);
+    return response;
+}
+export async function protectedResourceRequest(accessToken, method, url, headers, body, options) {
+    return resourceRequest(accessToken, method, url, headers, body, options).then((response) => {
+        let challenges;
+        if ((challenges = parseWwwAuthenticateChallenges(response))) {
+            throw new WWWAuthenticateChallengeError('server responded with a challenge in the WWW-Authenticate HTTP Header', { cause: challenges, response });
+        }
+        return response;
+    });
 }
 export async function userInfoRequest(as, client, accessToken, options) {
     assertAs(as);
     assertClient(client);
-    const url = resolveEndpoint(as, 'userinfo_endpoint', alias(client, options));
+    const url = resolveEndpoint(as, 'userinfo_endpoint', client.use_mtls_endpoint_aliases, options?.[allowInsecureRequests] !== true);
     const headers = prepareHeaders(options?.headers);
     if (client.userinfo_signed_response_alg) {
         headers.set('accept', 'application/jwt');
@@ -741,14 +873,14 @@ export async function userInfoRequest(as, client, accessToken, options) {
         headers.set('accept', 'application/json');
         headers.append('accept', 'application/jwt');
     }
-    return protectedResourceRequest(accessToken, 'GET', url, headers, null, {
+    return resourceRequest(accessToken, 'GET', url, headers, null, {
         ...options,
         [clockSkew]: getClockSkew(client),
     });
 }
 let jwksMap;
 function setJwksCache(as, jwks, uat, cache) {
-    jwksMap || (jwksMap = new WeakMap());
+    jwksMap ||= new WeakMap();
     jwksMap.set(as, {
         jwks,
         uat,
@@ -782,7 +914,7 @@ function clearJwksCache(as, cache) {
 }
 async function getPublicSigKeyFromIssuerJwksUri(as, options, header) {
     const { alg, kid } = header;
-    checkSupportedJwsAlg(alg);
+    checkSupportedJwsAlg(header);
     if (!jwksMap?.has(as) && isFreshJwksCache(options?.[jwksCache])) {
         setJwksCache(as, options?.[jwksCache].jwks, options?.[jwksCache].uat);
     }
@@ -814,7 +946,7 @@ async function getPublicSigKeyFromIssuerJwksUri(as, options, header) {
             kty = 'OKP';
             break;
         default:
-            throw new UnsupportedOperationError();
+            throw new UnsupportedOperationError('unsupported JWS algorithm', { cause: { alg } });
     }
     const candidates = jwks.keys.filter((jwk) => {
         if (jwk.kty !== kty) {
@@ -836,7 +968,8 @@ async function getPublicSigKeyFromIssuerJwksUri(as, options, header) {
             case alg === 'ES256' && jwk.crv !== 'P-256':
             case alg === 'ES384' && jwk.crv !== 'P-384':
             case alg === 'ES512' && jwk.crv !== 'P-521':
-            case alg === 'EdDSA' && !(jwk.crv === 'Ed25519' || jwk.crv === 'Ed448'):
+            case alg === 'Ed25519' && jwk.crv !== 'Ed25519':
+            case alg === 'EdDSA' && jwk.crv !== 'Ed25519':
                 return false;
         }
         return true;
@@ -847,221 +980,219 @@ async function getPublicSigKeyFromIssuerJwksUri(as, options, header) {
             clearJwksCache(as, options?.[jwksCache]);
             return getPublicSigKeyFromIssuerJwksUri(as, options, header);
         }
-        throw new OPE('error when selecting a JWT verification key, no applicable keys found');
+        throw OPE('error when selecting a JWT verification key, no applicable keys found', KEY_SELECTION, { header, candidates, jwks_uri: new URL(as.jwks_uri) });
     }
     if (length !== 1) {
-        throw new OPE('error when selecting a JWT verification key, multiple applicable keys found, a "kid" JWT Header Parameter is required');
-    }
-    const key = await importJwk(alg, jwk);
-    if (key.type !== 'public') {
-        throw new OPE('jwks_uri must only contain public keys');
+        throw OPE('error when selecting a JWT verification key, multiple applicable keys found, a "kid" JWT Header Parameter is required', KEY_SELECTION, { header, candidates, jwks_uri: new URL(as.jwks_uri) });
     }
-    return key;
+    return importJwk(alg, jwk);
 }
 export const skipSubjectCheck = Symbol();
 function getContentType(response) {
     return response.headers.get('content-type')?.split(';')[0];
 }
-export async function processUserInfoResponse(as, client, expectedSubject, response) {
+export async function processUserInfoResponse(as, client, expectedSubject, response, options) {
     assertAs(as);
     assertClient(client);
     if (!looseInstanceOf(response, Response)) {
-        throw new TypeError('"response" must be an instance of Response');
+        throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE);
+    }
+    let challenges;
+    if ((challenges = parseWwwAuthenticateChallenges(response))) {
+        throw new WWWAuthenticateChallengeError('server responded with a challenge in the WWW-Authenticate HTTP Header', { cause: challenges, response });
     }
     if (response.status !== 200) {
-        throw new OPE('"response" is not a conform UserInfo Endpoint response');
+        throw OPE('"response" is not a conform UserInfo Endpoint response', RESPONSE_IS_NOT_CONFORM, response);
     }
+    assertReadableResponse(response);
     let json;
     if (getContentType(response) === 'application/jwt') {
-        assertReadableResponse(response);
-        const { claims, jwt } = await validateJwt(await response.text(), checkSigningAlgorithm.bind(undefined, client.userinfo_signed_response_alg, as.userinfo_signing_alg_values_supported), noSignatureCheck, getClockSkew(client), getClockTolerance(client), client[jweDecrypt])
+        const { claims, jwt } = await validateJwt(await response.text(), checkSigningAlgorithm.bind(undefined, client.userinfo_signed_response_alg, as.userinfo_signing_alg_values_supported, undefined), getClockSkew(client), getClockTolerance(client), options?.[jweDecrypt])
             .then(validateOptionalAudience.bind(undefined, client.client_id))
-            .then(validateOptionalIssuer.bind(undefined, as.issuer));
-        jwtResponseBodies.set(response, jwt);
+            .then(validateOptionalIssuer.bind(undefined, as));
+        jwtRefs.set(response, jwt);
         json = claims;
     }
     else {
         if (client.userinfo_signed_response_alg) {
-            throw new OPE('JWT UserInfo Response expected');
+            throw OPE('JWT UserInfo Response expected', JWT_USERINFO_EXPECTED, response);
         }
-        assertReadableResponse(response);
+        assertApplicationJson(response);
         try {
             json = await response.json();
         }
         catch (cause) {
-            throw new OPE('failed to parse "response" body as JSON', { cause });
+            throw OPE('failed to parse "response" body as JSON', PARSE_ERROR, cause);
         }
     }
     if (!isJsonObject(json)) {
-        throw new OPE('"response" body must be a top level object');
-    }
-    if (!validateString(json.sub)) {
-        throw new OPE('"response" body "sub" property must be a non-empty string');
+        throw OPE('"response" body must be a top level object', INVALID_RESPONSE, { body: json });
     }
+    assertString(json.sub, '"response" body "sub" property', INVALID_RESPONSE, { body: json });
     switch (expectedSubject) {
         case skipSubjectCheck:
             break;
         default:
-            if (!validateString(expectedSubject)) {
-                throw new OPE('"expectedSubject" must be a non-empty string');
-            }
+            assertString(expectedSubject, '"expectedSubject"');
             if (json.sub !== expectedSubject) {
-                throw new OPE('unexpected "response" body "sub" value');
+                throw OPE('unexpected "response" body "sub" property value', JSON_ATTRIBUTE_COMPARISON, {
+                    expected: expectedSubject,
+                    body: json,
+                    attribute: 'sub',
+                });
             }
     }
     return json;
 }
-async function authenticatedRequest(as, client, method, url, body, headers, options) {
-    await clientAuthentication(as, client, body, headers, options?.clientPrivateKey);
+async function authenticatedRequest(as, client, clientAuthentication, url, body, headers, options) {
+    await clientAuthentication(as, client, body, headers);
     headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
     return (options?.[customFetch] || fetch)(url.href, {
         body,
         headers: Object.fromEntries(headers.entries()),
-        method,
+        method: 'POST',
         redirect: 'manual',
-        signal: options?.signal ? signal(options.signal) : null,
-    }).then(processDpopNonce);
+        signal: options?.signal ? signal(options.signal) : undefined,
+    });
 }
-async function tokenEndpointRequest(as, client, grantType, parameters, options) {
-    const url = resolveEndpoint(as, 'token_endpoint', alias(client, options));
+async function tokenEndpointRequest(as, client, clientAuthentication, grantType, parameters, options) {
+    const url = resolveEndpoint(as, 'token_endpoint', client.use_mtls_endpoint_aliases, options?.[allowInsecureRequests] !== true);
     parameters.set('grant_type', grantType);
     const headers = prepareHeaders(options?.headers);
     headers.set('accept', 'application/json');
     if (options?.DPoP !== undefined) {
-        await dpopProofJwt(headers, options.DPoP, url, 'POST', getClockSkew(client));
+        assertDPoP(options.DPoP);
+        await options.DPoP.addProof(url, headers, 'POST');
     }
-    return authenticatedRequest(as, client, 'POST', url, parameters, headers, options);
+    const response = await authenticatedRequest(as, client, clientAuthentication, url, parameters, headers, options);
+    options?.DPoP?.cacheNonce(response);
+    return response;
 }
-export async function refreshTokenGrantRequest(as, client, refreshToken, options) {
+export async function refreshTokenGrantRequest(as, client, clientAuthentication, refreshToken, options) {
     assertAs(as);
     assertClient(client);
-    if (!validateString(refreshToken)) {
-        throw new TypeError('"refreshToken" must be a non-empty string');
-    }
+    assertString(refreshToken, '"refreshToken"');
     const parameters = new URLSearchParams(options?.additionalParameters);
     parameters.set('refresh_token', refreshToken);
-    return tokenEndpointRequest(as, client, 'refresh_token', parameters, options);
+    return tokenEndpointRequest(as, client, clientAuthentication, 'refresh_token', parameters, options);
 }
 const idTokenClaims = new WeakMap();
-const jwtResponseBodies = new WeakMap();
+const jwtRefs = new WeakMap();
 export function getValidatedIdTokenClaims(ref) {
     if (!ref.id_token) {
         return undefined;
     }
     const claims = idTokenClaims.get(ref);
     if (!claims) {
-        throw new TypeError('"ref" was already garbage collected or did not resolve from the proper sources');
-    }
-    return claims[0];
-}
-export async function validateIdTokenSignature(as, ref, options) {
-    assertAs(as);
-    if (!idTokenClaims.has(ref)) {
-        throw new OPE('"ref" does not contain an ID Token to verify the signature of');
+        throw CodedTypeError('"ref" was already garbage collected or did not resolve from the proper sources', ERR_INVALID_ARG_VALUE);
     }
-    const { 0: protectedHeader, 1: payload, 2: encodedSignature, } = idTokenClaims.get(ref)[1].split('.');
-    const header = JSON.parse(buf(b64u(protectedHeader)));
-    if (header.alg.startsWith('HS')) {
-        throw new UnsupportedOperationError();
-    }
-    let key;
-    key = await getPublicSigKeyFromIssuerJwksUri(as, options, header);
-    await validateJwsSignature(protectedHeader, payload, key, b64u(encodedSignature));
+    return claims;
 }
-async function validateJwtResponseSignature(as, ref, options) {
+export async function validateApplicationLevelSignature(as, ref, options) {
     assertAs(as);
-    if (!jwtResponseBodies.has(ref)) {
-        throw new OPE('"ref" does not contain a processed JWT Response to verify the signature of');
+    if (!jwtRefs.has(ref)) {
+        throw CodedTypeError('"ref" does not contain a processed JWT Response to verify the signature of', ERR_INVALID_ARG_VALUE);
     }
-    const { 0: protectedHeader, 1: payload, 2: encodedSignature, } = jwtResponseBodies.get(ref).split('.');
+    const { 0: protectedHeader, 1: payload, 2: encodedSignature } = jwtRefs.get(ref).split('.');
     const header = JSON.parse(buf(b64u(protectedHeader)));
     if (header.alg.startsWith('HS')) {
-        throw new UnsupportedOperationError();
+        throw new UnsupportedOperationError('unsupported JWS algorithm', { cause: { alg: header.alg } });
     }
     let key;
     key = await getPublicSigKeyFromIssuerJwksUri(as, options, header);
     await validateJwsSignature(protectedHeader, payload, key, b64u(encodedSignature));
 }
-export function validateJwtUserInfoSignature(as, ref, options) {
-    return validateJwtResponseSignature(as, ref, options);
-}
-export function validateJwtIntrospectionSignature(as, ref, options) {
-    return validateJwtResponseSignature(as, ref, options);
-}
-async function processGenericAccessTokenResponse(as, client, response, ignoreIdToken = false, ignoreRefreshToken = false) {
+async function processGenericAccessTokenResponse(as, client, response, additionalRequiredIdTokenClaims, options) {
     assertAs(as);
     assertClient(client);
     if (!looseInstanceOf(response, Response)) {
-        throw new TypeError('"response" must be an instance of Response');
+        throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE);
+    }
+    let challenges;
+    if ((challenges = parseWwwAuthenticateChallenges(response))) {
+        throw new WWWAuthenticateChallengeError('server responded with a challenge in the WWW-Authenticate HTTP Header', { cause: challenges, response });
     }
     if (response.status !== 200) {
         let err;
         if ((err = await handleOAuthBodyError(response))) {
-            return err;
+            await response.body?.cancel();
+            throw new ResponseBodyError('server responded with an error in the response body', {
+                cause: err,
+                response,
+            });
         }
-        throw new OPE('"response" is not a conform Token Endpoint response');
+        throw OPE('"response" is not a conform Token Endpoint response', RESPONSE_IS_NOT_CONFORM, response);
     }
     assertReadableResponse(response);
+    assertApplicationJson(response);
     let json;
     try {
         json = await response.json();
     }
     catch (cause) {
-        throw new OPE('failed to parse "response" body as JSON', { cause });
+        throw OPE('failed to parse "response" body as JSON', PARSE_ERROR, cause);
     }
     if (!isJsonObject(json)) {
-        throw new OPE('"response" body must be a top level object');
-    }
-    if (!validateString(json.access_token)) {
-        throw new OPE('"response" body "access_token" property must be a non-empty string');
-    }
-    if (!validateString(json.token_type)) {
-        throw new OPE('"response" body "token_type" property must be a non-empty string');
+        throw OPE('"response" body must be a top level object', INVALID_RESPONSE, { body: json });
     }
+    assertString(json.access_token, '"response" body "access_token" property', INVALID_RESPONSE, {
+        body: json,
+    });
+    assertString(json.token_type, '"response" body "token_type" property', INVALID_RESPONSE, {
+        body: json,
+    });
     json.token_type = json.token_type.toLowerCase();
     if (json.token_type !== 'dpop' && json.token_type !== 'bearer') {
-        throw new UnsupportedOperationError('unsupported `token_type` value');
+        throw new UnsupportedOperationError('unsupported `token_type` value', { cause: { body: json } });
     }
-    if (json.expires_in !== undefined &&
-        (typeof json.expires_in !== 'number' || json.expires_in <= 0)) {
-        throw new OPE('"response" body "expires_in" property must be a positive number');
+    if (json.expires_in !== undefined) {
+        assertNumber(json.expires_in, false, '"response" body "expires_in" property', INVALID_RESPONSE, { body: json });
     }
-    if (!ignoreRefreshToken &&
-        json.refresh_token !== undefined &&
-        !validateString(json.refresh_token)) {
-        throw new OPE('"response" body "refresh_token" property must be a non-empty string');
+    if (json.refresh_token !== undefined) {
+        assertString(json.refresh_token, '"response" body "refresh_token" property', INVALID_RESPONSE, {
+            body: json,
+        });
     }
     if (json.scope !== undefined && typeof json.scope !== 'string') {
-        throw new OPE('"response" body "scope" property must be a string');
-    }
-    if (!ignoreIdToken) {
-        if (json.id_token !== undefined && !validateString(json.id_token)) {
-            throw new OPE('"response" body "id_token" property must be a non-empty string');
-        }
-        if (json.id_token) {
-            const { claims, jwt } = await validateJwt(json.id_token, checkSigningAlgorithm.bind(undefined, client.id_token_signed_response_alg, as.id_token_signing_alg_values_supported), noSignatureCheck, getClockSkew(client), getClockTolerance(client), client[jweDecrypt])
-                .then(validatePresence.bind(undefined, ['aud', 'exp', 'iat', 'iss', 'sub']))
-                .then(validateIssuer.bind(undefined, as.issuer))
-                .then(validateAudience.bind(undefined, client.client_id));
-            if (Array.isArray(claims.aud) && claims.aud.length !== 1) {
-                if (claims.azp === undefined) {
-                    throw new OPE('ID Token "aud" (audience) claim includes additional untrusted audiences');
-                }
-                if (claims.azp !== client.client_id) {
-                    throw new OPE('unexpected ID Token "azp" (authorized party) claim value');
-                }
+        throw OPE('"response" body "scope" property must be a string', INVALID_RESPONSE, { body: json });
+    }
+    if (json.id_token !== undefined) {
+        assertString(json.id_token, '"response" body "id_token" property', INVALID_RESPONSE, {
+            body: json,
+        });
+        const requiredClaims = ['aud', 'exp', 'iat', 'iss', 'sub'];
+        if (client.require_auth_time === true) {
+            requiredClaims.push('auth_time');
+        }
+        if (client.default_max_age !== undefined) {
+            assertNumber(client.default_max_age, false, '"client.default_max_age"');
+            requiredClaims.push('auth_time');
+        }
+        if (additionalRequiredIdTokenClaims?.length) {
+            requiredClaims.push(...additionalRequiredIdTokenClaims);
+        }
+        const { claims, jwt } = await validateJwt(json.id_token, checkSigningAlgorithm.bind(undefined, client.id_token_signed_response_alg, as.id_token_signing_alg_values_supported, 'RS256'), getClockSkew(client), getClockTolerance(client), options?.[jweDecrypt])
+            .then(validatePresence.bind(undefined, requiredClaims))
+            .then(validateIssuer.bind(undefined, as))
+            .then(validateAudience.bind(undefined, client.client_id));
+        if (Array.isArray(claims.aud) && claims.aud.length !== 1) {
+            if (claims.azp === undefined) {
+                throw OPE('ID Token "aud" (audience) claim includes additional untrusted audiences', JWT_CLAIM_COMPARISON, { claims, claim: 'aud' });
             }
-            if (claims.auth_time !== undefined &&
-                (!Number.isFinite(claims.auth_time) || Math.sign(claims.auth_time) !== 1)) {
-                throw new OPE('ID Token "auth_time" (authentication time) must be a positive number');
+            if (claims.azp !== client.client_id) {
+                throw OPE('unexpected ID Token "azp" (authorized party) claim value', JWT_CLAIM_COMPARISON, { expected: client.client_id, claims, claim: 'azp' });
             }
-            idTokenClaims.set(json, [claims, jwt]);
         }
+        if (claims.auth_time !== undefined) {
+            assertNumber(claims.auth_time, false, 'ID Token "auth_time" (authentication time)', INVALID_RESPONSE, { claims });
+        }
+        jwtRefs.set(response, jwt);
+        idTokenClaims.set(json, claims);
     }
     return json;
 }
-export async function processRefreshTokenResponse(as, client, response) {
-    return processGenericAccessTokenResponse(as, client, response);
+export async function processRefreshTokenResponse(as, client, response, options) {
+    return processGenericAccessTokenResponse(as, client, response, undefined, options);
 }
 function validateOptionalAudience(expected, result) {
     if (result.claims.aud !== undefined) {
@@ -1072,23 +1203,36 @@ function validateOptionalAudience(expected, result) {
 function validateAudience(expected, result) {
     if (Array.isArray(result.claims.aud)) {
         if (!result.claims.aud.includes(expected)) {
-            throw new OPE('unexpected JWT "aud" (audience) claim value');
+            throw OPE('unexpected JWT "aud" (audience) claim value', JWT_CLAIM_COMPARISON, {
+                expected,
+                claims: result.claims,
+                claim: 'aud',
+            });
         }
     }
     else if (result.claims.aud !== expected) {
-        throw new OPE('unexpected JWT "aud" (audience) claim value');
+        throw OPE('unexpected JWT "aud" (audience) claim value', JWT_CLAIM_COMPARISON, {
+            expected,
+            claims: result.claims,
+            claim: 'aud',
+        });
     }
     return result;
 }
-function validateOptionalIssuer(expected, result) {
+function validateOptionalIssuer(as, result) {
     if (result.claims.iss !== undefined) {
-        return validateIssuer(expected, result);
+        return validateIssuer(as, result);
     }
     return result;
 }
-function validateIssuer(expected, result) {
+function validateIssuer(as, result) {
+    const expected = as[_expectedIssuer]?.(result) ?? as.issuer;
     if (result.claims.iss !== expected) {
-        throw new OPE('unexpected JWT "iss" (issuer) claim value');
+        throw OPE('unexpected JWT "iss" (issuer) claim value', JWT_CLAIM_COMPARISON, {
+            expected,
+            claims: result.claims,
+            claim: 'iss',
+        });
     }
     return result;
 }
@@ -1097,27 +1241,25 @@ function brand(searchParams) {
     branded.add(searchParams);
     return searchParams;
 }
-export async function authorizationCodeGrantRequest(as, client, callbackParameters, redirectUri, codeVerifier, options) {
+export async function authorizationCodeGrantRequest(as, client, clientAuthentication, callbackParameters, redirectUri, codeVerifier, options) {
     assertAs(as);
     assertClient(client);
     if (!branded.has(callbackParameters)) {
-        throw new TypeError('"callbackParameters" must be an instance of URLSearchParams obtained from "validateAuthResponse()", or "validateJwtAuthResponse()');
-    }
-    if (!validateString(redirectUri)) {
-        throw new TypeError('"redirectUri" must be a non-empty string');
-    }
-    if (!validateString(codeVerifier)) {
-        throw new TypeError('"codeVerifier" must be a non-empty string');
+        throw CodedTypeError('"callbackParameters" must be an instance of URLSearchParams obtained from "validateAuthResponse()", or "validateJwtAuthResponse()', ERR_INVALID_ARG_VALUE);
     }
+    assertString(redirectUri, '"redirectUri"');
     const code = getURLSearchParameter(callbackParameters, 'code');
     if (!code) {
-        throw new OPE('no authorization code in "callbackParameters"');
+        throw OPE('no authorization code in "callbackParameters"', INVALID_RESPONSE);
     }
     const parameters = new URLSearchParams(options?.additionalParameters);
     parameters.set('redirect_uri', redirectUri);
-    parameters.set('code_verifier', codeVerifier);
     parameters.set('code', code);
-    return tokenEndpointRequest(as, client, 'authorization_code', parameters, options);
+    if (codeVerifier !== _nopkce) {
+        assertString(codeVerifier, '"codeVerifier"');
+        parameters.set('code_verifier', codeVerifier);
+    }
+    return tokenEndpointRequest(as, client, clientAuthentication, 'authorization_code', parameters, options);
 }
 const jwtClaimNames = {
     aud: 'audience',
@@ -1134,138 +1276,190 @@ const jwtClaimNames = {
     htm: 'http method',
     htu: 'http uri',
     cnf: 'confirmation',
+    auth_time: 'authentication time',
 };
 function validatePresence(required, result) {
     for (const claim of required) {
         if (result.claims[claim] === undefined) {
-            throw new OPE(`JWT "${claim}" (${jwtClaimNames[claim]}) claim missing`);
+            throw OPE(`JWT "${claim}" (${jwtClaimNames[claim]}) claim missing`, INVALID_RESPONSE, {
+                claims: result.claims,
+            });
         }
     }
     return result;
 }
 export const expectNoNonce = Symbol();
 export const skipAuthTimeCheck = Symbol();
-export async function processAuthorizationCodeOpenIDResponse(as, client, response, expectedNonce, maxAge) {
-    const result = await processGenericAccessTokenResponse(as, client, response);
-    if (isOAuth2Error(result)) {
-        return result;
+export async function processAuthorizationCodeResponse(as, client, response, options) {
+    if (typeof options?.expectedNonce === 'string' ||
+        typeof options?.maxAge === 'number' ||
+        options?.requireIdToken) {
+        return processAuthorizationCodeOpenIDResponse(as, client, response, options.expectedNonce, options.maxAge, {
+            [jweDecrypt]: options[jweDecrypt],
+        });
     }
-    if (!validateString(result.id_token)) {
-        throw new OPE('"response" body "id_token" property must be a non-empty string');
+    return processAuthorizationCodeOAuth2Response(as, client, response, options);
+}
+async function processAuthorizationCodeOpenIDResponse(as, client, response, expectedNonce, maxAge, options) {
+    const additionalRequiredClaims = [];
+    switch (expectedNonce) {
+        case undefined:
+            expectedNonce = expectNoNonce;
+            break;
+        case expectNoNonce:
+            break;
+        default:
+            assertString(expectedNonce, '"expectedNonce" argument');
+            additionalRequiredClaims.push('nonce');
     }
-    maxAge ?? (maxAge = client.default_max_age ?? skipAuthTimeCheck);
-    const claims = getValidatedIdTokenClaims(result);
-    if ((client.require_auth_time || maxAge !== skipAuthTimeCheck) &&
-        claims.auth_time === undefined) {
-        throw new OPE('ID Token "auth_time" (authentication time) claim missing');
+    maxAge ??= client.default_max_age;
+    switch (maxAge) {
+        case undefined:
+            maxAge = skipAuthTimeCheck;
+            break;
+        case skipAuthTimeCheck:
+            break;
+        default:
+            assertNumber(maxAge, false, '"maxAge" argument');
+            additionalRequiredClaims.push('auth_time');
     }
+    const result = await processGenericAccessTokenResponse(as, client, response, additionalRequiredClaims, options);
+    assertString(result.id_token, '"response" body "id_token" property', INVALID_RESPONSE, {
+        body: result,
+    });
+    const claims = getValidatedIdTokenClaims(result);
     if (maxAge !== skipAuthTimeCheck) {
-        if (typeof maxAge !== 'number' || maxAge < 0) {
-            throw new TypeError('"maxAge" must be a non-negative number');
-        }
         const now = epochTime() + getClockSkew(client);
         const tolerance = getClockTolerance(client);
         if (claims.auth_time + maxAge < now - tolerance) {
-            throw new OPE('too much time has elapsed since the last End-User authentication');
+            throw OPE('too much time has elapsed since the last End-User authentication', JWT_TIMESTAMP_CHECK, { claims, now, tolerance, claim: 'auth_time' });
         }
     }
-    switch (expectedNonce) {
-        case undefined:
-        case expectNoNonce:
-            if (claims.nonce !== undefined) {
-                throw new OPE('unexpected ID Token "nonce" claim value');
-            }
-            break;
-        default:
-            if (!validateString(expectedNonce)) {
-                throw new TypeError('"expectedNonce" must be a non-empty string');
-            }
-            if (claims.nonce === undefined) {
-                throw new OPE('ID Token "nonce" claim missing');
-            }
-            if (claims.nonce !== expectedNonce) {
-                throw new OPE('unexpected ID Token "nonce" claim value');
-            }
+    if (expectedNonce === expectNoNonce) {
+        if (claims.nonce !== undefined) {
+            throw OPE('unexpected ID Token "nonce" claim value', JWT_CLAIM_COMPARISON, {
+                expected: undefined,
+                claims,
+                claim: 'nonce',
+            });
+        }
+    }
+    else if (claims.nonce !== expectedNonce) {
+        throw OPE('unexpected ID Token "nonce" claim value', JWT_CLAIM_COMPARISON, {
+            expected: expectedNonce,
+            claims,
+            claim: 'nonce',
+        });
     }
     return result;
 }
-export async function processAuthorizationCodeOAuth2Response(as, client, response) {
-    const result = await processGenericAccessTokenResponse(as, client, response, true);
-    if (isOAuth2Error(result)) {
-        return result;
-    }
-    if (result.id_token !== undefined) {
-        if (typeof result.id_token === 'string' && result.id_token.length) {
-            throw new OPE('Unexpected ID Token returned, use processAuthorizationCodeOpenIDResponse() for OpenID Connect callback processing');
+async function processAuthorizationCodeOAuth2Response(as, client, response, options) {
+    const result = await processGenericAccessTokenResponse(as, client, response, undefined, options);
+    const claims = getValidatedIdTokenClaims(result);
+    if (claims) {
+        if (client.default_max_age !== undefined) {
+            assertNumber(client.default_max_age, false, '"client.default_max_age"');
+            const now = epochTime() + getClockSkew(client);
+            const tolerance = getClockTolerance(client);
+            if (claims.auth_time + client.default_max_age < now - tolerance) {
+                throw OPE('too much time has elapsed since the last End-User authentication', JWT_TIMESTAMP_CHECK, { claims, now, tolerance, claim: 'auth_time' });
+            }
+        }
+        if (claims.nonce !== undefined) {
+            throw OPE('unexpected ID Token "nonce" claim value', JWT_CLAIM_COMPARISON, {
+                expected: undefined,
+                claims,
+                claim: 'nonce',
+            });
         }
-        delete result.id_token;
     }
     return result;
 }
+export const WWW_AUTHENTICATE_CHALLENGE = 'OAUTH_WWW_AUTHENTICATE_CHALLENGE';
+export const RESPONSE_BODY_ERROR = 'OAUTH_RESPONSE_BODY_ERROR';
+export const UNSUPPORTED_OPERATION = 'OAUTH_UNSUPPORTED_OPERATION';
+export const AUTHORIZATION_RESPONSE_ERROR = 'OAUTH_AUTHORIZATION_RESPONSE_ERROR';
+export const JWT_USERINFO_EXPECTED = 'OAUTH_JWT_USERINFO_EXPECTED';
+export const PARSE_ERROR = 'OAUTH_PARSE_ERROR';
+export const INVALID_RESPONSE = 'OAUTH_INVALID_RESPONSE';
+export const INVALID_REQUEST = 'OAUTH_INVALID_REQUEST';
+export const RESPONSE_IS_NOT_JSON = 'OAUTH_RESPONSE_IS_NOT_JSON';
+export const RESPONSE_IS_NOT_CONFORM = 'OAUTH_RESPONSE_IS_NOT_CONFORM';
+export const HTTP_REQUEST_FORBIDDEN = 'OAUTH_HTTP_REQUEST_FORBIDDEN';
+export const REQUEST_PROTOCOL_FORBIDDEN = 'OAUTH_REQUEST_PROTOCOL_FORBIDDEN';
+export const JWT_TIMESTAMP_CHECK = 'OAUTH_JWT_TIMESTAMP_CHECK_FAILED';
+export const JWT_CLAIM_COMPARISON = 'OAUTH_JWT_CLAIM_COMPARISON_FAILED';
+export const JSON_ATTRIBUTE_COMPARISON = 'OAUTH_JSON_ATTRIBUTE_COMPARISON_FAILED';
+export const KEY_SELECTION = 'OAUTH_KEY_SELECTION_FAILED';
+export const MISSING_SERVER_METADATA = 'OAUTH_MISSING_SERVER_METADATA';
+export const INVALID_SERVER_METADATA = 'OAUTH_INVALID_SERVER_METADATA';
 function checkJwtType(expected, result) {
     if (typeof result.header.typ !== 'string' || normalizeTyp(result.header.typ) !== expected) {
-        throw new OPE('unexpected JWT "typ" header parameter value');
+        throw OPE('unexpected JWT "typ" header parameter value', INVALID_RESPONSE, {
+            header: result.header,
+        });
     }
     return result;
 }
-export async function clientCredentialsGrantRequest(as, client, parameters, options) {
+export async function clientCredentialsGrantRequest(as, client, clientAuthentication, parameters, options) {
     assertAs(as);
     assertClient(client);
-    return tokenEndpointRequest(as, client, 'client_credentials', new URLSearchParams(parameters), options);
+    return tokenEndpointRequest(as, client, clientAuthentication, 'client_credentials', new URLSearchParams(parameters), options);
 }
-export async function genericTokenEndpointRequest(as, client, grantType, parameters, options) {
+export async function genericTokenEndpointRequest(as, client, clientAuthentication, grantType, parameters, options) {
     assertAs(as);
     assertClient(client);
-    if (!validateString(grantType)) {
-        throw new TypeError('"grantType" must be a non-empty string');
-    }
-    return tokenEndpointRequest(as, client, grantType, new URLSearchParams(parameters), options);
+    assertString(grantType, '"grantType"');
+    return tokenEndpointRequest(as, client, clientAuthentication, grantType, new URLSearchParams(parameters), options);
 }
-export async function processClientCredentialsResponse(as, client, response) {
-    const result = await processGenericAccessTokenResponse(as, client, response, true, true);
-    if (isOAuth2Error(result)) {
-        return result;
-    }
-    return result;
+export async function processGenericTokenEndpointResponse(as, client, response, options) {
+    return processGenericAccessTokenResponse(as, client, response, undefined, options);
 }
-export async function revocationRequest(as, client, token, options) {
+export async function processClientCredentialsResponse(as, client, response, options) {
+    return processGenericAccessTokenResponse(as, client, response, undefined, options);
+}
+export async function revocationRequest(as, client, clientAuthentication, token, options) {
     assertAs(as);
     assertClient(client);
-    if (!validateString(token)) {
-        throw new TypeError('"token" must be a non-empty string');
-    }
-    const url = resolveEndpoint(as, 'revocation_endpoint', alias(client, options));
+    assertString(token, '"token"');
+    const url = resolveEndpoint(as, 'revocation_endpoint', client.use_mtls_endpoint_aliases, options?.[allowInsecureRequests] !== true);
     const body = new URLSearchParams(options?.additionalParameters);
     body.set('token', token);
     const headers = prepareHeaders(options?.headers);
     headers.delete('accept');
-    return authenticatedRequest(as, client, 'POST', url, body, headers, options);
+    return authenticatedRequest(as, client, clientAuthentication, url, body, headers, options);
 }
 export async function processRevocationResponse(response) {
     if (!looseInstanceOf(response, Response)) {
-        throw new TypeError('"response" must be an instance of Response');
+        throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE);
+    }
+    let challenges;
+    if ((challenges = parseWwwAuthenticateChallenges(response))) {
+        throw new WWWAuthenticateChallengeError('server responded with a challenge in the WWW-Authenticate HTTP Header', { cause: challenges, response });
     }
     if (response.status !== 200) {
         let err;
         if ((err = await handleOAuthBodyError(response))) {
-            return err;
+            await response.body?.cancel();
+            throw new ResponseBodyError('server responded with an error in the response body', {
+                cause: err,
+                response,
+            });
         }
-        throw new OPE('"response" is not a conform Revocation Endpoint response');
+        throw OPE('"response" is not a conform Revocation Endpoint response', RESPONSE_IS_NOT_CONFORM, response);
     }
     return undefined;
 }
 function assertReadableResponse(response) {
     if (response.bodyUsed) {
-        throw new TypeError('"response" body has been used already');
+        throw CodedTypeError('"response" body has been used already', ERR_INVALID_ARG_VALUE);
     }
 }
-export async function introspectionRequest(as, client, token, options) {
+export async function introspectionRequest(as, client, clientAuthentication, token, options) {
     assertAs(as);
     assertClient(client);
-    if (!validateString(token)) {
-        throw new TypeError('"token" must be a non-empty string');
-    }
-    const url = resolveEndpoint(as, 'introspection_endpoint', alias(client, options));
+    assertString(token, '"token"');
+    const url = resolveEndpoint(as, 'introspection_endpoint', client.use_mtls_endpoint_aliases, options?.[allowInsecureRequests] !== true);
     const body = new URLSearchParams(options?.additionalParameters);
     body.set('token', token);
     const headers = prepareHeaders(options?.headers);
@@ -1275,109 +1469,113 @@ export async function introspectionRequest(as, client, token, options) {
     else {
         headers.set('accept', 'application/json');
     }
-    return authenticatedRequest(as, client, 'POST', url, body, headers, options);
+    return authenticatedRequest(as, client, clientAuthentication, url, body, headers, options);
 }
-export async function processIntrospectionResponse(as, client, response) {
+export async function processIntrospectionResponse(as, client, response, options) {
     assertAs(as);
     assertClient(client);
     if (!looseInstanceOf(response, Response)) {
-        throw new TypeError('"response" must be an instance of Response');
+        throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE);
+    }
+    let challenges;
+    if ((challenges = parseWwwAuthenticateChallenges(response))) {
+        throw new WWWAuthenticateChallengeError('server responded with a challenge in the WWW-Authenticate HTTP Header', { cause: challenges, response });
     }
     if (response.status !== 200) {
         let err;
         if ((err = await handleOAuthBodyError(response))) {
-            return err;
+            await response.body?.cancel();
+            throw new ResponseBodyError('server responded with an error in the response body', {
+                cause: err,
+                response,
+            });
         }
-        throw new OPE('"response" is not a conform Introspection Endpoint response');
+        throw OPE('"response" is not a conform Introspection Endpoint response', RESPONSE_IS_NOT_CONFORM, response);
     }
     let json;
     if (getContentType(response) === 'application/token-introspection+jwt') {
         assertReadableResponse(response);
-        const { claims, jwt } = await validateJwt(await response.text(), checkSigningAlgorithm.bind(undefined, client.introspection_signed_response_alg, as.introspection_signing_alg_values_supported), noSignatureCheck, getClockSkew(client), getClockTolerance(client), client[jweDecrypt])
+        const { claims, jwt } = await validateJwt(await response.text(), checkSigningAlgorithm.bind(undefined, client.introspection_signed_response_alg, as.introspection_signing_alg_values_supported, 'RS256'), getClockSkew(client), getClockTolerance(client), options?.[jweDecrypt])
             .then(checkJwtType.bind(undefined, 'token-introspection+jwt'))
             .then(validatePresence.bind(undefined, ['aud', 'iat', 'iss']))
-            .then(validateIssuer.bind(undefined, as.issuer))
+            .then(validateIssuer.bind(undefined, as))
             .then(validateAudience.bind(undefined, client.client_id));
-        jwtResponseBodies.set(response, jwt);
+        jwtRefs.set(response, jwt);
         json = claims.token_introspection;
         if (!isJsonObject(json)) {
-            throw new OPE('JWT "token_introspection" claim must be a JSON object');
+            throw OPE('JWT "token_introspection" claim must be a JSON object', INVALID_RESPONSE, {
+                claims,
+            });
         }
     }
     else {
         assertReadableResponse(response);
+        assertApplicationJson(response);
         try {
             json = await response.json();
         }
         catch (cause) {
-            throw new OPE('failed to parse "response" body as JSON', { cause });
+            throw OPE('failed to parse "response" body as JSON', PARSE_ERROR, cause);
         }
         if (!isJsonObject(json)) {
-            throw new OPE('"response" body must be a top level object');
+            throw OPE('"response" body must be a top level object', INVALID_RESPONSE, { body: json });
         }
     }
     if (typeof json.active !== 'boolean') {
-        throw new OPE('"response" body "active" property must be a boolean');
+        throw OPE('"response" body "active" property must be a boolean', INVALID_RESPONSE, {
+            body: json,
+        });
     }
     return json;
 }
 async function jwksRequest(as, options) {
     assertAs(as);
-    const url = resolveEndpoint(as, 'jwks_uri');
+    const url = resolveEndpoint(as, 'jwks_uri', false, options?.[allowInsecureRequests] !== true);
     const headers = prepareHeaders(options?.headers);
     headers.set('accept', 'application/json');
     headers.append('accept', 'application/jwk-set+json');
     return (options?.[customFetch] || fetch)(url.href, {
+        body: undefined,
         headers: Object.fromEntries(headers.entries()),
         method: 'GET',
         redirect: 'manual',
-        signal: options?.signal ? signal(options.signal) : null,
-    }).then(processDpopNonce);
+        signal: options?.signal ? signal(options.signal) : undefined,
+    });
 }
 async function processJwksResponse(response) {
     if (!looseInstanceOf(response, Response)) {
-        throw new TypeError('"response" must be an instance of Response');
+        throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE);
     }
     if (response.status !== 200) {
-        throw new OPE('"response" is not a conform JSON Web Key Set response');
+        throw OPE('"response" is not a conform JSON Web Key Set response', RESPONSE_IS_NOT_CONFORM, response);
     }
     assertReadableResponse(response);
+    assertContentTypes(response, 'application/json', 'application/jwk-set+json');
     let json;
     try {
         json = await response.json();
     }
     catch (cause) {
-        throw new OPE('failed to parse "response" body as JSON', { cause });
+        throw OPE('failed to parse "response" body as JSON', PARSE_ERROR, cause);
     }
     if (!isJsonObject(json)) {
-        throw new OPE('"response" body must be a top level object');
+        throw OPE('"response" body must be a top level object', INVALID_RESPONSE, { body: json });
     }
     if (!Array.isArray(json.keys)) {
-        throw new OPE('"response" body "keys" property must be an array');
+        throw OPE('"response" body "keys" property must be an array', INVALID_RESPONSE, { body: json });
     }
     if (!Array.prototype.every.call(json.keys, isJsonObject)) {
-        throw new OPE('"response" body "keys" property members must be JWK formatted objects');
+        throw OPE('"response" body "keys" property members must be JWK formatted objects', INVALID_RESPONSE, { body: json });
     }
     return json;
 }
 async function handleOAuthBodyError(response) {
     if (response.status > 399 && response.status < 500) {
         assertReadableResponse(response);
+        assertApplicationJson(response);
         try {
-            const json = await response.json();
+            const json = await response.clone().json();
             if (isJsonObject(json) && typeof json.error === 'string' && json.error.length) {
-                if (json.error_description !== undefined && typeof json.error_description !== 'string') {
-                    delete json.error_description;
-                }
-                if (json.error_uri !== undefined && typeof json.error_uri !== 'string') {
-                    delete json.error_uri;
-                }
-                if (json.algs !== undefined && typeof json.algs !== 'string') {
-                    delete json.algs;
-                }
-                if (json.scope !== undefined && typeof json.scope !== 'string') {
-                    delete json.scope;
-                }
                 return json;
             }
         }
@@ -1385,19 +1583,42 @@ async function handleOAuthBodyError(response) {
     }
     return undefined;
 }
-function checkSupportedJwsAlg(alg) {
-    if (!SUPPORTED_JWS_ALGS.includes(alg)) {
-        throw new UnsupportedOperationError('unsupported JWS "alg" identifier');
+function supported(alg) {
+    switch (alg) {
+        case 'PS256':
+        case 'ES256':
+        case 'RS256':
+        case 'PS384':
+        case 'ES384':
+        case 'RS384':
+        case 'PS512':
+        case 'ES512':
+        case 'RS512':
+        case 'Ed25519':
+        case 'EdDSA':
+            return true;
+        default:
+            return false;
     }
-    return alg;
 }
-function checkRsaKeyAlgorithm(algorithm) {
+function checkSupportedJwsAlg(header) {
+    if (!supported(header.alg)) {
+        throw new UnsupportedOperationError('unsupported JWS "alg" identifier', {
+            cause: { alg: header.alg },
+        });
+    }
+}
+function checkRsaKeyAlgorithm(key) {
+    const { algorithm } = key;
     if (typeof algorithm.modulusLength !== 'number' || algorithm.modulusLength < 2048) {
-        throw new OPE(`${algorithm.name} modulusLength must be at least 2048 bits`);
+        throw new UnsupportedOperationError(`unsupported ${algorithm.name} modulusLength`, {
+            cause: key,
+        });
     }
 }
-function ecdsaHashName(namedCurve) {
-    switch (namedCurve) {
+function ecdsaHashName(key) {
+    const { algorithm } = key;
+    switch (algorithm.namedCurve) {
         case 'P-256':
             return 'SHA-256';
         case 'P-384':
@@ -1405,7 +1626,7 @@ function ecdsaHashName(namedCurve) {
         case 'P-521':
             return 'SHA-512';
         default:
-            throw new UnsupportedOperationError();
+            throw new UnsupportedOperationError('unsupported ECDSA namedCurve', { cause: key });
     }
 }
 function keyToSubtle(key) {
@@ -1413,10 +1634,10 @@ function keyToSubtle(key) {
         case 'ECDSA':
             return {
                 name: key.algorithm.name,
-                hash: ecdsaHashName(key.algorithm.namedCurve),
+                hash: ecdsaHashName(key),
             };
         case 'RSA-PSS': {
-            checkRsaKeyAlgorithm(key.algorithm);
+            checkRsaKeyAlgorithm(key);
             switch (key.algorithm.hash.name) {
                 case 'SHA-256':
                 case 'SHA-384':
@@ -1426,103 +1647,109 @@ function keyToSubtle(key) {
                         saltLength: parseInt(key.algorithm.hash.name.slice(-3), 10) >> 3,
                     };
                 default:
-                    throw new UnsupportedOperationError();
+                    throw new UnsupportedOperationError('unsupported RSA-PSS hash name', { cause: key });
             }
         }
         case 'RSASSA-PKCS1-v1_5':
-            checkRsaKeyAlgorithm(key.algorithm);
+            checkRsaKeyAlgorithm(key);
             return key.algorithm.name;
-        case 'Ed448':
         case 'Ed25519':
+        case 'EdDSA':
             return key.algorithm.name;
     }
-    throw new UnsupportedOperationError();
+    throw new UnsupportedOperationError('unsupported CryptoKey algorithm name', { cause: key });
 }
-const noSignatureCheck = Symbol();
 async function validateJwsSignature(protectedHeader, payload, key, signature) {
-    const input = `${protectedHeader}.${payload}`;
-    const verified = await crypto.subtle.verify(keyToSubtle(key), key, signature, buf(input));
+    const data = buf(`${protectedHeader}.${payload}`);
+    const algorithm = keyToSubtle(key);
+    const verified = await crypto.subtle.verify(algorithm, key, signature, data);
     if (!verified) {
-        throw new OPE('JWT signature verification failed');
+        throw OPE('JWT signature verification failed', INVALID_RESPONSE, {
+            key,
+            data,
+            signature,
+            algorithm,
+        });
     }
 }
-async function validateJwt(jws, checkAlg, getKey, clockSkew, clockTolerance, decryptJwt) {
-    let { 0: protectedHeader, 1: payload, 2: encodedSignature, length } = jws.split('.');
+async function validateJwt(jws, checkAlg, clockSkew, clockTolerance, decryptJwt) {
+    let { 0: protectedHeader, 1: payload, length } = jws.split('.');
     if (length === 5) {
         if (decryptJwt !== undefined) {
             jws = await decryptJwt(jws);
-            ({ 0: protectedHeader, 1: payload, 2: encodedSignature, length } = jws.split('.'));
+            ({ 0: protectedHeader, 1: payload, length } = jws.split('.'));
         }
         else {
-            throw new UnsupportedOperationError('JWE structure JWTs are not supported');
+            throw new UnsupportedOperationError('JWE decryption is not configured', { cause: jws });
         }
     }
     if (length !== 3) {
-        throw new OPE('Invalid JWT');
+        throw OPE('Invalid JWT', INVALID_RESPONSE, jws);
     }
     let header;
     try {
         header = JSON.parse(buf(b64u(protectedHeader)));
     }
     catch (cause) {
-        throw new OPE('failed to parse JWT Header body as base64url encoded JSON', { cause });
+        throw OPE('failed to parse JWT Header body as base64url encoded JSON', PARSE_ERROR, cause);
     }
     if (!isJsonObject(header)) {
-        throw new OPE('JWT Header must be a top level object');
+        throw OPE('JWT Header must be a top level object', INVALID_RESPONSE, jws);
     }
     checkAlg(header);
     if (header.crit !== undefined) {
-        throw new OPE('unexpected JWT "crit" header parameter');
-    }
-    const signature = b64u(encodedSignature);
-    let key;
-    if (getKey !== noSignatureCheck) {
-        key = await getKey(header);
-        await validateJwsSignature(protectedHeader, payload, key, signature);
+        throw new UnsupportedOperationError('no JWT "crit" header parameter extensions are supported', {
+            cause: { header },
+        });
     }
     let claims;
     try {
         claims = JSON.parse(buf(b64u(payload)));
     }
     catch (cause) {
-        throw new OPE('failed to parse JWT Payload body as base64url encoded JSON', { cause });
+        throw OPE('failed to parse JWT Payload body as base64url encoded JSON', PARSE_ERROR, cause);
     }
     if (!isJsonObject(claims)) {
-        throw new OPE('JWT Payload must be a top level object');
+        throw OPE('JWT Payload must be a top level object', INVALID_RESPONSE, jws);
     }
     const now = epochTime() + clockSkew;
     if (claims.exp !== undefined) {
         if (typeof claims.exp !== 'number') {
-            throw new OPE('unexpected JWT "exp" (expiration time) claim type');
+            throw OPE('unexpected JWT "exp" (expiration time) claim type', INVALID_RESPONSE, { claims });
         }
         if (claims.exp <= now - clockTolerance) {
-            throw new OPE('unexpected JWT "exp" (expiration time) claim value, timestamp is <= now()');
+            throw OPE('unexpected JWT "exp" (expiration time) claim value, expiration is past current timestamp', JWT_TIMESTAMP_CHECK, { claims, now, tolerance: clockTolerance, claim: 'exp' });
         }
     }
     if (claims.iat !== undefined) {
         if (typeof claims.iat !== 'number') {
-            throw new OPE('unexpected JWT "iat" (issued at) claim type');
+            throw OPE('unexpected JWT "iat" (issued at) claim type', INVALID_RESPONSE, { claims });
         }
     }
     if (claims.iss !== undefined) {
         if (typeof claims.iss !== 'string') {
-            throw new OPE('unexpected JWT "iss" (issuer) claim type');
+            throw OPE('unexpected JWT "iss" (issuer) claim type', INVALID_RESPONSE, { claims });
         }
     }
     if (claims.nbf !== undefined) {
         if (typeof claims.nbf !== 'number') {
-            throw new OPE('unexpected JWT "nbf" (not before) claim type');
+            throw OPE('unexpected JWT "nbf" (not before) claim type', INVALID_RESPONSE, { claims });
         }
         if (claims.nbf > now + clockTolerance) {
-            throw new OPE('unexpected JWT "nbf" (not before) claim value, timestamp is > now()');
+            throw OPE('unexpected JWT "nbf" (not before) claim value', JWT_TIMESTAMP_CHECK, {
+                claims,
+                now,
+                tolerance: clockTolerance,
+                claim: 'nbf',
+            });
         }
     }
     if (claims.aud !== undefined) {
         if (typeof claims.aud !== 'string' && !Array.isArray(claims.aud)) {
-            throw new OPE('unexpected JWT "aud" (audience) claim type');
+            throw OPE('unexpected JWT "aud" (audience) claim type', INVALID_RESPONSE, { claims });
         }
     }
-    return { header, claims, signature, key, jwt: jws };
+    return { header, claims, jwt: jws };
 }
 export async function validateJwtAuthResponse(as, client, parameters, expectedState, options) {
     assertAs(as);
@@ -1531,16 +1758,20 @@ export async function validateJwtAuthResponse(as, client, parameters, expectedSt
         parameters = parameters.searchParams;
     }
     if (!(parameters instanceof URLSearchParams)) {
-        throw new TypeError('"parameters" must be an instance of URLSearchParams, or URL');
+        throw CodedTypeError('"parameters" must be an instance of URLSearchParams, or URL', ERR_INVALID_ARG_TYPE);
     }
     const response = getURLSearchParameter(parameters, 'response');
     if (!response) {
-        throw new OPE('"parameters" does not contain a JARM response');
+        throw OPE('"parameters" does not contain a JARM response', INVALID_RESPONSE);
     }
-    const { claims } = await validateJwt(response, checkSigningAlgorithm.bind(undefined, client.authorization_signed_response_alg, as.authorization_signing_alg_values_supported), getPublicSigKeyFromIssuerJwksUri.bind(undefined, as, options), getClockSkew(client), getClockTolerance(client), client[jweDecrypt])
+    const { claims, header, jwt } = await validateJwt(response, checkSigningAlgorithm.bind(undefined, client.authorization_signed_response_alg, as.authorization_signing_alg_values_supported, 'RS256'), getClockSkew(client), getClockTolerance(client), options?.[jweDecrypt])
         .then(validatePresence.bind(undefined, ['aud', 'exp', 'iss']))
-        .then(validateIssuer.bind(undefined, as.issuer))
+        .then(validateIssuer.bind(undefined, as))
         .then(validateAudience.bind(undefined, client.client_id));
+    const { 0: protectedHeader, 1: payload, 2: encodedSignature } = jwt.split('.');
+    const signature = b64u(encodedSignature);
+    const key = await getPublicSigKeyFromIssuerJwksUri(as, options, header);
+    await validateJwsSignature(protectedHeader, payload, key, signature);
     const result = new URLSearchParams();
     for (const [key, value] of Object.entries(claims)) {
         if (typeof value === 'string' && key !== 'aud') {
@@ -1549,9 +1780,9 @@ export async function validateJwtAuthResponse(as, client, parameters, expectedSt
     }
     return validateAuthResponse(as, client, result, expectedState);
 }
-async function idTokenHash(alg, data, key) {
+async function idTokenHash(data, header, claimName) {
     let algorithm;
-    switch (alg) {
+    switch (header.alg) {
         case 'RS256':
         case 'PS256':
         case 'ES256':
@@ -1565,35 +1796,37 @@ async function idTokenHash(alg, data, key) {
         case 'RS512':
         case 'PS512':
         case 'ES512':
+        case 'Ed25519':
+        case 'EdDSA':
             algorithm = 'SHA-512';
             break;
-        case 'EdDSA':
-            if (key.algorithm.name === 'Ed25519') {
-                algorithm = 'SHA-512';
-                break;
-            }
-            throw new UnsupportedOperationError();
         default:
-            throw new UnsupportedOperationError();
+            throw new UnsupportedOperationError(`unsupported JWS algorithm for ${claimName} calculation`, { cause: { alg: header.alg } });
     }
     const digest = await crypto.subtle.digest(algorithm, buf(data));
     return b64u(digest.slice(0, digest.byteLength / 2));
 }
-async function idTokenHashMatches(data, actual, alg, key) {
-    const expected = await idTokenHash(alg, data, key);
+async function idTokenHashMatches(data, actual, header, claimName) {
+    const expected = await idTokenHash(data, header, claimName);
     return actual === expected;
 }
 export async function validateDetachedSignatureResponse(as, client, parameters, expectedNonce, expectedState, maxAge, options) {
+    return validateHybridResponse(as, client, parameters, expectedNonce, expectedState, maxAge, options, true);
+}
+export async function validateCodeIdTokenResponse(as, client, parameters, expectedNonce, expectedState, maxAge, options) {
+    return validateHybridResponse(as, client, parameters, expectedNonce, expectedState, maxAge, options, false);
+}
+async function validateHybridResponse(as, client, parameters, expectedNonce, expectedState, maxAge, options, fapi) {
     assertAs(as);
     assertClient(client);
     if (parameters instanceof URL) {
         if (!parameters.hash.length) {
-            throw new TypeError('"parameters" as an instance of URL must contain a hash (fragment) with the Authorization Response parameters');
+            throw CodedTypeError('"parameters" as an instance of URL must contain a hash (fragment) with the Authorization Response parameters', ERR_INVALID_ARG_VALUE);
         }
         parameters = new URLSearchParams(parameters.hash.slice(1));
     }
     if (!(parameters instanceof URLSearchParams)) {
-        throw new TypeError('"parameters" must be an instance of URLSearchParams');
+        throw CodedTypeError('"parameters" must be an instance of URLSearchParams', ERR_INVALID_ARG_TYPE);
     }
     parameters = new URLSearchParams(parameters);
     const id_token = getURLSearchParameter(parameters, 'id_token');
@@ -1603,23 +1836,18 @@ export async function validateDetachedSignatureResponse(as, client, parameters,
         case expectNoState:
             break;
         default:
-            if (!validateString(expectedState)) {
-                throw new TypeError('"expectedState" must be a non-empty string');
-            }
+            assertString(expectedState, '"expectedState" argument');
     }
     const result = validateAuthResponse({
         ...as,
         authorization_response_iss_parameter_supported: false,
     }, client, parameters, expectedState);
-    if (isOAuth2Error(result)) {
-        return result;
-    }
     if (!id_token) {
-        throw new OPE('"parameters" does not contain an ID Token');
+        throw OPE('"parameters" does not contain an ID Token', INVALID_RESPONSE);
     }
     const code = getURLSearchParameter(parameters, 'code');
     if (!code) {
-        throw new OPE('"parameters" does not contain an Authorization Code');
+        throw OPE('"parameters" does not contain an Authorization Code', INVALID_RESPONSE);
     }
     const requiredClaims = [
         'aud',
@@ -1630,86 +1858,132 @@ export async function validateDetachedSignatureResponse(as, client, parameters,
         'nonce',
         'c_hash',
     ];
-    if (typeof expectedState === 'string') {
+    const state = parameters.get('state');
+    if (fapi && (typeof expectedState === 'string' || state !== null)) {
         requiredClaims.push('s_hash');
     }
-    const { claims, header, key } = await validateJwt(id_token, checkSigningAlgorithm.bind(undefined, client.id_token_signed_response_alg, as.id_token_signing_alg_values_supported), getPublicSigKeyFromIssuerJwksUri.bind(undefined, as, options), getClockSkew(client), getClockTolerance(client), client[jweDecrypt])
+    if (maxAge !== undefined) {
+        assertNumber(maxAge, false, '"maxAge" argument');
+    }
+    else if (client.default_max_age !== undefined) {
+        assertNumber(client.default_max_age, false, '"client.default_max_age"');
+    }
+    maxAge ??= client.default_max_age ?? skipAuthTimeCheck;
+    if (client.require_auth_time || maxAge !== skipAuthTimeCheck) {
+        requiredClaims.push('auth_time');
+    }
+    const { claims, header, jwt } = await validateJwt(id_token, checkSigningAlgorithm.bind(undefined, client.id_token_signed_response_alg, as.id_token_signing_alg_values_supported, 'RS256'), getClockSkew(client), getClockTolerance(client), options?.[jweDecrypt])
         .then(validatePresence.bind(undefined, requiredClaims))
-        .then(validateIssuer.bind(undefined, as.issuer))
+        .then(validateIssuer.bind(undefined, as))
         .then(validateAudience.bind(undefined, client.client_id));
     const clockSkew = getClockSkew(client);
     const now = epochTime() + clockSkew;
     if (claims.iat < now - 3600) {
-        throw new OPE('unexpected JWT "iat" (issued at) claim value, it is too far in the past');
+        throw OPE('unexpected JWT "iat" (issued at) claim value, it is too far in the past', JWT_TIMESTAMP_CHECK, { now, claims, claim: 'iat' });
     }
-    if (typeof claims.c_hash !== 'string' ||
-        (await idTokenHashMatches(code, claims.c_hash, header.alg, key)) !== true) {
-        throw new OPE('invalid ID Token "c_hash" (code hash) claim value');
-    }
-    if (claims.s_hash !== undefined && typeof expectedState !== 'string') {
-        throw new OPE('could not verify ID Token "s_hash" (state hash) claim value');
-    }
-    if (typeof expectedState === 'string' &&
-        (typeof claims.s_hash !== 'string' ||
-            (await idTokenHashMatches(expectedState, claims.s_hash, header.alg, key)) !== true)) {
-        throw new OPE('invalid ID Token "s_hash" (state hash) claim value');
-    }
-    if (claims.auth_time !== undefined &&
-        (!Number.isFinite(claims.auth_time) || Math.sign(claims.auth_time) !== 1)) {
-        throw new OPE('ID Token "auth_time" (authentication time) must be a positive number');
-    }
-    maxAge ?? (maxAge = client.default_max_age ?? skipAuthTimeCheck);
-    if ((client.require_auth_time || maxAge !== skipAuthTimeCheck) &&
-        claims.auth_time === undefined) {
-        throw new OPE('ID Token "auth_time" (authentication time) claim missing');
+    assertString(claims.c_hash, 'ID Token "c_hash" (code hash) claim value', INVALID_RESPONSE, {
+        claims,
+    });
+    if (claims.auth_time !== undefined) {
+        assertNumber(claims.auth_time, false, 'ID Token "auth_time" (authentication time)', INVALID_RESPONSE, { claims });
     }
     if (maxAge !== skipAuthTimeCheck) {
-        if (typeof maxAge !== 'number' || maxAge < 0) {
-            throw new TypeError('"maxAge" must be a non-negative number');
-        }
         const now = epochTime() + getClockSkew(client);
         const tolerance = getClockTolerance(client);
         if (claims.auth_time + maxAge < now - tolerance) {
-            throw new OPE('too much time has elapsed since the last End-User authentication');
+            throw OPE('too much time has elapsed since the last End-User authentication', JWT_TIMESTAMP_CHECK, { claims, now, tolerance, claim: 'auth_time' });
         }
     }
-    if (!validateString(expectedNonce)) {
-        throw new TypeError('"expectedNonce" must be a non-empty string');
-    }
+    assertString(expectedNonce, '"expectedNonce" argument');
     if (claims.nonce !== expectedNonce) {
-        throw new OPE('unexpected ID Token "nonce" claim value');
+        throw OPE('unexpected ID Token "nonce" claim value', JWT_CLAIM_COMPARISON, {
+            expected: expectedNonce,
+            claims,
+            claim: 'nonce',
+        });
     }
     if (Array.isArray(claims.aud) && claims.aud.length !== 1) {
         if (claims.azp === undefined) {
-            throw new OPE('ID Token "aud" (audience) claim includes additional untrusted audiences');
+            throw OPE('ID Token "aud" (audience) claim includes additional untrusted audiences', JWT_CLAIM_COMPARISON, { claims, claim: 'aud' });
         }
         if (claims.azp !== client.client_id) {
-            throw new OPE('unexpected ID Token "azp" (authorized party) claim value');
+            throw OPE('unexpected ID Token "azp" (authorized party) claim value', JWT_CLAIM_COMPARISON, {
+                expected: client.client_id,
+                claims,
+                claim: 'azp',
+            });
+        }
+    }
+    const { 0: protectedHeader, 1: payload, 2: encodedSignature } = jwt.split('.');
+    const signature = b64u(encodedSignature);
+    const key = await getPublicSigKeyFromIssuerJwksUri(as, options, header);
+    await validateJwsSignature(protectedHeader, payload, key, signature);
+    if ((await idTokenHashMatches(code, claims.c_hash, header, 'c_hash')) !== true) {
+        throw OPE('invalid ID Token "c_hash" (code hash) claim value', JWT_CLAIM_COMPARISON, {
+            code,
+            alg: header.alg,
+            claim: 'c_hash',
+            claims,
+        });
+    }
+    if ((fapi && state !== null) || claims.s_hash !== undefined) {
+        assertString(claims.s_hash, 'ID Token "s_hash" (state hash) claim value', INVALID_RESPONSE, {
+            claims,
+        });
+        assertString(state, '"state" response parameter', INVALID_RESPONSE, { parameters });
+        if ((await idTokenHashMatches(state, claims.s_hash, header, 's_hash')) !== true) {
+            throw OPE('invalid ID Token "s_hash" (state hash) claim value', JWT_CLAIM_COMPARISON, {
+                state,
+                alg: header.alg,
+                claim: 's_hash',
+                claims,
+            });
         }
     }
     return result;
 }
-function checkSigningAlgorithm(client, issuer, header) {
+const SUPPORTED_JWS_ALGS = Symbol();
+function checkSigningAlgorithm(client, issuer, fallback, header) {
     if (client !== undefined) {
-        if (header.alg !== client) {
-            throw new OPE('unexpected JWT "alg" header parameter');
+        if (typeof client === 'string' ? header.alg !== client : !client.includes(header.alg)) {
+            throw OPE('unexpected JWT "alg" header parameter', INVALID_RESPONSE, {
+                header,
+                expected: client,
+                reason: 'client configuration',
+            });
         }
         return;
     }
     if (Array.isArray(issuer)) {
         if (!issuer.includes(header.alg)) {
-            throw new OPE('unexpected JWT "alg" header parameter');
+            throw OPE('unexpected JWT "alg" header parameter', INVALID_RESPONSE, {
+                header,
+                expected: issuer,
+                reason: 'authorization server metadata',
+            });
         }
         return;
     }
-    if (header.alg !== 'RS256') {
-        throw new OPE('unexpected JWT "alg" header parameter');
+    if (fallback !== undefined) {
+        if (typeof fallback === 'string'
+            ? header.alg !== fallback
+            : typeof fallback === 'symbol'
+                ? !supported(header.alg)
+                : !fallback.includes(header.alg)) {
+            throw OPE('unexpected JWT "alg" header parameter', INVALID_RESPONSE, {
+                header,
+                expected: fallback,
+                reason: 'default value',
+            });
+        }
+        return;
     }
+    throw OPE('missing client or server configuration to verify used JWT "alg" header parameter', undefined, { client, issuer, fallback });
 }
 function getURLSearchParameter(parameters, name) {
     const { 0: value, length } = parameters.getAll(name);
     if (length > 1) {
-        throw new OPE(`"${name}" parameter must be provided only once`);
+        throw OPE(`"${name}" parameter must be provided only once`, INVALID_RESPONSE);
     }
     return value;
 }
@@ -1722,46 +1996,47 @@ export function validateAuthResponse(as, client, parameters, expectedState) {
         parameters = parameters.searchParams;
     }
     if (!(parameters instanceof URLSearchParams)) {
-        throw new TypeError('"parameters" must be an instance of URLSearchParams, or URL');
+        throw CodedTypeError('"parameters" must be an instance of URLSearchParams, or URL', ERR_INVALID_ARG_TYPE);
     }
     if (getURLSearchParameter(parameters, 'response')) {
-        throw new OPE('"parameters" contains a JARM response, use validateJwtAuthResponse() instead of validateAuthResponse()');
+        throw OPE('"parameters" contains a JARM response, use validateJwtAuthResponse() instead of validateAuthResponse()', INVALID_RESPONSE, { parameters });
     }
     const iss = getURLSearchParameter(parameters, 'iss');
     const state = getURLSearchParameter(parameters, 'state');
     if (!iss && as.authorization_response_iss_parameter_supported) {
-        throw new OPE('response parameter "iss" (issuer) missing');
+        throw OPE('response parameter "iss" (issuer) missing', INVALID_RESPONSE, { parameters });
     }
     if (iss && iss !== as.issuer) {
-        throw new OPE('unexpected "iss" (issuer) response parameter value');
+        throw OPE('unexpected "iss" (issuer) response parameter value', INVALID_RESPONSE, {
+            expected: as.issuer,
+            parameters,
+        });
     }
     switch (expectedState) {
         case undefined:
         case expectNoState:
             if (state !== undefined) {
-                throw new OPE('unexpected "state" response parameter encountered');
+                throw OPE('unexpected "state" response parameter encountered', INVALID_RESPONSE, {
+                    expected: undefined,
+                    parameters,
+                });
             }
             break;
         case skipStateCheck:
             break;
         default:
-            if (!validateString(expectedState)) {
-                throw new OPE('"expectedState" must be a non-empty string');
-            }
-            if (state === undefined) {
-                throw new OPE('response parameter "state" missing');
-            }
+            assertString(expectedState, '"expectedState" argument');
             if (state !== expectedState) {
-                throw new OPE('unexpected "state" response parameter value');
+                throw OPE(state === undefined
+                    ? 'response parameter "state" missing'
+                    : 'unexpected "state" response parameter value', INVALID_RESPONSE, { expected: expectedState, parameters });
             }
     }
     const error = getURLSearchParameter(parameters, 'error');
     if (error) {
-        return {
-            error,
-            error_description: getURLSearchParameter(parameters, 'error_description'),
-            error_uri: getURLSearchParameter(parameters, 'error_uri'),
-        };
+        throw new AuthorizationResponseError('authorization response from the server is an error', {
+            cause: parameters,
+        });
     }
     const id_token = getURLSearchParameter(parameters, 'id_token');
     const token = getURLSearchParameter(parameters, 'token');
@@ -1770,7 +2045,7 @@ export function validateAuthResponse(as, client, parameters, expectedState) {
     }
     return brand(new URLSearchParams(parameters));
 }
-function algToSubtle(alg, crv) {
+function algToSubtle(alg) {
     switch (alg) {
         case 'PS256':
         case 'PS384':
@@ -1785,96 +2060,94 @@ function algToSubtle(alg, crv) {
             return { name: 'ECDSA', namedCurve: `P-${alg.slice(-3)}` };
         case 'ES512':
             return { name: 'ECDSA', namedCurve: 'P-521' };
-        case 'EdDSA': {
-            switch (crv) {
-                case 'Ed25519':
-                case 'Ed448':
-                    return crv;
-                default:
-                    throw new UnsupportedOperationError();
-            }
-        }
+        case 'Ed25519':
+        case 'EdDSA':
+            return 'Ed25519';
         default:
-            throw new UnsupportedOperationError();
+            throw new UnsupportedOperationError('unsupported JWS algorithm', { cause: { alg } });
     }
 }
 async function importJwk(alg, jwk) {
     const { ext, key_ops, use, ...key } = jwk;
-    return crypto.subtle.importKey('jwk', key, algToSubtle(alg, jwk.crv), true, ['verify']);
+    return crypto.subtle.importKey('jwk', key, algToSubtle(alg), true, ['verify']);
 }
-export async function deviceAuthorizationRequest(as, client, parameters, options) {
+export async function deviceAuthorizationRequest(as, client, clientAuthentication, parameters, options) {
     assertAs(as);
     assertClient(client);
-    const url = resolveEndpoint(as, 'device_authorization_endpoint', alias(client, options));
+    const url = resolveEndpoint(as, 'device_authorization_endpoint', client.use_mtls_endpoint_aliases, options?.[allowInsecureRequests] !== true);
     const body = new URLSearchParams(parameters);
     body.set('client_id', client.client_id);
     const headers = prepareHeaders(options?.headers);
     headers.set('accept', 'application/json');
-    return authenticatedRequest(as, client, 'POST', url, body, headers, options);
+    return authenticatedRequest(as, client, clientAuthentication, url, body, headers, options);
 }
 export async function processDeviceAuthorizationResponse(as, client, response) {
     assertAs(as);
     assertClient(client);
     if (!looseInstanceOf(response, Response)) {
-        throw new TypeError('"response" must be an instance of Response');
+        throw CodedTypeError('"response" must be an instance of Response', ERR_INVALID_ARG_TYPE);
+    }
+    let challenges;
+    if ((challenges = parseWwwAuthenticateChallenges(response))) {
+        throw new WWWAuthenticateChallengeError('server responded with a challenge in the WWW-Authenticate HTTP Header', { cause: challenges, response });
     }
     if (response.status !== 200) {
         let err;
         if ((err = await handleOAuthBodyError(response))) {
-            return err;
+            await response.body?.cancel();
+            throw new ResponseBodyError('server responded with an error in the response body', {
+                cause: err,
+                response,
+            });
         }
-        throw new OPE('"response" is not a conform Device Authorization Endpoint response');
+        throw OPE('"response" is not a conform Device Authorization Endpoint response', RESPONSE_IS_NOT_CONFORM, response);
     }
     assertReadableResponse(response);
+    assertApplicationJson(response);
     let json;
     try {
         json = await response.json();
     }
     catch (cause) {
-        throw new OPE('failed to parse "response" body as JSON', { cause });
+        throw OPE('failed to parse "response" body as JSON', PARSE_ERROR, cause);
     }
     if (!isJsonObject(json)) {
-        throw new OPE('"response" body must be a top level object');
-    }
-    if (!validateString(json.device_code)) {
-        throw new OPE('"response" body "device_code" property must be a non-empty string');
-    }
-    if (!validateString(json.user_code)) {
-        throw new OPE('"response" body "user_code" property must be a non-empty string');
+        throw OPE('"response" body must be a top level object', INVALID_RESPONSE, { body: json });
     }
-    if (!validateString(json.verification_uri)) {
-        throw new OPE('"response" body "verification_uri" property must be a non-empty string');
-    }
-    if (typeof json.expires_in !== 'number' || json.expires_in <= 0) {
-        throw new OPE('"response" body "expires_in" property must be a positive number');
-    }
-    if (json.verification_uri_complete !== undefined &&
-        !validateString(json.verification_uri_complete)) {
-        throw new OPE('"response" body "verification_uri_complete" property must be a non-empty string');
+    assertString(json.device_code, '"response" body "device_code" property', INVALID_RESPONSE, {
+        body: json,
+    });
+    assertString(json.user_code, '"response" body "user_code" property', INVALID_RESPONSE, {
+        body: json,
+    });
+    assertString(json.verification_uri, '"response" body "verification_uri" property', INVALID_RESPONSE, { body: json });
+    assertNumber(json.expires_in, false, '"response" body "expires_in" property', INVALID_RESPONSE, {
+        body: json,
+    });
+    if (json.verification_uri_complete !== undefined) {
+        assertString(json.verification_uri_complete, '"response" body "verification_uri_complete" property', INVALID_RESPONSE, { body: json });
     }
-    if (json.interval !== undefined && (typeof json.interval !== 'number' || json.interval <= 0)) {
-        throw new OPE('"response" body "interval" property must be a positive number');
+    if (json.interval !== undefined) {
+        assertNumber(json.interval, false, '"response" body "interval" property', INVALID_RESPONSE, {
+            body: json,
+        });
     }
     return json;
 }
-export async function deviceCodeGrantRequest(as, client, deviceCode, options) {
+export async function deviceCodeGrantRequest(as, client, clientAuthentication, deviceCode, options) {
     assertAs(as);
     assertClient(client);
-    if (!validateString(deviceCode)) {
-        throw new TypeError('"deviceCode" must be a non-empty string');
-    }
+    assertString(deviceCode, '"deviceCode"');
     const parameters = new URLSearchParams(options?.additionalParameters);
     parameters.set('device_code', deviceCode);
-    return tokenEndpointRequest(as, client, 'urn:ietf:params:oauth:grant-type:device_code', parameters, options);
+    return tokenEndpointRequest(as, client, clientAuthentication, 'urn:ietf:params:oauth:grant-type:device_code', parameters, options);
 }
-export async function processDeviceCodeResponse(as, client, response) {
-    return processGenericAccessTokenResponse(as, client, response);
+export async function processDeviceCodeResponse(as, client, response, options) {
+    return processGenericAccessTokenResponse(as, client, response, undefined, options);
 }
 export async function generateKeyPair(alg, options) {
-    if (!validateString(alg)) {
-        throw new TypeError('"alg" must be a non-empty string');
-    }
-    const algorithm = algToSubtle(alg, alg === 'EdDSA' ? (options?.crv ?? 'Ed25519') : undefined);
+    assertString(alg, '"alg"');
+    const algorithm = algToSubtle(alg);
     if (alg.startsWith('PS') || alg.startsWith('RS')) {
         Object.assign(algorithm, {
             modulusLength: options?.modulusLength ?? 2048,
@@ -1892,46 +2165,53 @@ function normalizeHtu(htu) {
     url.hash = '';
     return url.href;
 }
-async function validateDPoP(as, request, accessToken, accessTokenClaims, options) {
-    const header = request.headers.get('dpop');
-    if (header === null) {
-        throw new OPE('operation indicated DPoP use but the request has no DPoP HTTP Header');
+async function validateDPoP(request, accessToken, accessTokenClaims, options) {
+    const headerValue = request.headers.get('dpop');
+    if (headerValue === null) {
+        throw OPE('operation indicated DPoP use but the request has no DPoP HTTP Header', INVALID_REQUEST, { headers: request.headers });
     }
     if (request.headers.get('authorization')?.toLowerCase().startsWith('dpop ') === false) {
-        throw new OPE(`operation indicated DPoP use but the request's Authorization HTTP Header scheme is not DPoP`);
+        throw OPE(`operation indicated DPoP use but the request's Authorization HTTP Header scheme is not DPoP`, INVALID_REQUEST, { headers: request.headers });
     }
     if (typeof accessTokenClaims.cnf?.jkt !== 'string') {
-        throw new OPE('operation indicated DPoP use but the JWT Access Token has no jkt confirmation claim');
+        throw OPE('operation indicated DPoP use but the JWT Access Token has no jkt confirmation claim', INVALID_REQUEST, { claims: accessTokenClaims });
     }
     const clockSkew = getClockSkew(options);
-    const proof = await validateJwt(header, checkSigningAlgorithm.bind(undefined, undefined, as?.dpop_signing_alg_values_supported || SUPPORTED_JWS_ALGS), async ({ jwk, alg }) => {
-        if (!jwk) {
-            throw new OPE('DPoP Proof is missing the jwk header parameter');
-        }
-        const key = await importJwk(alg, jwk);
-        if (key.type !== 'public') {
-            throw new OPE('DPoP Proof jwk header parameter must contain a public key');
-        }
-        return key;
-    }, clockSkew, getClockTolerance(options), undefined)
+    const proof = await validateJwt(headerValue, checkSigningAlgorithm.bind(undefined, options?.signingAlgorithms, undefined, SUPPORTED_JWS_ALGS), clockSkew, getClockTolerance(options), undefined)
         .then(checkJwtType.bind(undefined, 'dpop+jwt'))
         .then(validatePresence.bind(undefined, ['iat', 'jti', 'ath', 'htm', 'htu']));
     const now = epochTime() + clockSkew;
     const diff = Math.abs(now - proof.claims.iat);
     if (diff > 300) {
-        throw new OPE('DPoP Proof iat is not recent enough');
+        throw OPE('DPoP Proof iat is not recent enough', JWT_TIMESTAMP_CHECK, {
+            now,
+            claims: proof.claims,
+            claim: 'iat',
+        });
     }
     if (proof.claims.htm !== request.method) {
-        throw new OPE('DPoP Proof htm mismatch');
+        throw OPE('DPoP Proof htm mismatch', JWT_CLAIM_COMPARISON, {
+            expected: request.method,
+            claims: proof.claims,
+            claim: 'htm',
+        });
     }
     if (typeof proof.claims.htu !== 'string' ||
         normalizeHtu(proof.claims.htu) !== normalizeHtu(request.url)) {
-        throw new OPE('DPoP Proof htu mismatch');
+        throw OPE('DPoP Proof htu mismatch', JWT_CLAIM_COMPARISON, {
+            expected: normalizeHtu(request.url),
+            claims: proof.claims,
+            claim: 'htu',
+        });
     }
     {
-        const expected = b64u(await crypto.subtle.digest('SHA-256', encoder.encode(accessToken)));
+        const expected = b64u(await crypto.subtle.digest('SHA-256', buf(accessToken)));
         if (proof.claims.ath !== expected) {
-            throw new OPE('DPoP Proof ath mismatch');
+            throw OPE('DPoP Proof ath mismatch', JWT_CLAIM_COMPARISON, {
+                expected,
+                claims: proof.claims,
+                claim: 'ath',
+            });
         }
     }
     {
@@ -1960,25 +2240,44 @@ async function validateDPoP(as, request, accessToken, accessTokenClaims, options
                 };
                 break;
             default:
-                throw new UnsupportedOperationError();
+                throw new UnsupportedOperationError('unsupported JWK key type', { cause: proof.header.jwk });
         }
-        const expected = b64u(await crypto.subtle.digest('SHA-256', encoder.encode(JSON.stringify(components))));
+        const expected = b64u(await crypto.subtle.digest('SHA-256', buf(JSON.stringify(components))));
         if (accessTokenClaims.cnf.jkt !== expected) {
-            throw new OPE('JWT Access Token confirmation mismatch');
+            throw OPE('JWT Access Token confirmation mismatch', JWT_CLAIM_COMPARISON, {
+                expected,
+                claims: accessTokenClaims,
+                claim: 'cnf.jkt',
+            });
         }
     }
+    const { 0: protectedHeader, 1: payload, 2: encodedSignature } = headerValue.split('.');
+    const signature = b64u(encodedSignature);
+    const { jwk, alg } = proof.header;
+    if (!jwk) {
+        throw OPE('DPoP Proof is missing the jwk header parameter', INVALID_REQUEST, {
+            header: proof.header,
+        });
+    }
+    const key = await importJwk(alg, jwk);
+    if (key.type !== 'public') {
+        throw OPE('DPoP Proof jwk header parameter must contain a public key', INVALID_REQUEST, {
+            header: proof.header,
+        });
+    }
+    await validateJwsSignature(protectedHeader, payload, key, signature);
 }
 export async function validateJwtAccessToken(as, request, expectedAudience, options) {
     assertAs(as);
     if (!looseInstanceOf(request, Request)) {
-        throw new TypeError('"request" must be an instance of Request');
-    }
-    if (!validateString(expectedAudience)) {
-        throw new OPE('"expectedAudience" must be a non-empty string');
+        throw CodedTypeError('"request" must be an instance of Request', ERR_INVALID_ARG_TYPE);
     }
+    assertString(expectedAudience, '"expectedAudience"');
     const authorization = request.headers.get('authorization');
     if (authorization === null) {
-        throw new OPE('"request" is missing an Authorization HTTP Header');
+        throw OPE('"request" is missing an Authorization HTTP Header', INVALID_REQUEST, {
+            headers: request.headers,
+        });
     }
     let { 0: scheme, 1: accessToken, length } = authorization.split(' ');
     scheme = scheme.toLowerCase();
@@ -1987,10 +2286,14 @@ export async function validateJwtAccessToken(as, request, expectedAudience, opti
         case 'bearer':
             break;
         default:
-            throw new UnsupportedOperationError('unsupported Authorization HTTP Header scheme');
+            throw new UnsupportedOperationError('unsupported Authorization HTTP Header scheme', {
+                cause: { headers: request.headers },
+            });
     }
     if (length !== 2) {
-        throw new OPE('invalid Authorization HTTP Header format');
+        throw OPE('invalid Authorization HTTP Header format', INVALID_REQUEST, {
+            headers: request.headers,
+        });
     }
     const requiredClaims = [
         'iss',
@@ -2004,43 +2307,54 @@ export async function validateJwtAccessToken(as, request, expectedAudience, opti
     if (options?.requireDPoP || scheme === 'dpop' || request.headers.has('dpop')) {
         requiredClaims.push('cnf');
     }
-    const { claims } = await validateJwt(accessToken, checkSigningAlgorithm.bind(undefined, undefined, SUPPORTED_JWS_ALGS), getPublicSigKeyFromIssuerJwksUri.bind(undefined, as, options), getClockSkew(options), getClockTolerance(options), undefined)
+    const { claims, header } = await validateJwt(accessToken, checkSigningAlgorithm.bind(undefined, options?.signingAlgorithms, undefined, SUPPORTED_JWS_ALGS), getClockSkew(options), getClockTolerance(options), undefined)
         .then(checkJwtType.bind(undefined, 'at+jwt'))
         .then(validatePresence.bind(undefined, requiredClaims))
-        .then(validateIssuer.bind(undefined, as.issuer))
-        .then(validateAudience.bind(undefined, expectedAudience));
+        .then(validateIssuer.bind(undefined, as))
+        .then(validateAudience.bind(undefined, expectedAudience))
+        .catch(reassignRSCode);
     for (const claim of ['client_id', 'jti', 'sub']) {
         if (typeof claims[claim] !== 'string') {
-            throw new OPE(`unexpected JWT "${claim}" claim type`);
+            throw OPE(`unexpected JWT "${claim}" claim type`, INVALID_REQUEST, { claims });
         }
     }
     if ('cnf' in claims) {
         if (!isJsonObject(claims.cnf)) {
-            throw new OPE('unexpected JWT "cnf" (confirmation) claim value');
+            throw OPE('unexpected JWT "cnf" (confirmation) claim value', INVALID_REQUEST, { claims });
         }
         const { 0: cnf, length } = Object.keys(claims.cnf);
         if (length) {
             if (length !== 1) {
-                throw new UnsupportedOperationError('multiple confirmation claims are not supported');
+                throw new UnsupportedOperationError('multiple confirmation claims are not supported', {
+                    cause: { claims },
+                });
             }
             if (cnf !== 'jkt') {
-                throw new UnsupportedOperationError('unsupported JWT Confirmation method');
+                throw new UnsupportedOperationError('unsupported JWT Confirmation method', {
+                    cause: { claims },
+                });
             }
         }
     }
+    const { 0: protectedHeader, 1: payload, 2: encodedSignature } = accessToken.split('.');
+    const signature = b64u(encodedSignature);
+    const key = await getPublicSigKeyFromIssuerJwksUri(as, options, header);
+    await validateJwsSignature(protectedHeader, payload, key, signature);
     if (options?.requireDPoP ||
         scheme === 'dpop' ||
         claims.cnf?.jkt !== undefined ||
         request.headers.has('dpop')) {
-        await validateDPoP(as, request, accessToken, claims, options);
+        await validateDPoP(request, accessToken, claims, options).catch(reassignRSCode);
     }
     return claims;
 }
-export const experimentalCustomFetch = customFetch;
-export const experimental_customFetch = customFetch;
-export const experimentalUseMtlsAlias = useMtlsAlias;
-export const experimental_useMtlsAlias = useMtlsAlias;
-export const experimental_validateDetachedSignatureResponse = (...args) => validateDetachedSignatureResponse(...args);
-export const experimental_validateJwtAccessToken = (...args) => validateJwtAccessToken(...args);
-export const validateJwtUserinfoSignature = (...args) => validateJwtUserInfoSignature(...args);
-export const experimental_jwksCache = jwksCache;
+function reassignRSCode(err) {
+    if (err instanceof OperationProcessingError && err?.code === INVALID_REQUEST) {
+        err.code = INVALID_RESPONSE;
+    }
+    throw err;
+}
+export const _nopkce = Symbol();
+export const _nodiscoverycheck = Symbol();
+export const _expectedIssuer = Symbol();
+//# sourceMappingURL=index.js.map