vouchly 0.0.0 → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,715 @@
+import { createLocalJWKSet, createRemoteJWKSet, customFetch, decodeJwt, decodeProtectedHeader, errors, importJWK, jwtVerify } from "jose";
+//#region src/cache/hash.ts
+async function hashToken(token) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(token));
+	let output = "";
+	for (const byte of new Uint8Array(digest)) output += byte.toString(16).padStart(2, "0");
+	return output;
+}
+//#endregion
+//#region src/cache/memory.ts
+var MemoryTokenCache = class {
+	max;
+	items;
+	constructor(options = {}) {
+		const max = options.max ?? 1e4;
+		if (!Number.isSafeInteger(max) || max < 1) throw new TypeError("The token cache max must be an integer of at least 1.");
+		this.max = max;
+		this.items = /* @__PURE__ */ new Map();
+	}
+	async get(key) {
+		const item = this.items.get(key);
+		if (!item) return;
+		this.items.delete(key);
+		if (item.expiresAt <= Date.now()) return;
+		this.items.set(key, item);
+		return structuredClone(item.entry);
+	}
+	async set(key, entry, ttl) {
+		this.items.delete(key);
+		if (!(ttl > 0)) return;
+		this.items.set(key, {
+			entry: structuredClone(entry),
+			expiresAt: Date.now() + ttl * 1e3
+		});
+		while (this.items.size > this.max) {
+			const oldest = this.items.keys().next();
+			if (oldest.done) break;
+			this.items.delete(oldest.value);
+		}
+	}
+};
+//#endregion
+//#region src/discovery/module.ts
+const CACHE_MAX_AGE = 600;
+const TIMEOUT$1 = 1e4;
+const FAILURE_COOLDOWN = 3e4;
+const items = /* @__PURE__ */ new WeakMap();
+const flights = /* @__PURE__ */ new WeakMap();
+const failures = /* @__PURE__ */ new WeakMap();
+function scope(store, fetchFn) {
+	let map = store.get(fetchFn);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		store.set(fetchFn, map);
+	}
+	return map;
+}
+function isRecord(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+function isURL(input) {
+	return typeof input === "string" && URL.canParse(input);
+}
+async function load(issuer, fetchFn) {
+	const response = await fetchFn(`${issuer.replace(/\/$/, "")}/.well-known/openid-configuration`, {
+		headers: { accept: "application/json" },
+		signal: AbortSignal.timeout(TIMEOUT$1)
+	});
+	if (!response.ok) throw new Error(`The provider metadata request answered ${response.status}.`);
+	const body = await response.json();
+	if (!isRecord(body)) throw new Error("The provider metadata is not a JSON object.");
+	if (body.issuer !== issuer) throw new Error("The provider metadata names another issuer.");
+	const metadata = { issuer: body.issuer };
+	if (typeof body.jwks_uri !== "undefined") {
+		if (!isURL(body.jwks_uri)) throw new Error("The provider metadata has an invalid jwks_uri.");
+		metadata.jwks_uri = body.jwks_uri;
+	}
+	if (typeof body.introspection_endpoint !== "undefined") {
+		if (!isURL(body.introspection_endpoint)) throw new Error("The provider metadata has an invalid introspection_endpoint.");
+		metadata.introspection_endpoint = body.introspection_endpoint;
+	}
+	return metadata;
+}
+/**
+* Reads `<issuer>/.well-known/openid-configuration`. The issuer must come
+* from configuration, never from a token. Answers are reused for
+* cacheMaxAge seconds; after a failure, the issuer is not asked again for
+* 30 seconds and calls fail fast instead.
+*/
+async function fetchProviderMetadata(issuer, fetchFn, options = {}) {
+	const cacheMaxAge = options.cacheMaxAge ?? CACHE_MAX_AGE;
+	const cached = scope(items, fetchFn);
+	const item = cached.get(issuer);
+	if (item && Date.now() - item.fetchedAt < cacheMaxAge * 1e3) return structuredClone(item.metadata);
+	const failed = scope(failures, fetchFn);
+	const failedAt = failed.get(issuer);
+	if (typeof failedAt === "number") {
+		if (Date.now() - failedAt < FAILURE_COOLDOWN) throw new Error("The provider metadata failed to load recently, not trying again yet.");
+		failed.delete(issuer);
+	}
+	const pending = scope(flights, fetchFn);
+	let flight = pending.get(issuer);
+	if (!flight) {
+		flight = load(issuer, fetchFn).then((metadata) => {
+			cached.set(issuer, {
+				metadata,
+				fetchedAt: Date.now()
+			});
+			return metadata;
+		}, (e) => {
+			failed.set(issuer, Date.now());
+			throw e;
+		}).finally(() => {
+			pending.delete(issuer);
+		});
+		pending.set(issuer, flight);
+	}
+	return structuredClone(await flight);
+}
+//#endregion
+//#region src/error/constants.ts
+let VouchlyErrorCode = /* @__PURE__ */ function(VouchlyErrorCode) {
+	VouchlyErrorCode["TOKEN_MALFORMED"] = "token_malformed";
+	VouchlyErrorCode["TOKEN_EXPIRED"] = "token_expired";
+	VouchlyErrorCode["TOKEN_INACTIVE"] = "token_inactive";
+	VouchlyErrorCode["ISSUER_UNTRUSTED"] = "issuer_untrusted";
+	VouchlyErrorCode["KEY_UNAVAILABLE"] = "key_unavailable";
+	VouchlyErrorCode["SIGNATURE_INVALID"] = "signature_invalid";
+	VouchlyErrorCode["CLAIM_INVALID"] = "claim_invalid";
+	VouchlyErrorCode["INTROSPECTION_FAILED"] = "introspection_failed";
+	VouchlyErrorCode["BINDING_MISMATCH"] = "binding_mismatch";
+	return VouchlyErrorCode;
+}({});
+const VOUCHLY_ERROR_MARKER = Symbol.for("vouchly.error");
+//#endregion
+//#region src/error/module.ts
+var VouchlyError = class extends Error {
+	code;
+	[VOUCHLY_ERROR_MARKER] = true;
+	constructor(code, message, options) {
+		super(message || code, options);
+		this.name = "VouchlyError";
+		this.code = code;
+	}
+};
+function isVouchlyError(input) {
+	if (typeof input !== "object" || input === null) return false;
+	return input[VOUCHLY_ERROR_MARKER] === true;
+}
+//#endregion
+//#region src/introspection/module.ts
+const TIMEOUT = 1e4;
+function fail(message, cause) {
+	return new VouchlyError("introspection_failed", message, typeof cause === "undefined" ? void 0 : { cause });
+}
+/**
+* application/x-www-form-urlencoded, as RFC 6749 2.3.1 asks for client credentials.
+*/
+function formEncode(value) {
+	return new URLSearchParams([["", value]]).toString().slice(1);
+}
+async function resolveEndpoint(issuer, fetchFn) {
+	if (issuer.introspection?.endpoint) return issuer.introspection.endpoint;
+	if (typeof issuer.issuer !== "string") throw fail("The issuer has no introspection endpoint.");
+	let endpoint;
+	try {
+		endpoint = (await fetchProviderMetadata(issuer.issuer, fetchFn)).introspection_endpoint;
+	} catch (e) {
+		throw fail("The introspection endpoint could not be discovered.", e);
+	}
+	if (!endpoint) throw fail("The issuer advertises no introspection endpoint.");
+	return endpoint;
+}
+async function resolveAuthorization(issuer) {
+	const authorization = issuer.introspection?.authorization;
+	if (!authorization) return;
+	if (typeof authorization === "function") try {
+		return await authorization();
+	} catch (e) {
+		throw fail("The introspection authorization could not be resolved.", e);
+	}
+	return `Basic ${btoa(`${formEncode(authorization.clientId)}:${formEncode(authorization.clientSecret)}`)}`;
+}
+function isResponse(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+async function request(token, issuer, fetchFn) {
+	const endpoint = await resolveEndpoint(issuer, fetchFn);
+	const authorization = await resolveAuthorization(issuer);
+	const headers = {
+		"content-type": "application/x-www-form-urlencoded",
+		accept: "application/json"
+	};
+	if (typeof authorization === "string") headers.authorization = authorization;
+	let response;
+	try {
+		response = await fetchFn(endpoint, {
+			method: "POST",
+			headers,
+			body: new URLSearchParams({ token }).toString(),
+			signal: AbortSignal.timeout(TIMEOUT)
+		});
+	} catch (e) {
+		throw fail("The introspection request failed.", e);
+	}
+	if (!response.ok) {
+		await response.body?.cancel().catch(() => void 0);
+		throw fail(`The introspection endpoint answered ${response.status}.`);
+	}
+	let body;
+	try {
+		body = JSON.parse(await response.text());
+	} catch (e) {
+		throw fail("The introspection response is not JSON.", e);
+	}
+	if (!isResponse(body)) throw fail("The introspection response is not a JSON object.");
+	if (body.active !== true) throw new VouchlyError("token_inactive", "The token is not active.");
+	return body;
+}
+/**
+* RFC 7662: asks the issuer's introspection endpoint about a token and
+* answers the response as its claims. Claim rules are the caller's.
+*/
+async function introspect(token, issuer, fetchFn) {
+	try {
+		return await request(token, issuer, fetchFn);
+	} catch (e) {
+		if (isVouchlyError(e)) throw e;
+		throw fail("The introspection failed.", e);
+	}
+}
+//#endregion
+//#region src/issuer/match.ts
+/**
+* Whether an issuer config trusts a token by its UNVERIFIED claims. This only
+* selects a config: verification still runs against it afterwards. A
+* function matcher counts only when it returns exactly `true`; one that
+* throws, or returns anything else (a Promise included), does not match.
+*/
+function matchIssuer(issuer, claims) {
+	if (typeof issuer.issuer === "string") return typeof claims.iss === "string" && claims.iss === issuer.issuer;
+	try {
+		return issuer.issuer(claims) === true;
+	} catch {
+		return false;
+	}
+}
+/**
+* The index of the first issuer that trusts the claims, or -1.
+*/
+function selectIssuer(issuers, claims) {
+	for (const [index, issuer] of issuers.entries()) if (matchIssuer(issuer, claims)) return index;
+	return -1;
+}
+//#endregion
+//#region src/key/cached.ts
+function cachedKeys(load, options) {
+	const ttl = options.ttl ?? 300;
+	const timeout = options.timeout ?? 10;
+	const max = options.max ?? 100;
+	if (!Number.isFinite(ttl) || ttl < 0) throw new TypeError("The key cache ttl must be a finite, non-negative number of seconds.");
+	if (!Number.isSafeInteger(max) || max < 1) throw new TypeError("The key cache max must be an integer of at least 1.");
+	if (!Number.isFinite(timeout) || timeout <= 0 || timeout * 1e3 > 2147483647) throw new TypeError("The key cache timeout must be a positive number of seconds, at most 2147483.");
+	const items = /* @__PURE__ */ new Map();
+	const flights = /* @__PURE__ */ new Map();
+	return async (context) => {
+		const key = options.key(context);
+		const item = items.get(key);
+		if (item) {
+			if (item.expiresAt > Date.now()) return structuredClone(item.jwk);
+			items.delete(key);
+		}
+		const pending = flights.get(key);
+		if (pending) return structuredClone(await pending);
+		let timer;
+		const deadline = new Promise((_resolve, reject) => {
+			timer = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("Loading the key timed out."));
+			}, timeout * 1e3);
+		});
+		const flight = Promise.race([Promise.resolve().then(() => load(context)), deadline]).then((jwk) => {
+			if (ttl > 0) {
+				items.delete(key);
+				items.set(key, {
+					jwk: structuredClone(jwk),
+					expiresAt: Date.now() + ttl * 1e3
+				});
+				while (items.size > max) {
+					const oldest = items.keys().next();
+					if (oldest.done) break;
+					items.delete(oldest.value);
+				}
+			}
+			return jwk;
+		}).finally(() => {
+			clearTimeout(timer);
+			if (flights.get(key) === flight) flights.delete(key);
+		});
+		flights.set(key, flight);
+		return structuredClone(await flight);
+	};
+}
+//#endregion
+//#region src/key/jwks.ts
+function jwks(url, options = {}) {
+	const target = new URL(url);
+	const sets = /* @__PURE__ */ new WeakMap();
+	return async (context) => {
+		let set = sets.get(context.fetch);
+		if (!set) {
+			set = createRemoteJWKSet(target, {
+				cacheMaxAge: options.cacheMaxAge,
+				cooldownDuration: options.cooldownDuration,
+				timeoutDuration: options.timeoutDuration,
+				[customFetch]: context.fetch
+			});
+			sets.set(context.fetch, set);
+		}
+		return set(context.token.header);
+	};
+}
+//#endregion
+//#region src/key/discovery.ts
+/**
+* Resolves keys through the configured issuer's OIDC discovery document.
+* A function issuer is refused: its only URL would be the token's own `iss`.
+*/
+function discovery(options = {}) {
+	if (typeof options.cacheMaxAge !== "undefined" && (!Number.isFinite(options.cacheMaxAge) || options.cacheMaxAge < 0)) throw new TypeError("The discovery cacheMaxAge must be a finite, non-negative number of seconds.");
+	const sources = /* @__PURE__ */ new Map();
+	return async (context) => {
+		const { issuer } = context.issuer;
+		if (typeof issuer !== "string") throw new VouchlyError("key_unavailable", "Discovery needs a configured issuer string, a function issuer cannot be discovered.");
+		let metadata;
+		try {
+			metadata = await fetchProviderMetadata(issuer, context.fetch, options);
+		} catch (e) {
+			throw new VouchlyError("key_unavailable", e instanceof Error && e.message ? e.message : "The provider metadata is unavailable.", { cause: e });
+		}
+		const { jwks_uri: url } = metadata;
+		if (!url) throw new VouchlyError("key_unavailable", "The provider metadata has no jwks_uri.");
+		let source = sources.get(url);
+		if (!source) {
+			source = jwks(url);
+			sources.set(url, source);
+		}
+		return source(context);
+	};
+}
+//#endregion
+//#region src/key/policy.ts
+const RSA_MIN_MODULUS_LENGTH = 2048;
+/**
+* Throws an Error when a JWK must never be used to verify a signature.
+*/
+function assertJWKPolicy(jwk) {
+	if (jwk.kty === "oct") throw new Error("A symmetric key (kty \"oct\") is not accepted.");
+	if (typeof jwk.use !== "undefined" && jwk.use !== "sig") throw new Error(`A key with use "${jwk.use}" is not a signature key.`);
+}
+/**
+* Throws an Error when a CryptoKey must never be used to verify a signature.
+*/
+function assertCryptoKeyPolicy(key) {
+	if (key.type === "secret") throw new Error("A symmetric key is not accepted.");
+	const { modulusLength } = key.algorithm;
+	if (typeof modulusLength === "number" && modulusLength < RSA_MIN_MODULUS_LENGTH) throw new Error(`An RSA key of ${modulusLength} bits is too small, at least ${RSA_MIN_MODULUS_LENGTH} are required.`);
+}
+//#endregion
+//#region src/key/module.ts
+function isJWK(input) {
+	return typeof input.kty === "string";
+}
+async function resolve(source, context) {
+	const output = await source(context);
+	let key;
+	if (isJWK(output)) {
+		assertJWKPolicy(output);
+		key = await importJWK(output, output.alg ?? context.token.header.alg);
+	} else key = output;
+	if (key instanceof Uint8Array) throw new Error("A symmetric key is not accepted.");
+	assertCryptoKeyPolicy(key);
+	return key;
+}
+/**
+* Resolves the key a token is verified with. Every failure, including a key
+* the policy refuses, is a KEY_UNAVAILABLE VouchlyError.
+*/
+async function resolveVerificationKey(source, context) {
+	try {
+		return await resolve(source, context);
+	} catch (e) {
+		if (isVouchlyError(e) && e.code === "key_unavailable") throw e;
+		throw new VouchlyError("key_unavailable", e instanceof Error && e.message ? `The verification key is unavailable: ${e.message}` : "The verification key is unavailable.", { cause: e });
+	}
+}
+//#endregion
+//#region src/key/static.ts
+function staticKeys(keys) {
+	const set = createLocalJWKSet({ keys: structuredClone(keys) });
+	return async (context) => set(context.token.header);
+}
+//#endregion
+//#region src/token/module.ts
+const COMPACT_TOKEN_REGEX = /^[\w-]+\.[\w-]+\.[\w-]+$/;
+function isCompactToken(token) {
+	return COMPACT_TOKEN_REGEX.test(token);
+}
+function isPlainObject(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+function parseToken(token) {
+	if (typeof token !== "string" || !isCompactToken(token)) throw new VouchlyError("token_malformed", "The token is not a compact JWS.");
+	let header;
+	let claims;
+	try {
+		header = decodeProtectedHeader(token);
+		claims = decodeJwt(token);
+	} catch (e) {
+		throw new VouchlyError("token_malformed", "The token could not be decoded.", { cause: e });
+	}
+	if (!isPlainObject(header) || !isPlainObject(claims)) throw new VouchlyError("token_malformed", "The token header or claims are not an object.");
+	return {
+		raw: token,
+		header,
+		claims
+	};
+}
+//#endregion
+//#region src/verifier/binding.ts
+/**
+* RFC 8705: a token carrying `cnf` is certificate-bound and fails closed
+* unless the presented thumbprint equals `cnf.x5t#S256`. A `cnf` this check
+* cannot satisfy (no `x5t#S256`, e.g. a DPoP `jkt`) fails too.
+*/
+function assertCertificateBinding(claims, thumbprint) {
+	if (typeof claims.cnf === "undefined" || claims.cnf === null) return;
+	const expected = typeof claims.cnf === "object" ? claims.cnf["x5t#S256"] : void 0;
+	if (typeof expected !== "string" || expected.length === 0 || typeof thumbprint !== "string" || thumbprint !== expected) throw new VouchlyError("binding_mismatch", "The token is bound to a certificate that was not presented.");
+}
+function isBound(claims) {
+	return typeof claims.cnf !== "undefined" && claims.cnf !== null;
+}
+/**
+* Checks the binding of every claim set given: a token verified by
+* introspection passes its own unverified claims next to the response, since
+* an unverified `cnf` may only add a requirement, never lift one.
+*/
+async function resolveCertificateBinding(claims, options) {
+	const bound = (Array.isArray(claims) ? claims : [claims]).filter(isBound);
+	if (bound.length === 0) return;
+	let thumbprint;
+	if (typeof options.certificateThumbprint === "function") try {
+		thumbprint = await options.certificateThumbprint();
+	} catch (e) {
+		throw new VouchlyError("binding_mismatch", "The certificate thumbprint could not be resolved.", { cause: e });
+	}
+	else thumbprint = options.certificateThumbprint;
+	for (const item of bound) assertCertificateBinding(item, thumbprint);
+}
+//#endregion
+//#region src/verifier/module.ts
+/**
+* One function for every verifier without a fetch of its own: discovery and
+* jwks() memoise per fetch, so their caches are shared between such
+* verifiers. It reads the global at call time, so a later stub applies.
+*/
+const defaultFetch = (input, init) => fetch(input, init);
+const EC_ALGORITHMS = {
+	"P-256": "ES256",
+	"P-384": "ES384",
+	"P-521": "ES512"
+};
+/**
+* The JWS algorithms a resolved key verifies. A JWK without `alg` was
+* imported with the header's `alg`, so for it this is the header's choice
+* among the algorithms its key type supports; Issuer.algorithms pins it.
+*/
+function deriveAlgorithms(key) {
+	const algorithm = key.algorithm;
+	const bits = algorithm.hash?.name.replace("SHA-", "");
+	switch (algorithm.name) {
+		case "RSASSA-PKCS1-v1_5": return bits ? [`RS${bits}`] : [];
+		case "RSA-PSS": return bits ? [`PS${bits}`] : [];
+		case "ECDSA": {
+			const alg = algorithm.namedCurve ? EC_ALGORITHMS[algorithm.namedCurve] : void 0;
+			return alg ? [alg] : [];
+		}
+		case "Ed25519": return ["EdDSA", "Ed25519"];
+		default: return [];
+	}
+}
+function mapJoseError(e) {
+	if (isVouchlyError(e)) return e;
+	const message = e instanceof Error && e.message ? e.message : void 0;
+	if (e instanceof errors.JWTExpired) return new VouchlyError("token_expired", message, { cause: e });
+	if (e instanceof errors.JWSSignatureVerificationFailed) return new VouchlyError("signature_invalid", message, { cause: e });
+	if (e instanceof errors.JWTClaimValidationFailed || e instanceof errors.JOSEAlgNotAllowed || e instanceof errors.JWTInvalid) return new VouchlyError("claim_invalid", message, { cause: e });
+	return new VouchlyError("signature_invalid", message, { cause: e });
+}
+function assertAudience(issuer, claims) {
+	if (typeof issuer.audience === "undefined") return;
+	const expected = Array.isArray(issuer.audience) ? issuer.audience : [issuer.audience];
+	if ((Array.isArray(claims.aud) ? claims.aud : [claims.aud]).every((value) => typeof value !== "string" || !expected.includes(value))) throw new VouchlyError("claim_invalid", "The token audience is not accepted.");
+}
+function normalizeTyp(value) {
+	const normalized = value.toLowerCase();
+	return value.includes("/") ? normalized : `application/${normalized}`;
+}
+/**
+* The rules jose applies to the header and claims of a local token that do
+* not need the signature, so a cache hit is held to them too.
+*/
+function assertLocalClaims(issuer, entry) {
+	for (const claim of issuer.requiredClaims ?? ["exp"]) if (!(claim in entry.claims)) throw new VouchlyError("claim_invalid", `The token has no "${claim}" claim.`);
+	if (typeof issuer.typ === "string" && (typeof entry.typ !== "string" || normalizeTyp(entry.typ) !== normalizeTyp(issuer.typ))) throw new VouchlyError("claim_invalid", "The token typ is not accepted.");
+	if (issuer.algorithms && (typeof entry.alg !== "string" || !issuer.algorithms.includes(entry.alg))) throw new VouchlyError("claim_invalid", "The token algorithm is not accepted.");
+	const { nbf } = entry.claims;
+	if (typeof nbf === "number" && nbf > Date.now() / 1e3 + (issuer.clockTolerance ?? 0)) throw new VouchlyError("claim_invalid", "The token is not yet valid.");
+}
+function buildRecords(options) {
+	if (!Array.isArray(options.issuers) || options.issuers.length === 0) throw new TypeError("A verifier needs at least one issuer.");
+	const names = /* @__PURE__ */ new Set();
+	return options.issuers.map((issuer, index) => {
+		const name = issuer.id ?? String(index);
+		if (names.has(name)) throw new TypeError(`The issuer id "${name}" is used twice (an issuer without id is named by its index).`);
+		names.add(name);
+		const verification = issuer.verification ?? "local";
+		if (verification !== "local" && verification !== "remote") throw new TypeError(`The issuer "${name}" has an unknown verification "${String(verification)}".`);
+		let { keys } = issuer;
+		if (!keys && verification === "local") {
+			if (typeof issuer.issuer !== "string") throw new TypeError(`The issuer "${name}" matches by function and needs a key source, since it cannot be discovered.`);
+			keys = discovery();
+		}
+		return {
+			name,
+			issuer,
+			keys
+		};
+	});
+}
+var Verifier = class {
+	records;
+	cache;
+	fetch;
+	opaque;
+	cacheNamespace;
+	constructor(options) {
+		this.records = buildRecords(options);
+		if (typeof options.opaque !== "undefined") {
+			this.opaque = this.records.find((record) => record.issuer.id === options.opaque);
+			if (!this.opaque) throw new TypeError(`The opaque issuer "${options.opaque}" names no configured issuer.`);
+		}
+		if (options.cache && !options.cacheNamespace) throw new TypeError("A cache passed in needs a cacheNamespace; verifiers sharing one namespace must have identical issuer configurations.");
+		if (typeof options.cacheNamespace === "string" && options.cacheNamespace.includes("\0")) throw new TypeError("The cacheNamespace must not contain a NUL character.");
+		this.cache = options.cache === false ? void 0 : options.cache ?? new MemoryTokenCache();
+		this.cacheNamespace = options.cacheNamespace ?? "";
+		this.fetch = options.fetch ?? defaultFetch;
+	}
+	async verify(token, options = {}) {
+		const compact = typeof token === "string" && isCompactToken(token);
+		if (!compact && (!this.opaque || typeof token !== "string" || token.length === 0)) throw new VouchlyError("token_malformed", "The token is not a compact JWS.");
+		const parsed = compact ? parseToken(token) : void 0;
+		const key = await hashToken(`${this.cacheNamespace}\u0000${token}`);
+		const cached = await this.readCache(key, parsed);
+		if (cached) {
+			await resolveCertificateBinding(this.bindingClaims(cached.entry.claims, cached.entry.source, parsed), options);
+			return {
+				claims: structuredClone(cached.entry.claims),
+				issuer: cached.record.issuer,
+				source: cached.entry.source
+			};
+		}
+		if (!compact) return this.introspect(token, key, this.opaque, options, parsed);
+		const record = this.selectRecord(parsed);
+		if (record.issuer.verification === "remote") return this.introspect(token, key, record, options, parsed);
+		const claims = await this.verifyLocal(parsed, record);
+		const entry = {
+			claims,
+			issuer: record.name,
+			source: "local"
+		};
+		if (typeof parsed.header.typ === "string") entry.typ = parsed.header.typ;
+		if (typeof parsed.header.alg === "string") entry.alg = parsed.header.alg;
+		await this.writeCache(key, entry, claims.exp);
+		await resolveCertificateBinding(claims, options);
+		return {
+			claims: structuredClone(claims),
+			issuer: record.issuer,
+			source: "local"
+		};
+	}
+	/**
+	* The claim sets whose `cnf` a result must satisfy: an introspected
+	* compact token is held to its own `cnf` as well as the response's.
+	*/
+	bindingClaims(claims, source, token) {
+		return source === "remote" && token ? [claims, token.claims] : [claims];
+	}
+	selectRecord(token) {
+		const index = selectIssuer(this.records.map((record) => record.issuer), token.claims);
+		if (index === -1) throw new VouchlyError("issuer_untrusted", "The token issuer is not trusted.");
+		return this.records[index];
+	}
+	async verifyLocal(token, record) {
+		const { issuer } = record;
+		const key = await resolveVerificationKey(record.keys, {
+			token,
+			issuer,
+			fetch: this.fetch
+		});
+		const algorithms = issuer.algorithms ?? deriveAlgorithms(key);
+		if (algorithms.length === 0) throw new VouchlyError("key_unavailable", "The verification key has no supported algorithm.");
+		let payload;
+		try {
+			payload = (await jwtVerify(token.raw, key, {
+				algorithms,
+				audience: issuer.audience,
+				typ: issuer.typ,
+				clockTolerance: issuer.clockTolerance ?? 0,
+				requiredClaims: issuer.requiredClaims ?? ["exp"],
+				issuer: typeof issuer.issuer === "string" ? issuer.issuer : void 0
+			})).payload;
+		} catch (e) {
+			throw mapJoseError(e);
+		}
+		await this.assertClaimsPredicate(issuer, payload);
+		return payload;
+	}
+	async assertClaimsPredicate(issuer, claims) {
+		if (!issuer.claims) return;
+		let passed;
+		try {
+			passed = await issuer.claims(structuredClone(claims)) === true;
+		} catch (e) {
+			throw new VouchlyError("claim_invalid", "The claims predicate failed.", { cause: e });
+		}
+		if (!passed) throw new VouchlyError("claim_invalid", "The claims predicate refused the token.");
+	}
+	/**
+	* Verifies a token by RFC 7662 introspection and applies the issuer's
+	* audience and claims predicate to the response.
+	*/
+	async verifyIntrospection(token, record) {
+		const claims = await introspect(token, record.issuer, this.fetch);
+		assertAudience(record.issuer, claims);
+		await this.assertClaimsPredicate(record.issuer, claims);
+		return claims;
+	}
+	async introspect(token, key, record, options, parsed) {
+		const claims = await this.verifyIntrospection(token, record);
+		await this.writeCache(key, {
+			claims,
+			issuer: record.name,
+			source: "remote"
+		}, claims.exp, record.issuer.introspection?.maxCacheTTL);
+		await resolveCertificateBinding(this.bindingClaims(claims, "remote", parsed), options);
+		return {
+			claims: structuredClone(claims),
+			issuer: record.issuer,
+			source: "remote"
+		};
+	}
+	/**
+	* A cache failure is a miss: the token is verified again instead. An entry
+	* is only served under the record an uncached verify would pick, and only
+	* after this verifier's own rules that need no signature passed on it:
+	* a verifier sharing the cache may have applied other ones.
+	*/
+	async readCache(key, token) {
+		if (!this.cache) return;
+		let entry;
+		try {
+			entry = await this.cache.get(key);
+		} catch {
+			return;
+		}
+		if (!entry) return;
+		const record = token ? this.selectRecord(token) : this.opaque;
+		const source = record.issuer.verification ?? "local";
+		if (entry.issuer !== record.name || entry.source !== source) return;
+		if (source === "local") {
+			if (!matchIssuer(record.issuer, entry.claims)) throw new VouchlyError("issuer_untrusted", "The token issuer is not trusted.");
+			assertLocalClaims(record.issuer, entry);
+		}
+		const { exp } = entry.claims;
+		if (typeof exp === "number" && exp <= Date.now() / 1e3 - (record.issuer.clockTolerance ?? 0)) throw new VouchlyError("token_expired", "The token has expired.");
+		assertAudience(record.issuer, entry.claims);
+		await this.assertClaimsPredicate(record.issuer, entry.claims);
+		return {
+			entry,
+			record
+		};
+	}
+	/**
+	* Caches until `exp`, measured to the millisecond, or for at most `maxTTL` seconds when given. A token
+	* without `exp` is cached only under a `maxTTL`. A cache failure is ignored.
+	*/
+	async writeCache(key, entry, exp, maxTTL) {
+		if (!this.cache) return;
+		let ttl;
+		if (typeof exp === "number" && Number.isFinite(exp)) ttl = exp - Date.now() / 1e3;
+		if (typeof maxTTL === "number") ttl = typeof ttl === "number" ? Math.min(ttl, maxTTL) : maxTTL;
+		if (typeof ttl !== "number" || !(ttl > 0)) return;
+		try {
+			await this.cache.set(key, structuredClone(entry), ttl);
+		} catch {}
+	}
+};
+function createVerifier(options) {
+	return new Verifier(options);
+}
+//#endregion
+export { MemoryTokenCache, VOUCHLY_ERROR_MARKER, Verifier, VouchlyError, VouchlyErrorCode, assertCertificateBinding, cachedKeys, createVerifier, discovery, fetchProviderMetadata, hashToken, introspect, isCompactToken, isVouchlyError, jwks, matchIssuer, parseToken, resolveVerificationKey, selectIssuer, staticKeys };
+
+//# sourceMappingURL=index.mjs.map