@openeudi/openid4vp 0.11.1 → 0.13.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { X509Certificate, SubjectKeyIdentifierExtension, X509Certificates, BasicConstraintsExtension, KeyUsagesExtension, KeyUsageFlags as KeyUsageFlags$1, AuthorityKeyIdentifierExtension, SubjectAlternativeNameExtension, ExtendedKeyUsageExtension, Name as Name$1 } from '@peculiar/x509';
+import { X509Certificate, SubjectKeyIdentifierExtension, BasicConstraintsExtension, KeyUsagesExtension, KeyUsageFlags as KeyUsageFlags$1, ExtendedKeyUsageExtension, AuthorityKeyIdentifierExtension, SubjectAlternativeNameExtension, Name as Name$1 } from '@peculiar/x509';
 import { v4 } from 'uuid';
 import { SignJWT, importX509, decodeProtectedHeader, jwtVerify, importJWK, compactDecrypt } from 'jose';
 import { Encoder, Tag } from 'cbor-x';
@@ -24,7 +24,7 @@ var init_reflect_polyfill = __esm({
 });
 
 // src/errors.ts
-var InvalidSignatureError, ExpiredCredentialError, UnsupportedFormatError, MalformedCredentialError, NonceValidationError, HaipValidationError, OpenID4VPError, TrustAnchorNotFoundError, CertificateChainError, RevokedCertificateError, RevocationCheckFailedError, LotlFetchError, LotlSignatureError, SignedRequestBuildError, UnsupportedJweError, DecryptionFailedError, MissingDecryptionKeyError, MissingVerifierEncryptionKeyError, MultipleCredentialsNotSupportedError;
+var InvalidSignatureError, ExpiredCredentialError, UnsupportedFormatError, MalformedCredentialError, NonceValidationError, HaipValidationError, OpenID4VPError, TrustAnchorNotFoundError, CertificateChainError, RevokedCertificateError, RevocationCheckFailedError, LotlFetchError, LotlSignatureError, LotlConfigurationError, SignedRequestBuildError, UnsupportedJweError, DecryptionFailedError, MissingDecryptionKeyError, MissingVerifierEncryptionKeyError, MultipleCredentialsNotSupportedError, GuardedFetchError;
 var init_errors = __esm({
   "src/errors.ts"() {
     init_reflect_polyfill();
@@ -121,6 +121,9 @@ var init_errors = __esm({
     LotlSignatureError = class extends OpenID4VPError {
       code = "lotl_signature_invalid";
     };
+    LotlConfigurationError = class extends OpenID4VPError {
+      code = "lotl_configuration_invalid";
+    };
     SignedRequestBuildError = class extends OpenID4VPError {
       code;
       constructor(code, message) {
@@ -168,6 +171,16 @@ var init_errors = __esm({
         this.presentationCount = presentationCount;
       }
     };
+    GuardedFetchError = class extends OpenID4VPError {
+      code = "guarded_fetch_rejected";
+      reason;
+      url;
+      constructor(reason, message, options) {
+        super(message, { cause: options.cause });
+        this.reason = reason;
+        this.url = options.url;
+      }
+    };
   }
 });
 
@@ -6564,7 +6577,7 @@ function dnIsUnder(childDn, subtreeDn) {
   }
   return true;
 }
-var NAME_CONSTRAINTS_OID, DEFAULT_ALGORITHMS, ChainBuilder;
+var NAME_CONSTRAINTS_OID, ISO_18013_5_DS_EKU, DEFAULT_MAX_CHAIN_LENGTH, DEFAULT_MAX_SIGNATURE_CHECKS, searchAborts, DEFAULT_ALGORITHMS, ChainBuilder;
 var init_ChainBuilder = __esm({
   "src/trust/ChainBuilder.ts"() {
     init_reflect_polyfill();
@@ -6573,6 +6586,10 @@ var init_ChainBuilder = __esm({
     init_errors();
     init_x509_utils();
     NAME_CONSTRAINTS_OID = "2.5.29.30";
+    ISO_18013_5_DS_EKU = "1.0.18013.5.1.2";
+    DEFAULT_MAX_CHAIN_LENGTH = 5;
+    DEFAULT_MAX_SIGNATURE_CHECKS = 32;
+    searchAborts = /* @__PURE__ */ new WeakSet();
     DEFAULT_ALGORITHMS = [
       "ES256",
       "ES384",
@@ -6595,62 +6612,130 @@ var init_ChainBuilder = __esm({
        * optionally using additional intermediates. Returns the ordered chain
        * (leaf → anchor). Throws `CertificateChainError` on any validation
        * failure.
+       *
+       * Trust is by presence in the anchor set and is established ONLY by (a) the
+       * leaf being byte-identical to an anchor, or (b) a verified signature by an
+       * anchor's key on the last certificate of the path. Subject/Issuer DN
+       * equality is used to select candidates, never to conclude trust
+       * (GHSA-4c2f-96cf-f5fc).
+       *
+       * The search is depth-first and backtracks: when several intermediates share
+       * a Subject DN — a re-issued certificate next to its expired predecessor, or
+       * cross-signed copies under different roots — a candidate that fails a check
+       * or leads nowhere does not end the search. The result therefore does not
+       * depend on the order of `intermediates`. Work is bounded by
+       * `maxChainLength` and `maxSignatureChecks`.
        */
-      async build(leaf, anchors, intermediates = []) {
-        const errors = [];
+      async build(leaf, anchors, intermediates = [], context = {}) {
+        const search = {
+          remaining: this.opts.maxSignatureChecks ?? DEFAULT_MAX_SIGNATURE_CHECKS
+        };
+        let lastFailure;
         for (const anchor of anchors) {
+          search.specific = void 0;
+          search.fallback = void 0;
           try {
-            return await this.tryBuild(leaf, anchor, intermediates);
+            const chain = await this.tryBuild(leaf, anchor, intermediates, context, search);
+            if (chain) return chain;
+            lastFailure = search.specific ?? search.fallback;
           } catch (err) {
-            errors.push(err);
+            if (searchAborts.has(err)) throw err;
+            lastFailure = err;
           }
         }
-        const last = errors[errors.length - 1];
-        if (last instanceof CertificateChainError) throw last;
+        if (lastFailure instanceof CertificateChainError) throw lastFailure;
         throw new CertificateChainError("no valid chain to any anchor", {
           reason: "signature",
-          cause: last
+          cause: lastFailure
         });
       }
-      async tryBuild(leaf, anchor, intermediates) {
-        this.checkPerCert(leaf);
-        this.checkLeafKeyUsage(leaf);
-        const chain = [leaf];
-        let current = leaf;
-        const pool = new X509Certificates(intermediates);
-        let nonLeafDepth = 0;
-        while (current.subject !== anchor.subject) {
-          const issuer = pool.find((c) => c.subject === current.issuer);
-          if (!issuer) {
-            if (current.issuer !== anchor.subject) {
-              throw new CertificateChainError(`no issuer certificate found for ${current.subject}`, {
-                reason: "signature"
-              });
-            }
-            this.checkPerCert(anchor);
-            this.checkCaAndPathLen(anchor, nonLeafDepth);
-            this.checkAkiSkiMatch(current, anchor);
-            await this.verifySignature(current, anchor);
-            chain.push(anchor);
-            this.checkNameConstraints(leaf, chain.slice(1));
-            return chain;
+      /** Search for a path from `leaf` that closes at `anchor`. */
+      async tryBuild(leaf, anchor, intermediates, context, search) {
+        this.checkPerCert(leaf, context);
+        if (certificatesEqual(leaf, anchor)) {
+          this.checkLeafKeyUsage(leaf, "generic");
+          return [leaf];
+        }
+        const profile = this.opts.profile ?? "generic";
+        this.checkLeafKeyUsage(leaf, profile);
+        this.checkLeafExtendedKeyUsage(leaf, profile);
+        const pool = intermediates.filter(
+          (c) => !certificatesEqual(c, anchor) && !certificatesEqual(c, leaf)
+        );
+        return this.extendPath([leaf], anchor, pool, context, search);
+      }
+      /**
+       * Try to complete `chain` (leaf first) to `anchor`. Returns the completed
+       * chain, or `undefined` when no extension of this prefix works — failures
+       * are recorded on `search` so the caller can report the most specific one.
+       * Throws only to abandon the whole search (signature budget exhausted).
+       */
+      async extendPath(chain, anchor, pool, context, search) {
+        const leaf = chain[0];
+        const current = chain[chain.length - 1];
+        const maxLength = this.opts.maxChainLength ?? DEFAULT_MAX_CHAIN_LENGTH;
+        if (chain.length + 1 > maxLength) {
+          search.specific = new CertificateChainError(
+            `chain from ${leaf.subject} exceeds the maximum length of ${maxLength} certificates`,
+            { reason: "path_length" }
+          );
+          return void 0;
+        }
+        const nonLeafDepth = chain.length - 1;
+        if (current.issuer === anchor.subject) {
+          try {
+            await this.closeAtAnchor(current, anchor, nonLeafDepth, context, search);
+            const closed = [...chain, anchor];
+            this.checkNameConstraints(leaf, closed.slice(1));
+            return closed;
+          } catch (err) {
+            if (searchAborts.has(err)) throw err;
+            search.specific = err;
           }
-          this.checkPerCert(issuer);
-          this.checkCaAndPathLen(issuer, nonLeafDepth);
-          this.checkAkiSkiMatch(current, issuer);
-          await this.verifySignature(current, issuer);
-          chain.push(issuer);
-          current = issuer;
-          nonLeafDepth += 1;
-        }
-        if (!certificatesEqual(current, anchor)) {
-          throw new CertificateChainError(
-            `certificate ${current.subject} shares the trust anchor's Subject DN but is not the anchor (no signature closure)`,
-            { reason: "signature" }
+        }
+        const candidates = pool.filter(
+          (c) => c.subject === current.issuer && !chain.some((x) => certificatesEqual(x, c))
+        );
+        let verified = 0;
+        for (const candidate of candidates) {
+          if (!await this.signatureVerifies(current, candidate, search)) continue;
+          verified++;
+          try {
+            this.checkPerCert(candidate, context);
+            this.checkCaAndPathLen(candidate, nonLeafDepth);
+            this.checkAkiSkiMatch(current, candidate);
+          } catch (err) {
+            search.specific = err;
+            continue;
+          }
+          const found = await this.extendPath([...chain, candidate], anchor, pool, context, search);
+          if (found) return found;
+        }
+        search.fallback = new CertificateChainError(
+          candidates.length > 0 && verified === 0 ? `signature verification failed for ${current.subject}` : `no issuer certificate found for ${current.subject}`,
+          { reason: "signature" }
+        );
+        return void 0;
+      }
+      async closeAtAnchor(current, anchor, nonLeafDepth, context, search) {
+        this.checkPerCert(anchor, context);
+        this.checkCaAndPathLen(anchor, nonLeafDepth);
+        this.checkAkiSkiMatch(current, anchor);
+        this.spendSignatureCheck(search);
+        await this.verifySignature(current, anchor);
+      }
+      /** Charge one signature verification to the search, or abandon it. */
+      spendSignatureCheck(search) {
+        if (search.remaining <= 0) {
+          const limit = this.opts.maxSignatureChecks ?? DEFAULT_MAX_SIGNATURE_CHECKS;
+          const err = new CertificateChainError(
+            `certificate path search exceeded ${limit} signature checks`,
+            { reason: "path_length" }
           );
+          searchAborts.add(err);
+          throw err;
         }
-        this.checkNameConstraints(leaf, chain.slice(1));
-        return chain;
+        search.remaining--;
       }
       /**
        * Enforce nameConstraints asserted by any CA above the leaf against the
@@ -6699,7 +6784,7 @@ var init_ChainBuilder = __esm({
         }
       }
       checkCaAndPathLen(cert, nonLeafDepth) {
-        this.checkCaKeyUsage(cert);
+        this.checkCaKeyUsage(cert, this.opts.profile ?? "generic");
         const bc = cert.getExtension(BasicConstraintsExtension);
         if (!bc || !bc.ca) {
           throw new CertificateChainError(
@@ -6714,9 +6799,17 @@ var init_ChainBuilder = __esm({
           );
         }
       }
-      checkLeafKeyUsage(leaf) {
+      checkLeafKeyUsage(leaf, profile) {
         const ext = leaf.getExtension(KeyUsagesExtension);
-        if (!ext) return;
+        if (!ext) {
+          if (profile === "iso18013-5") {
+            throw new CertificateChainError(
+              `document signer ${leaf.subject} has no keyUsage extension (ISO 18013-5 requires digitalSignature)`,
+              { reason: "key_usage" }
+            );
+          }
+          return;
+        }
         if ((ext.usages & KeyUsageFlags$1.digitalSignature) === 0) {
           throw new CertificateChainError(
             `leaf ${leaf.subject} does not assert digitalSignature key usage`,
@@ -6724,9 +6817,28 @@ var init_ChainBuilder = __esm({
           );
         }
       }
-      checkCaKeyUsage(cert) {
+      checkLeafExtendedKeyUsage(leaf, profile) {
+        if (profile !== "iso18013-5") return;
+        const ext = leaf.getExtension(ExtendedKeyUsageExtension);
+        const usages = (ext?.usages ?? []).map(String);
+        if (!usages.includes(ISO_18013_5_DS_EKU)) {
+          throw new CertificateChainError(
+            `document signer ${leaf.subject} lacks extended key usage ${ISO_18013_5_DS_EKU} (id-mdl-kp-mdlDS)`,
+            { reason: "extended_key_usage" }
+          );
+        }
+      }
+      checkCaKeyUsage(cert, profile) {
         const ext = cert.getExtension(KeyUsagesExtension);
-        if (!ext) return;
+        if (!ext) {
+          if (profile === "iso18013-5") {
+            throw new CertificateChainError(
+              `CA ${cert.subject} has no keyUsage extension (ISO 18013-5 requires keyCertSign)`,
+              { reason: "key_usage" }
+            );
+          }
+          return;
+        }
         if ((ext.usages & KeyUsageFlags$1.keyCertSign) === 0) {
           throw new CertificateChainError(
             `CA ${cert.subject} does not assert keyCertSign key usage`,
@@ -6747,30 +6859,46 @@ var init_ChainBuilder = __esm({
           );
         }
       }
+      /**
+       * Signature check used to select among DN-matching candidates. Never throws
+       * on a bad signature; throws only when the search budget is exhausted.
+       */
+      async signatureVerifies(child, issuer, search) {
+        this.spendSignatureCheck(search);
+        try {
+          return await child.verify({ publicKey: issuer.publicKey, signatureOnly: true });
+        } catch {
+          return false;
+        }
+      }
       async verifySignature(child, issuer) {
         const ok = await child.verify({ publicKey: issuer.publicKey, signatureOnly: true });
         if (!ok) {
           throw new CertificateChainError(`signature verification failed for ${child.subject}`, { reason: "signature" });
         }
       }
-      checkPerCert(cert) {
-        this.checkValidity(cert);
+      checkPerCert(cert, context = {}) {
+        const now = (this.opts.now ?? (() => /* @__PURE__ */ new Date()))();
+        this.checkValidity(cert, now, "");
+        if (context.issuedAt) {
+          this.checkValidity(cert, context.issuedAt, ` at issuance time ${context.issuedAt.toISOString()}`);
+        }
         this.checkAlgorithm(cert);
       }
-      checkValidity(cert) {
-        const now = (this.opts.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+      checkValidity(cert, at, label) {
+        const time = at.getTime();
         const skewMs = (this.opts.clockSkewTolerance ?? 60) * 1e3;
         const notBefore = cert.notBefore.getTime();
         const notAfter = cert.notAfter.getTime();
-        if (now + skewMs < notBefore) {
+        if (time + skewMs < notBefore) {
           throw new CertificateChainError(
-            `certificate ${cert.subject} not yet valid (notBefore=${cert.notBefore.toISOString()})`,
+            `certificate ${cert.subject} not yet valid${label} (notBefore=${cert.notBefore.toISOString()})`,
             { reason: "validity" }
           );
         }
-        if (now - skewMs > notAfter) {
+        if (time - skewMs > notAfter) {
           throw new CertificateChainError(
-            `certificate ${cert.subject} expired (notAfter=${cert.notAfter.toISOString()})`,
+            `certificate ${cert.subject} expired${label} (notAfter=${cert.notAfter.toISOString()})`,
             { reason: "validity" }
           );
         }
@@ -6817,6 +6945,349 @@ var init_ecdsa_util = __esm({
   }
 });
 
+// src/http/ip-address.ts
+function parseIPv4(input) {
+  const parts = input.split(".");
+  if (parts.length !== 4) return void 0;
+  const bytes = [];
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) return void 0;
+    const value = Number(part);
+    if (value > 255) return void 0;
+    bytes.push(value);
+  }
+  return bytes;
+}
+function parseIPv6(input) {
+  const address = input.split("%")[0];
+  if (!address.includes(":")) return void 0;
+  let head = address;
+  let embeddedV4;
+  const lastColon = address.lastIndexOf(":");
+  const tail = address.slice(lastColon + 1);
+  if (tail.includes(".")) {
+    embeddedV4 = parseIPv4(tail);
+    if (!embeddedV4) return void 0;
+    head = address.slice(0, lastColon + 1) + "0:0";
+  }
+  const doubleColon = head.split("::");
+  if (doubleColon.length > 2) return void 0;
+  const toGroups = (s) => s === "" ? [] : s.split(":");
+  const left = toGroups(doubleColon[0]);
+  const right = doubleColon.length === 2 ? toGroups(doubleColon[1]) : [];
+  const missing = 8 - left.length - right.length;
+  if (doubleColon.length === 2 ? missing < 1 : missing !== 0) return void 0;
+  const groups = [...left, ...Array(doubleColon.length === 2 ? missing : 0).fill("0"), ...right];
+  const bytes = [];
+  for (const group of groups) {
+    if (!/^[0-9a-fA-F]{1,4}$/.test(group)) return void 0;
+    const value = parseInt(group, 16);
+    bytes.push(value >> 8, value & 255);
+  }
+  if (embeddedV4) bytes.splice(12, 4, ...embeddedV4);
+  return bytes;
+}
+function inPrefix(bytes, prefix, bits) {
+  for (let i = 0; i < bits; i++) {
+    const byte = i >> 3;
+    const mask = 128 >> (i & 7);
+    if ((bytes[byte] & mask) !== ((prefix[byte] ?? 0) & mask)) return false;
+  }
+  return true;
+}
+function isPublicV4(bytes) {
+  return !BLOCKED_V4.some(([prefix, bits]) => inPrefix(bytes, prefix, bits));
+}
+function isPublicV6(bytes) {
+  const first10Zero = bytes.slice(0, 10).every((b) => b === 0);
+  if (first10Zero && bytes[10] === 0 && bytes[11] === 0) {
+    const v4 = bytes.slice(12);
+    if (v4.slice(0, 3).every((b) => b === 0)) return false;
+    return isPublicV4(v4);
+  }
+  if (first10Zero && bytes[10] === 255 && bytes[11] === 255) return isPublicV4(bytes.slice(12));
+  if (inPrefix(bytes, [0, 100, 255, 155], 96)) return isPublicV4(bytes.slice(12));
+  if (inPrefix(bytes, [32, 2], 16)) return isPublicV4(bytes.slice(2, 6));
+  return !BLOCKED_V6.some(([prefix, bits]) => inPrefix(bytes, prefix, bits));
+}
+function isPublicIpAddress(ip) {
+  const v4 = parseIPv4(ip);
+  if (v4) return isPublicV4(v4);
+  const v6 = parseIPv6(ip);
+  if (v6) return isPublicV6(v6);
+  return false;
+}
+function isIpLiteral(host) {
+  return parseIPv4(host) !== void 0 || parseIPv6(host) !== void 0;
+}
+var BLOCKED_V4, BLOCKED_V6;
+var init_ip_address = __esm({
+  "src/http/ip-address.ts"() {
+    init_reflect_polyfill();
+    BLOCKED_V4 = [
+      [[0, 0, 0, 0], 8],
+      [[10, 0, 0, 0], 8],
+      [[100, 64, 0, 0], 10],
+      [[127, 0, 0, 0], 8],
+      [[169, 254, 0, 0], 16],
+      [[172, 16, 0, 0], 12],
+      [[192, 0, 0, 0], 24],
+      [[192, 0, 2, 0], 24],
+      [[192, 88, 99, 0], 24],
+      [[192, 168, 0, 0], 16],
+      [[198, 18, 0, 0], 15],
+      [[198, 51, 100, 0], 24],
+      [[203, 0, 113, 0], 24],
+      [[224, 0, 0, 0], 4],
+      [[240, 0, 0, 0], 4]
+    ];
+    BLOCKED_V6 = [
+      [[1, 0], 64],
+      // 100::/64 discard-only
+      [[32, 1, 0, 0], 32],
+      // 2001::/32 Teredo (embeds an obfuscated IPv4)
+      [[32, 1, 13, 184], 32],
+      // 2001:db8::/32 documentation
+      [[252], 7],
+      // fc00::/7 unique local (incl. fd00:ec2::254 metadata)
+      [[254, 128], 10],
+      // fe80::/10 link-local
+      [[254, 192], 10],
+      // fec0::/10 deprecated site-local
+      [[255], 8]
+      // ff00::/8 multicast
+    ];
+  }
+});
+
+// src/http/guarded-fetch.ts
+function loadDns() {
+  dnsModule ??= (async () => {
+    try {
+      const specifier = "node:dns";
+      const mod = await import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        specifier
+      );
+      return mod.promises ?? mod.default?.promises;
+    } catch {
+      return void 0;
+    }
+  })();
+  return dnsModule;
+}
+function toError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+function createGuardedFetcher(options = {}) {
+  const allowHttp = options.allowHttp ?? false;
+  const allowPrivate = options.allowPrivateNetworks ?? false;
+  const maxRedirects = options.maxRedirects ?? GUARDED_FETCH_DEFAULTS.maxRedirects;
+  const timeoutMs = options.timeoutMs ?? GUARDED_FETCH_DEFAULTS.timeoutMs;
+  const maxBytes = options.maxResponseBytes ?? GUARDED_FETCH_DEFAULTS.maxResponseBytes;
+  const lookup = options.lookup ?? defaultLookup;
+  const transport = options.fetch ?? ((url, init) => globalThis.fetch(url, init));
+  return async (input, init = {}) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+      controller.abort(
+        new GuardedFetchError("timeout", `request to ${input} exceeded ${timeoutMs} ms`, { url: input })
+      );
+    }, timeoutMs);
+    const callerSignal = init.signal ?? void 0;
+    const onCallerAbort = () => controller.abort(callerSignal?.reason);
+    if (callerSignal?.aborted) onCallerAbort();
+    else callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+    const aborted = new Promise((_, reject) => {
+      const fail = () => reject(toError(controller.signal.reason));
+      if (controller.signal.aborted) fail();
+      else controller.signal.addEventListener("abort", fail, { once: true });
+    });
+    aborted.catch(() => {
+    });
+    const race = (p) => Promise.race([p, aborted]);
+    try {
+      let url = await race(validateTarget(input, void 0));
+      let method = (init.method ?? "GET").toUpperCase();
+      let body = init.body;
+      const headers = new Headers(init.headers);
+      for (let hop = 0; ; hop++) {
+        const response = await race(
+          transport(url.href, { ...init, method, body, headers, redirect: "manual", signal: controller.signal })
+        );
+        if (response.type === "opaqueredirect") {
+          throw new GuardedFetchError(
+            "invalid_redirect",
+            `redirect from ${url.href} cannot be inspected by this transport`,
+            { url: url.href }
+          );
+        }
+        if (!REDIRECT_STATUSES.has(response.status)) {
+          const bytes = await readBounded(response, url.href, maxBytes, race);
+          return new Response(NULL_BODY_STATUSES.has(response.status) ? null : bytes, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers
+          });
+        }
+        await response.body?.cancel().catch(() => {
+        });
+        if (hop >= maxRedirects) {
+          throw new GuardedFetchError(
+            "too_many_redirects",
+            `more than ${maxRedirects} redirects starting at ${input}`,
+            { url: url.href }
+          );
+        }
+        const location = response.headers.get("location");
+        if (!location) {
+          throw new GuardedFetchError(
+            "invalid_redirect",
+            `HTTP ${response.status} from ${url.href} has no Location header`,
+            { url: url.href }
+          );
+        }
+        let next;
+        try {
+          next = new URL(location, url);
+        } catch (err) {
+          throw new GuardedFetchError("invalid_redirect", `unparseable Location from ${url.href}`, {
+            url: url.href,
+            cause: toError(err)
+          });
+        }
+        const nextUrl = await race(validateTarget(next.href, url));
+        if (response.status === 303 || (response.status === 301 || response.status === 302) && method === "POST") {
+          if (method !== "HEAD") method = "GET";
+          body = void 0;
+          for (const h of BODY_HEADERS) headers.delete(h);
+        }
+        if (nextUrl.origin !== url.origin) {
+          for (const h of CROSS_ORIGIN_STRIPPED_HEADERS) headers.delete(h);
+        }
+        url = nextUrl;
+      }
+    } catch (err) {
+      if (controller.signal.aborted) throw toError(controller.signal.reason);
+      throw err;
+    } finally {
+      clearTimeout(timer);
+      callerSignal?.removeEventListener("abort", onCallerAbort);
+    }
+  };
+  async function validateTarget(raw, previous) {
+    let url;
+    try {
+      url = new URL(raw);
+    } catch (err) {
+      throw new GuardedFetchError("invalid_url", `not an absolute URL: ${raw}`, { url: raw, cause: toError(err) });
+    }
+    if (url.protocol !== "https:" && !(allowHttp && url.protocol === "http:")) {
+      throw new GuardedFetchError("insecure_scheme", `refusing ${url.protocol} URL ${url.href}: HTTPS is required`, {
+        url: url.href
+      });
+    }
+    if (previous?.protocol === "https:" && url.protocol !== "https:") {
+      throw new GuardedFetchError("insecure_scheme", `refusing https -> http redirect to ${url.href}`, {
+        url: url.href
+      });
+    }
+    if (allowPrivate) return url;
+    const host = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    if (host === "localhost" || host.endsWith(".localhost")) {
+      throw new GuardedFetchError("private_address", `refusing loopback host ${host}`, { url: url.href });
+    }
+    if (isIpLiteral(host)) {
+      if (!isPublicIpAddress(host)) {
+        throw new GuardedFetchError("private_address", `refusing non-public address ${host}`, { url: url.href });
+      }
+      return url;
+    }
+    let addresses;
+    try {
+      addresses = await lookup(host);
+    } catch (err) {
+      throw new GuardedFetchError("dns_resolution_failed", `could not resolve ${host}`, {
+        url: url.href,
+        cause: toError(err)
+      });
+    }
+    if (addresses === void 0) return url;
+    if (addresses.length === 0) {
+      throw new GuardedFetchError("dns_resolution_failed", `${host} resolved to no addresses`, {
+        url: url.href
+      });
+    }
+    const blocked = addresses.find((a) => !isPublicIpAddress(a));
+    if (blocked !== void 0) {
+      throw new GuardedFetchError("private_address", `${host} resolves to non-public address ${blocked}`, {
+        url: url.href
+      });
+    }
+    return url;
+  }
+}
+async function readBounded(response, url, maxBytes, race) {
+  const tooLarge = () => new GuardedFetchError("response_too_large", `response from ${url} exceeds ${maxBytes} bytes`, { url });
+  const declared = response.headers.get("content-length");
+  if (declared !== null && Number(declared) > maxBytes) {
+    await response.body?.cancel().catch(() => {
+    });
+    throw tooLarge();
+  }
+  if (!response.body) return null;
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await race(reader.read());
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) throw tooLarge();
+      chunks.push(value);
+    }
+  } catch (err) {
+    reader.cancel().catch(() => {
+    });
+    throw err;
+  }
+  const out = new Uint8Array(new ArrayBuffer(total));
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+function createDefaultTrustFetcher() {
+  return createGuardedFetcher({ allowHttp: true });
+}
+var GUARDED_FETCH_DEFAULTS, REDIRECT_STATUSES, NULL_BODY_STATUSES, CROSS_ORIGIN_STRIPPED_HEADERS, BODY_HEADERS, dnsModule, defaultLookup;
+var init_guarded_fetch = __esm({
+  "src/http/guarded-fetch.ts"() {
+    init_reflect_polyfill();
+    init_errors();
+    init_ip_address();
+    GUARDED_FETCH_DEFAULTS = {
+      maxRedirects: 3,
+      timeoutMs: 15e3,
+      maxResponseBytes: 16 * 1024 * 1024
+    };
+    REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+    NULL_BODY_STATUSES = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
+    CROSS_ORIGIN_STRIPPED_HEADERS = ["authorization", "cookie", "proxy-authorization"];
+    BODY_HEADERS = ["content-type", "content-length", "content-encoding", "content-language", "content-location"];
+    defaultLookup = async (hostname) => {
+      const dns = await loadDns();
+      if (!dns) return void 0;
+      const records = await dns.lookup(hostname, { all: true, verbatim: true });
+      return records.map((r) => r.address);
+    };
+  }
+});
+
 // src/trust/CrlFetcher.ts
 function normalizeCrl(parsed, der) {
   const thisUpdate = parsed.tbsCertList.thisUpdate.getTime();
@@ -6852,11 +7323,12 @@ var init_CrlFetcher = __esm({
     init_es2015();
     init_es20152();
     init_ecdsa_util();
+    init_guarded_fetch();
     CrlFetcher = class {
       fetcher;
       cache;
       constructor(opts = {}) {
-        this.fetcher = opts.fetcher ?? globalThis.fetch.bind(globalThis);
+        this.fetcher = opts.fetcher ?? createDefaultTrustFetcher();
         this.cache = opts.cache;
       }
       async fetchAndParse(url) {
@@ -7588,12 +8060,13 @@ var init_OcspClient = __esm({
     init_es20152();
     init_ChainBuilder();
     init_ecdsa_util();
+    init_guarded_fetch();
     DEFAULT_MAX_RESPONSE_AGE_MS = 7 * 24 * 3600 * 1e3;
     OcspClient = class {
       fetcher;
       cache;
       constructor(opts = {}) {
-        this.fetcher = opts.fetcher ?? globalThis.fetch.bind(globalThis);
+        this.fetcher = opts.fetcher ?? createDefaultTrustFetcher();
         this.cache = opts.cache;
       }
       /**
@@ -8059,7 +8532,9 @@ var init_ProvenanceResolver = __esm({
 // src/trust/TrustEvaluator.ts
 var TrustEvaluator_exports = {};
 __export(TrustEvaluator_exports, {
-  TrustEvaluator: () => TrustEvaluator
+  MAX_CREDENTIAL_CERTIFICATES: () => MAX_CREDENTIAL_CERTIFICATES,
+  TrustEvaluator: () => TrustEvaluator,
+  evaluateCredentialIssuer: () => evaluateCredentialIssuer
 });
 function deriveHint(leaf) {
   const aki = leaf.getExtension(AuthorityKeyIdentifierExtension);
@@ -8070,6 +8545,13 @@ function deriveHint(leaf) {
     aki: akiBytes
   };
 }
+function deriveSelfHint(cert) {
+  const skiHex = getSkiHex(cert);
+  return {
+    issuer: cert.subject,
+    aki: skiHex ? hexToBytes(skiHex) : void 0
+  };
+}
 function hexToBytes(s) {
   const clean = s.replace(/[^0-9a-f]/gi, "");
   const out = new Uint8Array(clean.length / 2);
@@ -8101,7 +8583,31 @@ async function resolveProvenance(store, anchor) {
     return void 0;
   }
 }
-var TrustEvaluator;
+async function evaluateCredentialIssuer(input) {
+  const [signerDer, ...rest] = input.chain;
+  if (!signerDer) {
+    throw new MalformedCredentialError("Missing issuer certificate");
+  }
+  if (input.chain.length > MAX_CREDENTIAL_CERTIFICATES) {
+    throw new MalformedCredentialError(
+      `x5c/x5chain carries ${input.chain.length} certificates; at most ${MAX_CREDENTIAL_CERTIFICATES} are accepted`
+    );
+  }
+  const parse = (bytes, position) => {
+    try {
+      return new X509Certificate(bytes);
+    } catch (err) {
+      throw new MalformedCredentialError(
+        `Invalid certificate at x5c/x5chain position ${position}: ${err.message}`
+      );
+    }
+  };
+  const leaf = parse(signerDer, 0);
+  const intermediates = rest.map((bytes, i) => parse(bytes, i + 1));
+  const { chain, issuedAt, ...evaluatorOptions } = input;
+  return new TrustEvaluator(evaluatorOptions).evaluate(leaf, { intermediates, issuedAt });
+}
+var TrustEvaluator, MAX_CREDENTIAL_CERTIFICATES;
 var init_TrustEvaluator = __esm({
   "src/trust/TrustEvaluator.ts"() {
     init_reflect_polyfill();
@@ -8127,13 +8633,10 @@ var init_TrustEvaluator = __esm({
       revocationChecker;
       async evaluate(leaf, context = {}) {
         const hint = deriveHint(leaf);
-        const seen = /* @__PURE__ */ new Set();
         const anchors = [];
         const pushUnique = (batch) => {
           for (const a of batch) {
-            const key = a.certificate.serialNumber;
-            if (seen.has(key)) continue;
-            seen.add(key);
+            if (anchors.some((x) => certificatesEqual(x.certificate, a.certificate))) continue;
             anchors.push(a);
           }
         };
@@ -8141,6 +8644,7 @@ var init_TrustEvaluator = __esm({
         for (const inter of context.intermediates ?? []) {
           pushUnique(await this.trustStore.getAnchors(deriveHint(inter)));
         }
+        pushUnique(await this.trustStore.getAnchors(deriveSelfHint(leaf)));
         if (anchors.length === 0) {
           throw new TrustAnchorNotFoundError(
             `no trust anchor for issuer=${hint.issuer ?? "(none)"}`
@@ -8150,7 +8654,8 @@ var init_TrustEvaluator = __esm({
         const chain = await this.chainBuilder.build(
           leaf,
           anchorCerts,
-          context.intermediates ?? []
+          context.intermediates ?? [],
+          { issuedAt: context.issuedAt }
         );
         const terminusCert = chain[chain.length - 1];
         const anchor = anchors.find(
@@ -8190,6 +8695,7 @@ var init_TrustEvaluator = __esm({
         };
       }
     };
+    MAX_CREDENTIAL_CERTIFICATES = 10;
   }
 });
 
@@ -8422,6 +8928,33 @@ function buildHaipQuery(input) {
   }
   return { credentials: [credential] };
 }
+function buildCredentialSetQuery(input) {
+  if (input.options.length === 0) {
+    throw new HaipValidationError(
+      "EMPTY_OPTIONS",
+      "a credential set must offer at least one option"
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const option of input.options) {
+    if (seen.has(option.credentialId)) {
+      throw new HaipValidationError(
+        "DUPLICATE_CREDENTIAL_ID",
+        `credential '${option.credentialId}' is declared by more than one option; credential ids must be unique for credential_sets to reference them`,
+        option.credentialId
+      );
+    }
+    seen.add(option.credentialId);
+  }
+  const credentials = input.options.map((option) => buildHaipQuery(option).credentials[0]);
+  const credentialSet = {
+    options: input.options.map((option) => [option.credentialId])
+  };
+  if (input.required === false) {
+    credentialSet.required = false;
+  }
+  return { credentials, credential_sets: [credentialSet] };
+}
 var HAIP_FORMATS = /* @__PURE__ */ new Set(["dc+sd-jwt", "mso_mdoc"]);
 function validateHaipQuery(query) {
   if (!query.credentials || query.credentials.length === 0) {
@@ -8437,46 +8970,86 @@ function validateHaipQuery(query) {
     );
   }
   for (const credential of query.credentials) {
-    if (!HAIP_FORMATS.has(credential.format)) {
+    validateCredential(credential);
+  }
+}
+function validateCredential(credential) {
+  if (!HAIP_FORMATS.has(credential.format)) {
+    throw new HaipValidationError(
+      "UNSUPPORTED_FORMAT",
+      `credential '${credential.id}' uses unsupported format '${credential.format}' (allowed: dc+sd-jwt, mso_mdoc)`,
+      credential.id
+    );
+  }
+  if (credential.format === "dc+sd-jwt") {
+    const vctValues = credential.meta?.vct_values;
+    if (!vctValues || vctValues.length === 0) {
       throw new HaipValidationError(
-        "UNSUPPORTED_FORMAT",
-        `credential '${credential.id}' uses unsupported format '${credential.format}' (allowed: dc+sd-jwt, mso_mdoc)`,
+        "MISSING_SDJWT_META",
+        `credential '${credential.id}' with format 'dc+sd-jwt' must set meta.vct_values`,
         credential.id
       );
     }
-    if (credential.format === "dc+sd-jwt") {
-      const vctValues = credential.meta?.vct_values;
-      if (!vctValues || vctValues.length === 0) {
-        throw new HaipValidationError(
-          "MISSING_SDJWT_META",
-          `credential '${credential.id}' with format 'dc+sd-jwt' must set meta.vct_values`,
-          credential.id
-        );
-      }
-    }
-    if (credential.format === "mso_mdoc") {
-      if (typeof credential.meta?.doctype_value !== "string") {
-        throw new HaipValidationError(
-          "MISSING_MDOC_META",
-          `credential '${credential.id}' with format 'mso_mdoc' must set meta.doctype_value`,
-          credential.id
-        );
-      }
-    }
-    if (!credential.claims || credential.claims.length === 0) {
+  }
+  if (credential.format === "mso_mdoc") {
+    if (typeof credential.meta?.doctype_value !== "string") {
       throw new HaipValidationError(
-        "NO_CLAIMS",
-        `credential '${credential.id}' must declare at least one claim`,
+        "MISSING_MDOC_META",
+        `credential '${credential.id}' with format 'mso_mdoc' must set meta.doctype_value`,
         credential.id
       );
     }
-    if (credential.claim_sets !== void 0) {
+  }
+  if (!credential.claims || credential.claims.length === 0) {
+    throw new HaipValidationError(
+      "NO_CLAIMS",
+      `credential '${credential.id}' must declare at least one claim`,
+      credential.id
+    );
+  }
+  if (credential.claim_sets !== void 0) {
+    throw new HaipValidationError(
+      "CLAIM_SETS_DISALLOWED",
+      `credential '${credential.id}' uses claim_sets, not permitted in HAIP-minimal`,
+      credential.id
+    );
+  }
+}
+function validateCredentialSetQuery(query) {
+  if (!query.credentials || query.credentials.length === 0) {
+    throw new HaipValidationError(
+      "EMPTY_QUERY",
+      "query.credentials must have at least one entry"
+    );
+  }
+  if (!query.credential_sets || query.credential_sets.length === 0) {
+    throw new HaipValidationError(
+      "MISSING_CREDENTIAL_SETS",
+      "a credential-set query must declare at least one credential_sets entry"
+    );
+  }
+  for (const credential of query.credentials) {
+    validateCredential(credential);
+  }
+  const declaredIds = new Set(query.credentials.map((c) => c.id));
+  for (const credentialSet of query.credential_sets) {
+    if (!credentialSet.options || credentialSet.options.length === 0) {
       throw new HaipValidationError(
-        "CLAIM_SETS_DISALLOWED",
-        `credential '${credential.id}' uses claim_sets, not permitted in HAIP-minimal`,
-        credential.id
+        "EMPTY_OPTIONS",
+        "a credential set must offer at least one option"
       );
     }
+    for (const option of credentialSet.options) {
+      for (const id of option) {
+        if (!declaredIds.has(id)) {
+          throw new HaipValidationError(
+            "UNKNOWN_OPTION_REFERENCE",
+            `credential_sets option references '${id}', which is not declared in query.credentials`,
+            id
+          );
+        }
+      }
+    }
   }
 }
 function isHaipQuery(query) {
@@ -8914,6 +9487,14 @@ function bytesEqual3(a, b) {
   }
   return true;
 }
+function peekMsoSigned(payload) {
+  try {
+    const signed = decodeMso(payload).validityInfo.signed;
+    return Number.isFinite(signed.getTime()) ? signed : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function derToPem(der) {
   let binary = "";
   for (const b of der) binary += String.fromCharCode(b);
@@ -9074,17 +9655,17 @@ var MdocParser = class {
     }
     let trustResult;
     if (options.trustStore) {
-      const { TrustEvaluator: TrustEvaluator2 } = await Promise.resolve().then(() => (init_TrustEvaluator(), TrustEvaluator_exports));
-      const evaluator = new TrustEvaluator2({
+      const { evaluateCredentialIssuer: evaluateCredentialIssuer2 } = await Promise.resolve().then(() => (init_TrustEvaluator(), TrustEvaluator_exports));
+      trustResult = await evaluateCredentialIssuer2({
+        chain: cose.x5chain,
+        profile: "iso18013-5",
+        issuedAt: peekMsoSigned(cose.payload),
         trustStore: options.trustStore,
         revocationPolicy: options.revocationPolicy ?? "skip",
         fetcher: options.fetcher,
         cache: options.cache,
         clockSkewTolerance: options.clockSkewTolerance
       });
-      const { X509Certificate: X509Certificate9 } = await import('@peculiar/x509');
-      const leaf = new X509Certificate9(issuerCertBytes);
-      trustResult = await evaluator.evaluate(leaf);
     } else {
       if (options.trustedCertificates.length === 0) {
         if (options.skipTrustCheck !== true) {
@@ -9233,6 +9814,13 @@ var MdocParser = class {
 init_reflect_polyfill();
 init_errors();
 var DEFAULT_ALLOWED_ALGORITHMS2 = ["ES256", "ES384", "ES512"];
+var SD_JWT_VC_TYP = "dc+sd-jwt";
+var LEGACY_SD_JWT_VC_TYP = "vc+sd-jwt";
+function normalizeTyp(typ) {
+  if (typeof typ !== "string") return void 0;
+  const lower = typ.toLowerCase();
+  return lower.startsWith("application/") ? lower.slice("application/".length) : lower;
+}
 var sha256Hasher = async (data, _alg) => {
   const encoder2 = new TextEncoder();
   const input = typeof data === "string" ? encoder2.encode(data) : data;
@@ -9345,6 +9933,18 @@ var SdJwtParser = class {
     if (typeof alg !== "string" || !allowedAlgorithms.includes(alg)) {
       return invalidResult(`Unsupported algorithm: ${alg}`);
     }
+    const typ = normalizeTyp(header.typ);
+    if (typ === LEGACY_SD_JWT_VC_TYP) {
+      if (options.allowLegacyVcSdJwtTyp !== true) {
+        return invalidResult(
+          `Legacy SD-JWT VC typ '${LEGACY_SD_JWT_VC_TYP}' is not accepted (removed in draft-ietf-oauth-sd-jwt-vc-19; expected '${SD_JWT_VC_TYP}'). Set allowLegacyVcSdJwtTyp to accept it during migration.`
+        );
+      }
+    } else if (typ !== SD_JWT_VC_TYP) {
+      return invalidResult(
+        `Unsupported SD-JWT VC typ: ${header.typ === void 0 ? "(missing)" : String(header.typ)} (expected '${SD_JWT_VC_TYP}')`
+      );
+    }
     const x5cArray = header.x5c;
     const hasX5c = Array.isArray(x5cArray) && x5cArray.length > 0 && typeof x5cArray[0] === "string";
     let issuerKey;
@@ -9414,17 +10014,22 @@ var SdJwtParser = class {
     };
     let trustResult;
     if (issuerCertBytes === void 0) ; else if (options.trustStore) {
-      const { TrustEvaluator: TrustEvaluator2 } = await Promise.resolve().then(() => (init_TrustEvaluator(), TrustEvaluator_exports));
-      const evaluator = new TrustEvaluator2({
+      const { evaluateCredentialIssuer: evaluateCredentialIssuer2 } = await Promise.resolve().then(() => (init_TrustEvaluator(), TrustEvaluator_exports));
+      const x5cRest = x5cArray.slice(1);
+      if (!x5cRest.every((entry) => typeof entry === "string")) {
+        throw new MalformedCredentialError("x5c entries must be base64 strings");
+      }
+      const iat = payload["iat"];
+      trustResult = await evaluateCredentialIssuer2({
+        chain: [issuerCertBytes, ...x5cRest.map((entry) => base64ToBytes(entry))],
+        profile: "generic",
+        issuedAt: typeof iat === "number" && Number.isFinite(iat) ? new Date(iat * 1e3) : void 0,
         trustStore: options.trustStore,
         revocationPolicy: options.revocationPolicy ?? "skip",
         fetcher: options.fetcher,
         cache: options.cache,
         clockSkewTolerance: options.clockSkewTolerance
       });
-      const { X509Certificate: X509Certificate9 } = await import('@peculiar/x509');
-      const leaf = new X509Certificate9(issuerCertBytes);
-      trustResult = await evaluator.evaluate(leaf);
     } else {
       if (options.trustedCertificates.length === 0) {
         if (options.skipTrustCheck !== true) {
@@ -9860,6 +10465,9 @@ var InMemoryCache = class {
   }
 };
 
+// src/index.ts
+init_guarded_fetch();
+
 // src/trust/index.ts
 init_reflect_polyfill();
 
@@ -9907,14 +10515,10 @@ var CompositeTrustStore = class {
     const results = await Promise.all(
       this.stores.map((store) => store.getAnchors(hint))
     );
-    const seen = /* @__PURE__ */ new Set();
     const out = [];
     for (const batch of results) {
       for (const anchor of batch) {
-        const ski = getSkiHex(anchor.certificate);
-        const key = ski ?? anchor.certificate.serialNumber;
-        if (seen.has(key)) continue;
-        seen.add(key);
+        if (out.some((a) => certificatesEqual(a.certificate, anchor.certificate))) continue;
         out.push(anchor);
       }
     }
@@ -9946,6 +10550,7 @@ function bytesToHex3(bytes) {
 
 // src/trust/LotlTrustStore.ts
 init_reflect_polyfill();
+init_errors();
 
 // src/trust/lotl-signing-anchors.ts
 init_reflect_polyfill();
@@ -10007,13 +10612,15 @@ var EU_LOTL_SIGNING_ANCHORS = Object.freeze(
 // src/trust/LotlFetcher.ts
 init_reflect_polyfill();
 init_errors();
+init_guarded_fetch();
 var XMLDSIG_NS = "http://www.w3.org/2000/09/xmldsig#";
 var LotlFetcher = class {
   fetcher;
   constructor(opts = {}) {
-    this.fetcher = opts.fetcher ?? globalThis.fetch.bind(globalThis);
+    this.fetcher = opts.fetcher ?? createDefaultTrustFetcher();
   }
   async fetchSigned(url, signingAnchors) {
+    assertCryptoEngineRegistered();
     let xmlText;
     try {
       const response = await this.fetcher(url, { method: "GET" });
@@ -10066,6 +10673,22 @@ var LotlFetcher = class {
     );
   }
 };
+function assertCryptoEngineRegistered() {
+  let engine;
+  try {
+    engine = xmldsig.Application.crypto;
+  } catch (err) {
+    throw new LotlConfigurationError(
+      `no xmldsigjs crypto engine registered \u2014 trusted-list signatures cannot be verified. Call xmldsig.Application.setEngine('NodeJS', new Crypto()) (e.g. from @peculiar/webcrypto) once at startup, before using LotlTrustStore. Underlying error: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err instanceof Error ? err : void 0 }
+    );
+  }
+  if (!engine) {
+    throw new LotlConfigurationError(
+      "no xmldsigjs crypto engine registered \u2014 trusted-list signatures cannot be verified. Call xmldsig.Application.setEngine('NodeJS', new Crypto()) (e.g. from @peculiar/webcrypto) once at startup, before using LotlTrustStore."
+    );
+  }
+}
 async function verifyAgainst(doc, sigEl, anchor) {
   try {
     const signed = new xmldsig.SignedXml(doc);
@@ -10213,6 +10836,7 @@ function parsePointer(el) {
 
 // src/trust/NationalTlResolver.ts
 init_reflect_polyfill();
+init_errors();
 var TSL_NS2 = "http://uri.etsi.org/02231/v2#";
 var NationalTlResolver = class {
   constructor(opts) {
@@ -10228,6 +10852,7 @@ var NationalTlResolver = class {
         );
         return parseNationalTl(doc, pointer.country);
       } catch (err) {
+        if (err instanceof LotlConfigurationError) throw err;
         console.warn(
           `[openid4vp] national TL for ${pointer.country} failed: ${err.message}`
         );
@@ -10406,6 +11031,7 @@ var LotlTrustStore = class {
         };
         return this.snapshot;
       } catch (err) {
+        if (err instanceof LotlConfigurationError) throw err;
         if (this.snapshot) {
           console.warn(
             `[openid4vp] LOTL refresh failed; serving cached snapshot (${err.message})`
@@ -10453,7 +11079,7 @@ function equalBytes(a, b) {
 
 // src/index.ts
 init_errors();
-var VERSION = "0.11.1";
+var VERSION = "0.13.0";
 /*! Bundled license information:
 
 pvtsutils/build/index.es.js:
@@ -10523,6 +11149,6 @@ asn1js/build/index.es.js:
    *)
 */
 
-export { CertificateChainError, CompositeTrustStore, DecryptionFailedError, ExpiredCredentialError, HAIP_DOCTYPE_NAMESPACES, HaipValidationError, InMemoryCache, InvalidSignatureError, LotlFetchError, LotlSignatureError, LotlTrustStore, MalformedCredentialError, MdocParser, MissingDecryptionKeyError, MissingVerifierEncryptionKeyError, MultipleCredentialsNotSupportedError, NonceValidationError, OpenID4VPError, RevocationCheckFailedError, RevokedCertificateError, SdJwtParser, SignedRequestBuildError, StaticTrustStore, TrustAnchorNotFoundError, UnsupportedFormatError, UnsupportedJweError, VERSION, buildHaipQuery, buildOid4vpSessionTranscript, buildOpenID4VPHandoverSessionTranscript, createAuthorizationRequest, createSignedAuthorizationRequest, decryptAuthorizationResponse, isHaipQuery, parsePresentation, validateHaipQuery, verifyAuthorizationResponse, verifyPresentation };
+export { CertificateChainError, CompositeTrustStore, DecryptionFailedError, ExpiredCredentialError, GUARDED_FETCH_DEFAULTS, GuardedFetchError, HAIP_DOCTYPE_NAMESPACES, HaipValidationError, InMemoryCache, InvalidSignatureError, LotlConfigurationError, LotlFetchError, LotlSignatureError, LotlTrustStore, MalformedCredentialError, MdocParser, MissingDecryptionKeyError, MissingVerifierEncryptionKeyError, MultipleCredentialsNotSupportedError, NonceValidationError, OpenID4VPError, RevocationCheckFailedError, RevokedCertificateError, SdJwtParser, SignedRequestBuildError, StaticTrustStore, TrustAnchorNotFoundError, UnsupportedFormatError, UnsupportedJweError, VERSION, buildCredentialSetQuery, buildHaipQuery, buildOid4vpSessionTranscript, buildOpenID4VPHandoverSessionTranscript, createAuthorizationRequest, createGuardedFetcher, createSignedAuthorizationRequest, decryptAuthorizationResponse, isHaipQuery, parsePresentation, validateCredentialSetQuery, validateHaipQuery, verifyAuthorizationResponse, verifyPresentation };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map