@blamejs/core 0.18.53 → 0.18.55

package/lib/vendor/blamejs-pki.cjs

@@ -1,4 +1,4 @@
-// @blamejs/pki v0.5.28 — vendored (Apache-2.0). Zero-dep pure CJS.
+// @blamejs/pki v0.5.31 — vendored (Apache-2.0). Zero-dep pure CJS.
 // https://github.com/blamejs/pki  Exports: x509, crl, pkcs12, key, webcrypto, schema, csr, cms, ...
 // Backs lib/mtls-engine-default.js (PQC-capable CA + PKCS#12 engine).
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -141,7 +141,7 @@ var require_package = __commonJS({
   "node_modules/@blamejs/pki/package.json"(exports2, module2) {
     module2.exports = {
       name: "@blamejs/pki",
-      version: "0.5.28",
+      version: "0.5.31",
       description: "Pure-JavaScript PKI toolkit that owns its stack \u2014 X.509, ASN.1/DER, CMS, PQC-first.",
       license: "Apache-2.0",
       author: "blamejs contributors",
@@ -1957,6 +1957,41 @@ var require_oid = __commonJS({
       // The arc is RSA-dedicated, so a consumer can classify the whole family by its prefix; one member is
       // registered here so that prefix can be derived from the registry rather than a dotted-decimal literal.
       teletrustRsaSig: { base: [1, 3, 36, 3, 3, 1], of: { "rsaSignatureWithripemd160": 2 } },
+      // TeleTrusT (BSI) signatureScheme arc (1.3.36.3.4) -- the ISO/IEC 9796-2 RSA signatures giving message
+      // recovery (schemes 1/2/3: two deterministic, one randomized). ISO/IEC 9796-2 is titled "integer
+      // factorization based mechanisms", so EVERY scheme it defines is RSA and the standard has no non-RSA
+      // member; each node is registered so a consumer can name it -- e.g. the CMP keySpec RSA exclusion, which
+      // must recognize RSA wherever it is standardized. ISO/IEC 9796-2 assigns no algorithm OIDs of its own;
+      // this registrant tree is the de-facto registry. The .2 (deterministic) and .3 (randomized) sub-arcs are
+      // RSA-dedicated in full -- every descendant is RSA -- so a consumer prefix-matches each to catch a hash
+      // variant added later; the per-hash leaves are registered for readability. The `...Withrsa-even-exp`
+      // nodes (.2.1 / .3.1) are the even-public-exponent RSA variants the registrant marks "not used"; they are
+      // RSA (the registrant names them `sigS_ISO9796-2Withrsa_even-exp`), so the sub-arc prefix classifies them
+      // correctly, not wrongly. .1 is ISO/IEC 9796-1, also RSA, on the same arc. The PARENT node (.4) is generic
+      // "signatureScheme" and the sibling authentication arc (.5) is mixed (its .5.3 children are ECC), so
+      // neither is RSA-dedicated -- a consumer must not prefix-match the parent or .5.
+      teletrustSigScheme: { base: [1, 3, 36, 3, 4], of: {
+        "sigS-ISO9796-1": 1,
+        "sigS-ISO9796-1-DFUE": [1, 1],
+        "sigS-ISO9796-2": 2,
+        "sigS-ISO9796-2Withrsa-even-exp": [2, 1],
+        "sigS-ISO9796-2Withrsa": [2, 2],
+        "sigS-ISO9796-2Withrsa-sha1": [2, 2, 1],
+        "sigS-ISO9796-2Withrsa-ripemd160": [2, 2, 2],
+        "sigS-ISO9796-2Withrsa-sha224": [2, 2, 3],
+        "sigS-ISO9796-2Withrsa-sha256": [2, 2, 4],
+        "sigS-ISO9796-2Withrsa-sha384": [2, 2, 5],
+        "sigS-ISO9796-2Withrsa-sha512": [2, 2, 6],
+        "sigS-ISO9796-2rnd": 3,
+        "sigS-ISO9796-2rndWithrsa-even-exp": [3, 1],
+        "sigS-ISO9796-2rndWithrsa": [3, 2],
+        "sigS-ISO9796-2rndWithrsa-sha1": [3, 2, 1],
+        "sigS-ISO9796-2rndWithrsa-ripemd160": [3, 2, 2],
+        "sigS-ISO9796-2rndWithrsa-sha224": [3, 2, 3],
+        "sigS-ISO9796-2rndWithrsa-sha256": [3, 2, 4],
+        "sigS-ISO9796-2rndWithrsa-sha384": [3, 2, 5],
+        "sigS-ISO9796-2rndWithrsa-sha512": [3, 2, 6]
+      } },
       // X.509 directory encryptionAlgorithm arc (2.5.8.1). id-ea-rsa (.1) is the X.509 `rsa` public-key
       // identifier, distinct from PKCS#1 rsaEncryption. Registered so a consumer can name it -- e.g. the
       // CMP keySpec RSA exclusion, which must recognize RSA wherever it is standardized.
@@ -5721,6 +5756,7 @@ var require_asn1_der = __commonJS({
         return _asBuffer(buf, "build.raw");
       }
     };
+    intrinsic.freeze(build);
     function _intContent(v, who) {
       if (Buffer.isBuffer(v)) {
         if (v.length === 0) throw new Asn1Error("asn1/bad-integer", who + ": INTEGER content is empty");
@@ -18378,7 +18414,10 @@ var require_sign_scheme = __commonJS({
     }
     function _assertKeyMatchesScheme(key, imp, E) {
       var ka = key.algorithm || {};
-      if (_toUpperCase(_String(ka.name)) !== _toUpperCase(_String(imp.name))) throw E("bad-input", "the signer CryptoKey algorithm (" + ka.name + ") does not match the certificate's key algorithm (" + imp.name + ")");
+      if (_toUpperCase(_String(ka.name)) !== _toUpperCase(_String(imp.name))) {
+        var hint = _toUpperCase(_String(ka.name)) === "RSA-PSS" && _toUpperCase(_String(imp.name)) === "RSASSA-PKCS1-V1_5" ? "; this CryptoKey is bound to RSASSA-PSS -- pass opts.pss to sign with RSASSA-PSS" : "";
+        throw E("bad-input", "the signer CryptoKey algorithm (" + ka.name + ") does not match the certificate's key algorithm (" + imp.name + ")" + hint);
+      }
       if (imp.hash && (!ka.hash || ka.hash.name !== imp.hash)) throw E("bad-input", "the signer CryptoKey hash (" + (ka.hash && ka.hash.name) + ") does not match the signing digest (" + imp.hash + ")");
       if (imp.namedCurve && ka.namedCurve !== imp.namedCurve) throw E("bad-input", "the signer CryptoKey curve (" + ka.namedCurve + ") does not match the certificate curve (" + imp.namedCurve + ")");
     }
@@ -18401,7 +18440,10 @@ var require_sign_scheme = __commonJS({
       return { mldsa: _normPkcs8(key.mldsa, "the composite ML-DSA component key", E), trad: _normPkcs8(key.trad, "the composite traditional component key", E) };
     }
     function _importKey(key, imp, E) {
-      if (key && typeof key === "object" && !_isBuffer(key) && !_isU8(key) && key.type === "private") {
+      if (key && typeof key === "object" && !_isBuffer(key) && !_isU8(key) && typeof key.type === "string" && key.algorithm != null) {
+        if (key.type !== "private") {
+          throw E("bad-input", "the signing key is a WebCrypto CryptoKey of type " + _stringify(key.type) + '; a signing key must be a private key (type "private")');
+        }
         _assertKeyMatchesScheme(key, imp, E);
         return webcrypto.adoptKey(key, imp, ["sign"], E, "bad-input");
       }
@@ -18417,7 +18459,9 @@ var require_sign_scheme = __commonJS({
           throw E("bad-input", "the signer PEM private key could not be decoded", e);
         }
         owned = true;
-      } else throw E("bad-input", "a signer key must be a CryptoKey, a PKCS#8 DER Buffer, or a PKCS#8 PEM string");
+      } else if (intrinsic.types.isKeyObject(key)) {
+        throw E("bad-input", "the signing key is a node:crypto KeyObject, not a WebCrypto CryptoKey; pass a CryptoKey (e.g. from pki.key.generate) or export it to a PKCS#8 DER Buffer or PEM string");
+      } else throw E("bad-input", "a signer key must be a WebCrypto CryptoKey, a PKCS#8 DER Buffer, or a PKCS#8 PEM string");
       var imported = subtle.importKey("pkcs8", der, imp, false, ["sign"]);
       if (!owned) return imported;
       return imported.then(function(k) {
@@ -18457,35 +18501,101 @@ var require_sign_scheme = __commonJS({
 var require_ip_utils = __commonJS({
   "node_modules/@blamejs/pki/lib/ip-utils.js"(exports2, module2) {
     "use strict";
-    var IPV4_RE = /^(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
+    var intrinsic = require_guard_intrinsic();
+    var _slice = intrinsic.uncurry(String.prototype.slice);
+    var _padStart = intrinsic.uncurry(String.prototype.padStart);
+    var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+    var _lastIndexOf = intrinsic.uncurry(String.prototype.lastIndexOf);
+    var _toLowerCase = intrinsic.toLowerCase;
+    var _indexOf = intrinsic.stringIndexOf;
+    var _numToString = intrinsic.numberToString;
+    var _bufferFrom = intrinsic.bufferFrom;
+    var _bufferAlloc = intrinsic.bufferAlloc;
+    var _defineProperty = intrinsic.defineProperty;
+    var _Number = intrinsic.Number;
+    function _push(arr, v) {
+      _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true });
+    }
+    function _splitOn(str, sep) {
+      var out = [], from = 0, at;
+      while ((at = _indexOf(str, sep, from)) !== -1) {
+        _push(out, _slice(str, from, at));
+        from = at + sep.length;
+      }
+      _push(out, _slice(str, from));
+      return out;
+    }
+    function _isDigitCode(c) {
+      return c >= 48 && c <= 57;
+    }
+    function _isHexCode(c) {
+      return c >= 48 && c <= 57 || c >= 97 && c <= 102 || c >= 65 && c <= 70;
+    }
+    function _isOctet(p) {
+      var n = p.length, i, c;
+      if (n < 1 || n > 3) return false;
+      for (i = 0; i < n; i += 1) {
+        c = _charCodeAt(p, i);
+        if (!_isDigitCode(c)) return false;
+      }
+      if (n > 1 && _charCodeAt(p, 0) === 48) return false;
+      return _Number(p) <= 255;
+    }
     function isIPv4(s) {
-      return typeof s === "string" && IPV4_RE.test(s);
+      if (typeof s !== "string") return false;
+      var parts = _splitOn(s, ".");
+      if (parts.length !== 4) return false;
+      for (var i = 0; i < 4; i += 1) {
+        if (!_isOctet(parts[i])) return false;
+      }
+      return true;
+    }
+    function _isHexGroup(g) {
+      var n = g.length, i;
+      if (n < 1 || n > 4) return false;
+      for (i = 0; i < n; i += 1) {
+        if (!_isHexCode(_charCodeAt(g, i))) return false;
+      }
+      return true;
+    }
+    function _isDottedQuadShape(t) {
+      var q = _splitOn(t, "."), i, p, j;
+      if (q.length !== 4) return false;
+      for (i = 0; i < 4; i += 1) {
+        p = q[i];
+        if (p.length < 1 || p.length > 3) return false;
+        for (j = 0; j < p.length; j += 1) {
+          if (!_isDigitCode(_charCodeAt(p, j))) return false;
+        }
+      }
+      return true;
     }
     var IPV6_TEXT_MAX_LEN = 45;
     function expandIpv6Hex(ip) {
-      if (typeof ip !== "string" || ip.length > IPV6_TEXT_MAX_LEN || ip.indexOf(":") === -1) return null;
-      var dual = ip.match(/^(.*):(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
-      if (dual) {
-        if (!isIPv4(dual[2])) return null;
-        var v4 = dual[2].split(".").map(Number);
-        ip = dual[1] + ":" + (v4[0] << 8 | v4[1]).toString(16) + ":" + (v4[2] << 8 | v4[3]).toString(16);
-      }
-      var dbl = ip.split("::");
+      if (typeof ip !== "string" || ip.length > IPV6_TEXT_MAX_LEN || _indexOf(ip, ":") === -1) return null;
+      var lastColon = _lastIndexOf(ip, ":");
+      var tail = _slice(ip, lastColon + 1);
+      if (_indexOf(tail, ".") !== -1) {
+        if (!_isDottedQuadShape(tail) || !isIPv4(tail)) return null;
+        var q = _splitOn(tail, "."), o0 = _Number(q[0]), o1 = _Number(q[1]), o2 = _Number(q[2]), o3 = _Number(q[3]);
+        ip = _slice(ip, 0, lastColon) + ":" + _numToString(o0 << 8 | o1, 16) + ":" + _numToString(o2 << 8 | o3, 16);
+      }
+      var dbl = _splitOn(ip, "::");
       if (dbl.length > 2) return null;
-      var left = dbl[0] === "" ? [] : dbl[0].split(":");
-      var right = dbl.length === 2 ? dbl[1] === "" ? [] : dbl[1].split(":") : [];
+      var left = dbl[0] === "" ? [] : _splitOn(dbl[0], ":");
+      var right = dbl.length === 2 ? dbl[1] === "" ? [] : _splitOn(dbl[1], ":") : [];
       if (dbl.length === 1 && left.length !== 8) return null;
       var fill = 8 - left.length - right.length;
       if (dbl.length === 2 ? fill < 1 : fill !== 0) return null;
       var groups = left, i;
-      for (i = 0; i < fill; i += 1) groups = groups.concat(["0"]);
-      groups = groups.concat(right);
+      for (i = 0; i < fill; i += 1) _push(groups, "0");
+      for (i = 0; i < right.length; i += 1) _push(groups, right[i]);
       if (groups.length !== 8) return null;
       var hex = "";
       for (i = 0; i < 8; i += 1) {
         var g = groups[i];
-        if (g.length < 1 || g.length > 4 || !/^[0-9a-f]+$/i.test(g)) return null;
-        hex += g.toLowerCase().padStart(4, "0");
+        if (!_isHexGroup(g)) return null;
+        hex += _padStart(_toLowerCase(g), 4, "0");
       }
       return hex;
     }
@@ -18493,11 +18603,15 @@ var require_ip_utils = __commonJS({
       return isIPv4(s) || expandIpv6Hex(s) !== null;
     }
     function packIpLiteral(s) {
-      if (isIPv4(s)) return Buffer.from(s.split(".").map(Number));
+      if (isIPv4(s)) {
+        var parts = _splitOn(s, "."), buf = _bufferAlloc(4), i;
+        for (i = 0; i < 4; i += 1) buf[i] = _Number(parts[i]);
+        return buf;
+      }
       var hex = expandIpv6Hex(s);
-      return hex === null ? null : Buffer.from(hex, "hex");
+      return hex === null ? null : _bufferFrom(hex, "hex");
     }
-    module2.exports = { isIPv4, expandIpv6Hex, isIpLiteral, packIpLiteral, IPV4_RE };
+    module2.exports = { isIPv4, expandIpv6Hex, isIpLiteral, packIpLiteral };
   }
 });
 
@@ -18515,10 +18629,275 @@ var require_pki_build = __commonJS({
     var _bufferEquals = intrinsic.bufferEquals;
     var oid = require_oid();
     var ipUtils = require_ip_utils();
+    var _packIpLiteral = ipUtils.packIpLiteral;
     var nodeCrypto = require("crypto");
     var _keyEquals = intrinsic.uncurry(nodeCrypto.KeyObject.prototype.equals);
+    var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+    var _stringIndexOf = intrinsic.stringIndexOf;
+    var _stringLastIndexOf = intrinsic.uncurry(String.prototype.lastIndexOf);
+    var _sliceStr = intrinsic.uncurry(String.prototype.slice);
+    var _String = intrinsic.String;
+    var _objectKeys = intrinsic.keys;
+    var _isBufferChk = intrinsic.isBuffer;
+    var _stringify = intrinsic.stringify;
+    function _isAlphaCode(c) {
+      return c >= 65 && c <= 90 || c >= 97 && c <= 122;
+    }
+    function _isDigitCode(c) {
+      return c >= 48 && c <= 57;
+    }
+    function _isHexCode(c) {
+      return c >= 48 && c <= 57 || c >= 97 && c <= 102 || c >= 65 && c <= 70;
+    }
+    function _isUnreserved(c) {
+      return _isAlphaCode(c) || _isDigitCode(c) || c === 45 || c === 46 || c === 95 || c === 126;
+    }
+    function _isSubDelim(c) {
+      switch (c) {
+        case 33:
+        case 36:
+        case 38:
+        case 39:
+        case 40:
+        case 41:
+        case 42:
+        case 43:
+        case 44:
+        case 59:
+        case 61:
+          return true;
+        default:
+          return false;
+      }
+    }
+    function _isUserinfoByte(c) {
+      return _isUnreserved(c) || _isSubDelim(c) || c === 58;
+    }
+    function _isUriByte(c) {
+      return _isUnreserved(c) || _isSubDelim(c) || c === 58 || c === 47 || c === 63 || c === 35 || c === 64;
+    }
+    function _isAtextByte(c) {
+      if (_isAlphaCode(c) || _isDigitCode(c)) return true;
+      switch (c) {
+        case 33:
+        case 35:
+        case 36:
+        case 37:
+        case 38:
+        case 39:
+        // ! # $ % & '
+        case 42:
+        case 43:
+        case 45:
+        case 47:
+        case 61:
+        case 63:
+        // * + - / = ?
+        case 94:
+        case 95:
+        case 96:
+        case 123:
+        case 124:
+        case 125:
+        case 126:
+          return true;
+        default:
+          return false;
+      }
+    }
+    function _looksLikeIPv4Shape(s) {
+      var n = s.length, i, c, sawDot = false, atomEmpty = true;
+      if (n === 0) return false;
+      for (i = 0; i < n; i += 1) {
+        c = _charCodeAt(s, i);
+        if (c === 46) {
+          if (atomEmpty) return false;
+          sawDot = true;
+          atomEmpty = true;
+        } else if (_isDigitCode(c)) {
+          atomEmpty = false;
+        } else return false;
+      }
+      return sawDot && !atomEmpty;
+    }
+    function _componentBytesOk(s, from, to, byteOk) {
+      var i = from, c;
+      while (i < to) {
+        c = _charCodeAt(s, i);
+        if (c === 37) {
+          if (i + 2 >= to || !_isHexCode(_charCodeAt(s, i + 1)) || !_isHexCode(_charCodeAt(s, i + 2))) return false;
+          i += 3;
+        } else if (byteOk(c)) {
+          i += 1;
+        } else return false;
+      }
+      return true;
+    }
+    function _validUriHost(s, from, to) {
+      if (to <= from) return false;
+      var host = _sliceStr(s, from, to), len = host.length;
+      if (_looksLikeIPv4Shape(host)) return _packIpLiteral(host) !== null;
+      var end = _charCodeAt(host, len - 1) === 46 ? len - 1 : len;
+      if (end > 253) return false;
+      var firstDot = _stringIndexOf(host, ".", 0);
+      if (firstDot === -1 || firstDot >= end) return false;
+      return _labelsValid(host, 0, len, _isHostLabelRange, true);
+    }
+    function _validUriAuthority(s, from, to) {
+      var i, c, at = -1;
+      for (i = from; i < to; i += 1) {
+        c = _charCodeAt(s, i);
+        if (c === 64) {
+          if (at !== -1) return false;
+          at = i;
+        }
+      }
+      var hostStart = at === -1 ? from : at + 1;
+      if (at !== -1 && !_componentBytesOk(s, from, at, _isUserinfoByte)) return false;
+      var colon = -1;
+      for (i = hostStart; i < to; i += 1) {
+        if (_charCodeAt(s, i) === 58) {
+          colon = i;
+          break;
+        }
+      }
+      var hostEnd = colon === -1 ? to : colon;
+      if (!_validUriHost(s, hostStart, hostEnd)) return false;
+      if (colon !== -1) {
+        for (i = colon + 1; i < to; i += 1) {
+          if (!_isDigitCode(_charCodeAt(s, i))) return false;
+        }
+      }
+      return true;
+    }
+    function _looksLikeUri(s) {
+      var n = s.length, i, c;
+      if (n === 0 || !_isAlphaCode(_charCodeAt(s, 0))) return false;
+      i = 1;
+      while (i < n) {
+        c = _charCodeAt(s, i);
+        if (_isAlphaCode(c) || _isDigitCode(c) || c === 43 || c === 45 || c === 46) i += 1;
+        else break;
+      }
+      if (i + 3 > n || _charCodeAt(s, i) !== 58 || _charCodeAt(s, i + 1) !== 47 || _charCodeAt(s, i + 2) !== 47) return false;
+      i += 3;
+      var authStart = i, authEnd = n;
+      for (; i < n; i += 1) {
+        c = _charCodeAt(s, i);
+        if (c === 47 || c === 63 || c === 35) {
+          authEnd = i;
+          break;
+        }
+      }
+      if (authEnd === authStart) return false;
+      if (!_validUriAuthority(s, authStart, authEnd)) return false;
+      var sawHash = false;
+      i = authEnd;
+      while (i < n) {
+        c = _charCodeAt(s, i);
+        if (c === 37) {
+          if (i + 2 >= n || !_isHexCode(_charCodeAt(s, i + 1)) || !_isHexCode(_charCodeAt(s, i + 2))) return false;
+          i += 3;
+          continue;
+        }
+        if (c === 35) {
+          if (sawHash) return false;
+          sawHash = true;
+        }
+        if (!_isUriByte(c)) return false;
+        i += 1;
+      }
+      return true;
+    }
+    function _isDnsLabelRange(s, from, to) {
+      var len = to - from, i, c;
+      if (len < 1 || len > 63) return false;
+      for (i = from; i < to; i += 1) {
+        c = _charCodeAt(s, i);
+        if (_isAlphaCode(c) || _isDigitCode(c)) continue;
+        if (i === to - 1) return false;
+        if (c === 95) continue;
+        if (c === 45 && i !== from) continue;
+        return false;
+      }
+      return true;
+    }
+    function _isHostLabelRange(s, from, to) {
+      var len = to - from, i, c, edge;
+      if (len < 1 || len > 63) return false;
+      for (i = from; i < to; i += 1) {
+        c = _charCodeAt(s, i);
+        edge = i === from || i === to - 1;
+        if (_isAlphaCode(c) || _isDigitCode(c)) continue;
+        if (c === 45 && !edge) continue;
+        return false;
+      }
+      return true;
+    }
+    function _labelsValid(s, from, to, labelFn, allowRootDot) {
+      if (allowRootDot && to - from >= 1 && _charCodeAt(s, to - 1) === 46) to -= 1;
+      if (to <= from) return false;
+      var start = from, dot;
+      for (; ; ) {
+        dot = _stringIndexOf(s, ".", start);
+        var end = dot === -1 || dot >= to ? to : dot;
+        if (!labelFn(s, start, end)) return false;
+        if (end === to) return true;
+        start = end + 1;
+      }
+    }
+    function _looksLikeDnsName(s) {
+      var n = s.length, start = 0;
+      if (n < 1) return false;
+      var end = _charCodeAt(s, n - 1) === 46 ? n - 1 : n;
+      if (end < 1 || end > 253) return false;
+      if (end >= 2 && _charCodeAt(s, 0) === 42 && _charCodeAt(s, 1) === 46) start = 2;
+      if (start >= end) return false;
+      return _labelsValid(s, start, n, _isDnsLabelRange, true);
+    }
+    function _looksLikeEmail(s) {
+      if (s.length > 254) return false;
+      var at = _stringIndexOf(s, "@", 0);
+      if (at < 1 || at > 64 || _stringLastIndexOf(s, "@") !== at) return false;
+      var i, c, atomEmpty = true;
+      for (i = 0; i < at; i += 1) {
+        c = _charCodeAt(s, i);
+        if (c === 46) {
+          if (atomEmpty) return false;
+          atomEmpty = true;
+        } else if (_isAtextByte(c)) {
+          atomEmpty = false;
+        } else return false;
+      }
+      if (atomEmpty) return false;
+      var dStart = at + 1, dLen = s.length - dStart;
+      if (dLen < 1 || dLen > 253 || _stringIndexOf(s, ".", dStart) === -1) return false;
+      return _labelsValid(s, dStart, s.length, _isHostLabelRange, false);
+    }
+    function _isDottedOid(s) {
+      var n = s.length, i, c, d0, arcs = 0;
+      if (n < 3) return false;
+      c = _charCodeAt(s, 0);
+      if (c < 48 || c > 50) return false;
+      i = 1;
+      while (i < n) {
+        if (_charCodeAt(s, i) !== 46) return false;
+        i += 1;
+        if (i >= n) return false;
+        d0 = _charCodeAt(s, i);
+        if (d0 === 48) {
+          i += 1;
+        } else if (d0 >= 49 && d0 <= 57) {
+          i += 1;
+          while (i < n && _isDigitCode(_charCodeAt(s, i))) i += 1;
+        } else {
+          return false;
+        }
+        arcs += 1;
+      }
+      return arcs >= 1;
+    }
     var b = asn1.build;
-    var DOTTED_OID_RE = /^[0-2](?:\.(?:0|[1-9]\d*))+$/;
     var KU_BIT = {
       digitalSignature: 0,
       nonRepudiation: 1,
@@ -18604,15 +18983,30 @@ var require_pki_build = __commonJS({
         return asn1.decode(nameDer).children.length === 0;
       }
       function ia5Content(s) {
-        s = String(s);
+        s = _String(s);
         for (var i = 0; i < s.length; i++) {
-          if (s.charCodeAt(i) > 127) throw E("bad-input", "value requires 7-bit ASCII (IA5String): " + JSON.stringify(s));
+          if (_charCodeAt(s, i) > 127) throw E("bad-input", "value requires 7-bit ASCII (IA5String): " + _stringify(s));
         }
-        return Buffer.from(s, "latin1");
+        return _bufferFrom(s, "latin1");
+      }
+      function _classifyBareGeneralName(s) {
+        if (_packIpLiteral(s) !== null) return { iPAddress: s };
+        if (_looksLikeIPv4Shape(s)) {
+          throw E("bad-input", "the bare GeneralName string " + _stringify(s) + " looks like an IPv4 address but is not a valid one; pass { iPAddress: ... } for an address or { dNSName: ... } for a name");
+        }
+        if (_looksLikeUri(s)) return { uniformResourceIdentifier: s };
+        if (_looksLikeEmail(s)) return { rfc822Name: s };
+        if (_looksLikeDnsName(s)) return { dNSName: s };
+        var _qs = _stringify(s);
+        throw E("bad-input", "cannot classify the bare GeneralName string " + _qs + " as a dNSName, rfc822Name, iPAddress, or URI; pass an explicit form object, e.g. { dNSName: " + _qs + " }");
       }
       function encodeGeneralName(entry) {
-        if (!entry || typeof entry !== "object" || Buffer.isBuffer(entry)) throw E("bad-input", "a GeneralName must be an object with exactly one name form");
-        var keys = Object.keys(entry);
+        if (typeof entry === "string") {
+          if (entry === "") throw E("bad-input", "an empty GeneralName value is not permitted (RFC 5280 sec. 4.2.1.6)");
+          entry = _classifyBareGeneralName(entry);
+        }
+        if (!entry || typeof entry !== "object" || _isBufferChk(entry)) throw E("bad-input", "a GeneralName must be an object with exactly one name form");
+        var keys = _objectKeys(entry);
         if (keys.length !== 1) throw E("bad-input", "a GeneralName entry must have exactly one form, got " + keys.length);
         var k = keys[0], v = entry[k];
         if (v == null || v === "") throw E("bad-input", "an empty GeneralName value is not permitted (RFC 5280 sec. 4.2.1.6)");
@@ -18627,10 +19021,10 @@ var require_pki_build = __commonJS({
           case "iPAddress":
             var ipBuf = v;
             if (typeof v === "string") {
-              ipBuf = ipUtils.packIpLiteral(v);
-              if (ipBuf === null) throw E("bad-input", "iPAddress string is not a valid IPv4 or IPv6 literal: " + JSON.stringify(v));
+              ipBuf = _packIpLiteral(v);
+              if (ipBuf === null) throw E("bad-input", "iPAddress string is not a valid IPv4 or IPv6 literal: " + _stringify(v));
             }
-            if (!Buffer.isBuffer(ipBuf) || ipBuf.length !== 4 && ipBuf.length !== 16) throw E("bad-input", "iPAddress must be a 4- or 16-octet Buffer or an IPv4/IPv6 string");
+            if (!_isBufferChk(ipBuf) || ipBuf.length !== 4 && ipBuf.length !== 16) throw E("bad-input", "iPAddress must be a 4- or 16-octet Buffer or an IPv4/IPv6 string");
             return b.contextPrimitive(7, ipBuf);
           case "directoryName":
             return b.explicit(4, encodeName(v));
@@ -18665,7 +19059,7 @@ var require_pki_build = __commonJS({
       function _resolveOid(n, label) {
         var dotted = O(n);
         if (dotted != null) return dotted;
-        if (typeof n === "string" && DOTTED_OID_RE.test(n)) {
+        if (typeof n === "string" && _isDottedOid(n)) {
           try {
             b.oid(n);
           } catch (e) {
@@ -24151,7 +24545,14 @@ var require_cmp_session = __commonJS({
       crlUpdate: { name: "crlUpdate", requestOid: "crlStatusList", responseOid: "crls", value: "crlStatus", read: "readCrls" }
     });
     var KNOWN_REVOKE_KEYS = { certificate: 1, certDetails: 1, reason: 1 };
-    var RSA_ARCS = ["rsaEncryption", "rsaSignatureWithripemd160", "id-TA-RSA-v1-5-SHA-256"].map(function(n) {
+    var RSA_ARCS = [
+      "rsaEncryption",
+      "rsaSignatureWithripemd160",
+      "id-TA-RSA-v1-5-SHA-256",
+      "sigS-ISO9796-1-DFUE",
+      "sigS-ISO9796-2Withrsa",
+      "sigS-ISO9796-2rndWithrsa"
+    ].map(function(n) {
       return oid.toArcs(oid.byName(n)).slice(0, -1);
     });
     var RSA_OFF_ARC = /* @__PURE__ */ Object.create(null);
@@ -24179,8 +24580,13 @@ var require_cmp_session = __commonJS({
       "sqMod-nWithRSA",
       "mdc2WithRSA",
       // the X.500 directory signatureAlgorithm RSA OIDs (2.5.8.3.1, 2.5.8.3.100)
-      "sm3WithRSAEncryption"
+      "sm3WithRSAEncryption",
       // the Chinese GM/T RSA-with-SM3 signature (1.2.156.10197.1.504)
+      // The TeleTrusT signatureScheme (ISO/IEC 9796-2) sub-arcs are prefix-matched in RSA_ARCS, but the strict-
+      // descendant match skips each arc NODE itself, so the three bare nodes are named here (1.3.36.3.4.1/.2/.3).
+      "sigS-ISO9796-1",
+      "sigS-ISO9796-2",
+      "sigS-ISO9796-2rnd"
     ].forEach(function(n) {
       var d = oid.byName(n);
       if (d) RSA_OFF_ARC[d] = 1;
@@ -25298,6 +25704,7 @@ var require_path_validate = __commonJS({
     }
     var NS = pkix.makeNS("path", PathError, oid);
     var EXT_DECODERS = pkix.certExtensionDecoders(NS).byOid;
+    var ANCHOR_SPKI_SCHEMA = pkix.spki(NS);
     var subtle = webcrypto.webcrypto.subtle;
     var OID = {
       basicConstraints: oid.byName("basicConstraints"),
@@ -25781,7 +26188,7 @@ var require_path_validate = __commonJS({
         return { tag: st.tag, base: st.base };
       });
     }
-    function initialize(certs, params, seeds) {
+    function initialize(certs, params, seeds, anchor) {
       var n = certs.length;
       return {
         validPolicyTree: rootNode(),
@@ -25794,10 +26201,10 @@ var require_path_validate = __commonJS({
         explicitPolicy: params.initialExplicitPolicy ? 0 : n + 1,
         inhibitAnyPolicy: params.initialAnyPolicyInhibit ? 0 : n + 1,
         policyMapping: params.initialPolicyMappingInhibit ? 0 : n + 1,
-        workingPublicKeyAlgorithm: params.trustAnchor.algorithm,
-        workingPublicKey: params.trustAnchor.publicKey,
-        workingPublicKeyParameters: params.trustAnchor.parameters || null,
-        workingIssuerName: params.trustAnchor.name,
+        workingPublicKeyAlgorithm: anchor.algorithm,
+        workingPublicKey: anchor.publicKey,
+        workingPublicKeyParameters: anchor.parameters || null,
+        workingIssuerName: anchor.name,
         maxPathLength: n,
         userInitialPolicySet: params.userInitialPolicySet || [OID.anyPolicy],
         results: []
@@ -26110,6 +26517,7 @@ var require_path_validate = __commonJS({
       var n = certs.length;
       if (n < 1) throw E("path/empty-path", "validate: the certification path is empty");
       if (!opts.trustAnchor) throw E("path/bad-input", "validate: a trustAnchor is required");
+      var anchor = toAnchor(opts.trustAnchor, "validate");
       guard.time.assertValid(opts.time, E, "path/bad-input", "validate: opts.time (the always-on validity-window check date)");
       guard.limits.cap(opts.maxPolicyNodes, "validate: opts.maxPolicyNodes", void 0, { E, code: "path/bad-input", min: 1 });
       if (opts.userInitialPolicySet !== void 0) {
@@ -26128,7 +26536,7 @@ var require_path_validate = __commonJS({
       var purposeOpts = resolvePurposeOpts(opts);
       var requiredEku = purposeOpts.requiredEku;
       var checkPurpose = purposeOpts.checkPurpose;
-      var state = initialize(certs, opts, seeds);
+      var state = initialize(certs, opts, seeds, anchor);
       state._n = n;
       state.requiredEku = requiredEku;
       var verifier = opts.verifier || null;
@@ -26138,7 +26546,7 @@ var require_path_validate = __commonJS({
       var failed = false;
       var revocationRan = false, revocationWaived = false, revocationUndetermined = false;
       var anchorDistrustApplied = false, anchorPurposeApplied = false;
-      if (!checkPurpose && opts.trustAnchor && _hasPurposeScopedMetadata(opts.trustAnchor)) {
+      if (!checkPurpose && _hasPurposeScopedMetadata(anchor)) {
         throw E("path/bad-input", "validate: the trust anchor carries purpose-scoped metadata (distrustAfter / purposes), which is keyed by key purpose -- supply opts.checkPurpose to say which purpose this validation is for, or the constraint cannot be applied");
       }
       for (var idx = 0; idx < n; idx++) {
@@ -26295,7 +26703,7 @@ var require_path_validate = __commonJS({
           }
           if (requireCriticalExt(liap, "inhibitAnyPolicy", checks)) failed = true;
           if (requiredEku && ekuPurposeFails(cert, requiredEku, checks)) failed = true;
-          var ta = opts.trustAnchor;
+          var ta = anchor;
           var distrustDate = assertAnchorConstraints(ta, checkPurpose);
           if (distrustDate != null) {
             anchorDistrustApplied = true;
@@ -26936,11 +27344,13 @@ var require_path_validate = __commonJS({
       if (!ta || typeof ta !== "object") return false;
       return guard.list.anyMatches(["distrustAfter", "purposes"], function(k) {
         var m = ta[k];
-        return !!m && typeof m === "object" && Object.keys(m).length > 0;
+        return !!m && typeof m === "object" && intrinsic.getOwnPropertyNames(m).length > 0;
       });
     }
     function assertAnchorConstraints(ta, checkPurpose) {
-      var d = checkPurpose && ta && ta.distrustAfter && intrinsic.hasOwn(ta.distrustAfter, checkPurpose) ? ta.distrustAfter[checkPurpose] : null;
+      if (!checkPurpose || !ta) return null;
+      var da = ta.distrustAfter;
+      var d = da && intrinsic.hasOwn(da, checkPurpose) ? da[checkPurpose] : null;
       if (d == null) return null;
       return guard.time.assertValid(d, E, "path/bad-input", "trustAnchor.distrustAfter." + checkPurpose);
     }
@@ -26973,22 +27383,191 @@ var require_path_validate = __commonJS({
       }
       return { requiredEku, checkPurpose };
     }
-    function toAnchor(entry) {
-      if (entry && typeof entry === "object" && !Buffer.isBuffer(entry) && entry.name && entry.publicKey && entry.algorithm) {
-        if (!intrinsic.isArray(entry.name.rdns) || !Buffer.isBuffer(entry.publicKey) || typeof entry.algorithm !== "string") {
-          throw E("path/bad-input", "build: a trustAnchor tuple must be { name: { rdns: [...] }, publicKey: Buffer, algorithm: OID string }");
+    function _snapshotConstraintMap(m, E2, code, who) {
+      var out = {};
+      var proto = intrinsic.getPrototypeOf(m);
+      if (proto !== null && proto !== intrinsic.ObjectProto) throw E2(code, who + ": a trustAnchor constraint map must be a plain object (its own entries only), not one with a custom or cross-realm prototype");
+      var keys = intrinsic.getOwnPropertyNames(m);
+      if (intrinsic.ownKeys(m).length !== keys.length) throw E2(code, who + ": a trustAnchor constraint map must not have symbol-keyed entries");
+      for (var i = 0; i < keys.length; i++) {
+        if (keys[i] === "__proto__") throw E2(code, who + ": a trustAnchor constraint map must not have an own __proto__ entry");
+        var d = intrinsic.getOwnPropertyDescriptor(m, keys[i]);
+        if (!d || !intrinsic.hasOwn(d, "value")) throw E2(code, who + ": a trustAnchor constraint-map entry must be a data property, not an accessor");
+        var v = d.value;
+        if (intrinsic.types.isDate(v)) v = new intrinsic.Date(guard.time.instantOf(v));
+        intrinsic.defineProperty(out, keys[i], { value: v, enumerable: true, configurable: true, writable: true });
+      }
+      return out;
+    }
+    function _normalizeConstraintField(v, E2, code, who) {
+      if (v === null || v === void 0) return v;
+      if (typeof v !== "object" || intrinsic.isBuffer(v)) throw E2(code, who + ": a trustAnchor constraint map must be a plain object");
+      return _snapshotConstraintMap(v, E2, code, who);
+    }
+    function _captureConstraintMap(entry, key, E2, code, who) {
+      var d = intrinsic.getOwnPropertyDescriptor(entry, key);
+      if (d === void 0) {
+        if (key in entry) throw E2(code, who + ": a trustAnchor " + key + " must be an own data property, not inherited");
+        return void 0;
+      }
+      if (!intrinsic.hasOwn(d, "value")) throw E2(code, who + ": a trustAnchor " + key + " must be a data property, not an accessor");
+      if (intrinsic.types.isProxy(d.value)) throw E2(code, who + ": a trustAnchor " + key + " map must not be a Proxy");
+      return d.value;
+    }
+    function _captureOwnData(entry, key) {
+      var d = intrinsic.getOwnPropertyDescriptor(entry, key);
+      return d && intrinsic.hasOwn(d, "value") ? d.value : void 0;
+    }
+    function _copyAtv(atv) {
+      var out = {};
+      var t = atv.type;
+      if (t !== void 0) intrinsic.defineProperty(out, "type", { value: t, enumerable: true, configurable: true, writable: true });
+      var v = atv.value;
+      if (v !== void 0) intrinsic.defineProperty(out, "value", { value: v, enumerable: true, configurable: true, writable: true });
+      var nm = atv.name;
+      if (nm !== void 0) intrinsic.defineProperty(out, "name", { value: nm, enumerable: true, configurable: true, writable: true });
+      return out;
+    }
+    function _copyRdnsDeep(rdns) {
+      if (!intrinsic.isArray(rdns)) return rdns;
+      var out = [];
+      out.length = rdns.length;
+      for (var i = 0; i < rdns.length; i++) {
+        if (!intrinsic.hasOwn(rdns, i)) continue;
+        var rdn = rdns[i], val;
+        if (intrinsic.isArray(rdn)) {
+          var rdnOut = [];
+          rdnOut.length = rdn.length;
+          for (var j = 0; j < rdn.length; j++) {
+            if (!intrinsic.hasOwn(rdn, j)) continue;
+            var atv = rdn[j] !== null && typeof rdn[j] === "object" ? _copyAtv(rdn[j]) : rdn[j];
+            intrinsic.defineProperty(rdnOut, j, { value: atv, enumerable: true, configurable: true, writable: true });
+          }
+          val = rdnOut;
+        } else {
+          val = rdn;
         }
-        return entry;
+        intrinsic.defineProperty(out, i, { value: val, enumerable: true, configurable: true, writable: true });
+      }
+      return out;
+    }
+    function toAnchor(entry, verb) {
+      var who = verb || "build";
+      var isTuple = false, alg = null, pubRaw = null, nameRaw = null, pk = null, purposesSnap, distrustSnap;
+      var subjectDerRaw, labelRaw, mozRaw;
+      if (intrinsic.types.isProxy(entry)) {
+        throw E("path/bad-input", who + ": a trustAnchor must not be a Proxy");
+      }
+      if (entry !== null && typeof entry === "object") {
+        var proto = intrinsic.getPrototypeOf(entry);
+        while (proto !== null) {
+          if (intrinsic.types.isProxy(proto)) throw E("path/bad-input", who + ": a trustAnchor must not inherit from a Proxy");
+          proto = intrinsic.getPrototypeOf(proto);
+        }
+      }
+      try {
+        if (entry && typeof entry === "object" && !Buffer.isBuffer(entry) && !guard.parsed.isRecorded(entry)) {
+          var pRaw = _captureConstraintMap(entry, "purposes", E, "path/bad-input", who);
+          purposesSnap = _normalizeConstraintField(pRaw, E, "path/bad-input", who);
+          var dRaw = _captureConstraintMap(entry, "distrustAfter", E, "path/bad-input", who);
+          distrustSnap = _normalizeConstraintField(dRaw, E, "path/bad-input", who);
+          subjectDerRaw = _captureOwnData(entry, "subjectDer");
+          labelRaw = _captureOwnData(entry, "label");
+          mozRaw = _captureOwnData(entry, "mozillaCaPolicy");
+          pubRaw = entry.publicKey;
+          if (guard.bytes.isByteSource(pubRaw)) {
+            pk = guard.bytes.snapshot(pubRaw, PathError, "path/bad-input", who + ": trustAnchor publicKey");
+          }
+          nameRaw = entry.name;
+          alg = entry.algorithm;
+          isTuple = !!(nameRaw && pubRaw && alg);
+        }
+      } catch (e) {
+        throw E("path/bad-input", who + ": a trustAnchor accessor threw", e);
+      }
+      if (isTuple) {
+        var algStr;
+        try {
+          if (typeof alg === "string") {
+            algStr = alg;
+          } else if (alg !== null && typeof alg === "object") {
+            if (intrinsic.types.isProxy(alg)) throw E("path/bad-input", who + ": a trustAnchor algorithm must not be a Proxy");
+            var algOidD = intrinsic.getOwnPropertyDescriptor(alg, "oid");
+            if (algOidD && !intrinsic.hasOwn(algOidD, "value")) throw E("path/bad-input", who + ": a trustAnchor algorithm.oid must be a data property, not an accessor");
+            var algOid = algOidD ? algOidD.value : void 0;
+            algStr = typeof algOid === "string" ? algOid : null;
+          } else {
+            algStr = null;
+          }
+        } catch (e) {
+          throw E("path/bad-input", who + ": a trustAnchor algorithm.oid accessor threw", e);
+        }
+        var nameOut = {};
+        try {
+          var nsrc = nameRaw !== null && typeof nameRaw === "object" ? nameRaw : null;
+          if (nsrc !== null && intrinsic.types.isProxy(nsrc)) throw E("path/bad-input", who + ": a trustAnchor name must not be a Proxy");
+          var rdnsD = nsrc ? intrinsic.getOwnPropertyDescriptor(nsrc, "rdns") : void 0;
+          if (rdnsD && !intrinsic.hasOwn(rdnsD, "value")) throw E("path/bad-input", who + ": a trustAnchor name.rdns must be a data property, not an accessor");
+          var rdnsVal = rdnsD ? rdnsD.value : void 0;
+          if (rdnsVal !== void 0) {
+            intrinsic.defineProperty(nameOut, "rdns", { value: _copyRdnsDeep(rdnsVal), enumerable: true, configurable: true, writable: true });
+          }
+          var bytesD = nsrc ? intrinsic.getOwnPropertyDescriptor(nsrc, "bytes") : void 0;
+          if (bytesD && !intrinsic.hasOwn(bytesD, "value")) throw E("path/bad-input", who + ": a trustAnchor name.bytes must be a data property, not an accessor");
+          var nBytes = bytesD ? bytesD.value : void 0;
+          if (nBytes !== void 0) {
+            intrinsic.defineProperty(nameOut, "bytes", { value: nBytes, enumerable: true, configurable: true, writable: true });
+          }
+          var dnD = nsrc ? intrinsic.getOwnPropertyDescriptor(nsrc, "dn") : void 0;
+          if (dnD && !intrinsic.hasOwn(dnD, "value")) throw E("path/bad-input", who + ": a trustAnchor name.dn must be a data property, not an accessor");
+          var nDn = dnD ? dnD.value : void 0;
+          if (typeof nDn === "string") {
+            intrinsic.defineProperty(nameOut, "dn", { value: nDn, enumerable: true, configurable: true, writable: true });
+          }
+        } catch (e) {
+          throw E("path/bad-input", who + ": trustAnchor name could not be materialized", e);
+        }
+        var nameHasRdns = intrinsic.hasOwn(nameOut, "rdns") && intrinsic.isArray(nameOut.rdns);
+        if (!nameHasRdns || !Buffer.isBuffer(pubRaw) || algStr === null) {
+          throw E("path/bad-input", who + ": a trustAnchor tuple must be { name: { rdns: [...] }, publicKey: Buffer, algorithm: an OID string or a SubjectPublicKeyInfo algorithm carrying an oid }");
+        }
+        guard.identifier.assertCanonicalOid(algStr, E, "path/bad-input", who + ": trustAnchor algorithm " + algStr);
+        var spkiAlg;
+        try {
+          spkiAlg = schema.walk(ANCHOR_SPKI_SCHEMA, asn1.decode(pk), NS).result.algorithm;
+        } catch (e) {
+          throw E("path/bad-input", who + ": trustAnchor publicKey is not a valid SubjectPublicKeyInfo", e);
+        }
+        if (spkiAlg.oid !== algStr) {
+          throw E("path/bad-input", who + ": trustAnchor algorithm " + algStr + " does not match its publicKey key algorithm " + spkiAlg.oid);
+        }
+        var flat = {};
+        intrinsic.defineProperty(flat, "name", { value: nameOut, enumerable: true, configurable: true, writable: true });
+        if (purposesSnap !== void 0) intrinsic.defineProperty(flat, "purposes", { value: purposesSnap, enumerable: true, configurable: true, writable: true });
+        if (distrustSnap !== void 0) intrinsic.defineProperty(flat, "distrustAfter", { value: distrustSnap, enumerable: true, configurable: true, writable: true });
+        if (subjectDerRaw !== void 0) intrinsic.defineProperty(flat, "subjectDer", { value: subjectDerRaw, enumerable: true, configurable: true, writable: true });
+        if (labelRaw !== void 0) intrinsic.defineProperty(flat, "label", { value: labelRaw, enumerable: true, configurable: true, writable: true });
+        if (mozRaw !== void 0) intrinsic.defineProperty(flat, "mozillaCaPolicy", { value: mozRaw, enumerable: true, configurable: true, writable: true });
+        intrinsic.defineProperty(flat, "publicKey", { value: pk, enumerable: true, configurable: true, writable: true });
+        intrinsic.defineProperty(flat, "algorithm", { value: spkiAlg.oid, enumerable: true, configurable: true, writable: true });
+        intrinsic.defineProperty(flat, "parameters", { value: spkiAlg.parameters, enumerable: true, configurable: true, writable: true });
+        return flat;
+      }
+      if (entry && typeof entry === "object" && ("purposes" in entry || "distrustAfter" in entry)) {
+        throw E("path/bad-input", who + ": a trustAnchor certificate must not carry purposes / distrustAfter -- put per-purpose constraints on a { name, publicKey, algorithm, purposes, distrustAfter } tuple (or a pki.trust anchor), not on a parsed certificate");
       }
       var cert;
       try {
         cert = coerceCert(entry);
       } catch (e) {
-        throw E("path/bad-input", "build: a trustAnchor entry must be a { name, publicKey, algorithm } tuple or a certificate", e);
+        throw E("path/bad-input", who + ": a trustAnchor entry must be a { name, publicKey, algorithm } tuple or a certificate", e);
       }
       var spki = cert.subjectPublicKeyInfo;
       return { name: cert.subject, publicKey: spki.bytes, algorithm: spki.algorithm.oid, parameters: spki.algorithm.parameters, subjectDer: cert.subject.bytes };
     }
+    function anchorFromCert(cert) {
+      return toAnchor(cert, "anchorFromCert");
+    }
     function identityKey(cert) {
       var san = findExt(cert, OID.subjectAltName);
       return cert.subject.bytes.toString("hex") + "|" + (san ? san.value.toString("hex") : "") + "|" + cert.subjectPublicKeyInfo.bytes.toString("hex");
@@ -27170,7 +27749,9 @@ var require_path_validate = __commonJS({
       var poolDerKeys = /* @__PURE__ */ new Set();
       for (var pdk = 0; pdk < pool.length; pdk++) intrinsic.setAdd(poolDerKeys, certDerKey(pool[pdk]));
       if (!intrinsic.isArray(opts.trustAnchors) || opts.trustAnchors.length === 0) throw E("path/bad-input", "build: opts.trustAnchors must be a non-empty array of anchor tuples or root certificates");
-      var anchors = opts.trustAnchors.map(toAnchor);
+      var anchors = opts.trustAnchors.map(function(a) {
+        return toAnchor(a, "build");
+      });
       guard.time.assertValid(opts.time, E, "path/bad-input", "build: opts.time (the validity-window check date, forwarded to validate)");
       var effectiveMaxCerts = guard.limits.cap(opts.maxPathCerts, "build: opts.maxPathCerts", constants.LIMITS.PATH_MAX_CERTS, { E, code: "path/bad-input", min: 1 });
       var depthCeiling = effectiveMaxCerts - 1;
@@ -27325,6 +27906,7 @@ var require_path_validate = __commonJS({
     module2.exports = {
       validate,
       build,
+      anchorFromCert,
       crlChecker,
       ocspChecker,
       verifyOcspResponse,
@@ -30473,7 +31055,7 @@ var require_x509_sign = __commonJS({
         }
       );
       guard.identifier.assertKnownKeys(opts, KNOWN_SIGN_OPTS, _err, "x509/bad-input", "pki.x509.sign has an unknown option ");
-      if (issuer.key == null) throw _err("x509/bad-input", "a signing key (issuer.key, a PKCS#8 private key) is required");
+      if (issuer.key == null) throw _err("x509/bad-input", "a signing key (issuer.key, a WebCrypto CryptoKey or a PKCS#8 private key DER/PEM) is required");
       var spki = _reqDer(spec.subjectPublicKey, "spec.subjectPublicKey (the SPKI DER of the certified key)");
       _assertValidSpki(spki, "spec.subjectPublicKey");
       var subjectDer = _encodeName(spec.subject == null ? [] : spec.subject);
@@ -31085,7 +31667,7 @@ var require_attrcert_sign = __commonJS({
       if (!spec || typeof spec !== "object" || Buffer.isBuffer(spec)) throw _err("attrcert/bad-input", "the attribute-certificate spec must be an object");
       guard.identifier.assertKnownKeys(spec, KNOWN_SPEC_KEYS, _err, "attrcert/bad-input", "unknown spec field ");
       issuer = issuer || {};
-      if (issuer.key == null) throw _err("attrcert/bad-input", "a signing key (issuer.key, the AA's PKCS#8 private key) is required");
+      if (issuer.key == null) throw _err("attrcert/bad-input", "a signing key (issuer.key, the AA's WebCrypto CryptoKey or PKCS#8 private key DER/PEM) is required");
       var issuerDnSpec, aaSpki;
       if (issuer.cert != null) {
         var aaCert = _parseCert(issuer.cert, "issuer.cert");
@@ -31803,7 +32385,7 @@ var require_crl_sign = __commonJS({
         }
       );
       guard.identifier.assertKnownKeys(opts, KNOWN_SIGN_OPTS, _err, "crl/bad-input", "pki.crl.sign has an unknown option ");
-      if (issuer.key == null) throw _err("crl/bad-input", "a signing key (issuer.key, a PKCS#8 private key) is required");
+      if (issuer.key == null) throw _err("crl/bad-input", "a signing key (issuer.key, a WebCrypto CryptoKey or a PKCS#8 private key DER/PEM) is required");
       var issuerDer, issuerSpki, issuerCert = null;
       if (byCert) {
         issuerCert = _parseIssuerCert(issuer.cert);
@@ -37384,6 +37966,19 @@ var require_acme = __commonJS({
       sleep: 1,
       clock: 1
     };
+    var _METHOD_OPTS = {
+      finalize: { csr: 1, identifiers: 1 },
+      poll: { maxPolls: 1, maxTotalWait: 1, onRetryAfter: 1 },
+      download: { expectedSpki: 1, identifiers: 1, requireBinding: 1, selectChain: 1, maxAlternates: 1 },
+      revoke: { certAlg: 1, certJwk: 1, certKey: 1, certificate: 1, reason: 1 },
+      keyChange: { newAlg: 1, newJwk: 1, newKey: 1 },
+      renewalWindow: { random: 1, clock: 1, replaced: 1, previous: 1 }
+    };
+    function _gateOpts(bag, whitelist, name) {
+      bag = guard.identifier.optionsObject(bag, E, "acme/bad-input", "pki.acme " + name + " options");
+      guard.identifier.assertKnownKeys(bag, whitelist, E, "acme/bad-input", "unknown " + name + " option ");
+      return bag;
+    }
     function client(directoryUrl, opts) {
       opts = guard.identifier.optionsObject(opts, E, "acme/bad-input", "pki.acme.client options");
       guard.identifier.assertKnownKeys(opts, _CLIENT_OPTS, E, "acme/bad-input", "unknown pki.acme.client option ");
@@ -37638,7 +38233,7 @@ var require_acme = __commonJS({
         });
       }
       function _finalizeBody(order, o) {
-        o = o || {};
+        o = _gateOpts(o, _METHOD_OPTS.finalize, "finalize");
         if (!_isObject(order) || !_isString(order.finalize)) throw E("acme/bad-input", "finalize requires the order object with its finalize URL");
         if (!Array.isArray(order.identifiers)) throw E("acme/bad-input", "finalize requires the order's identifiers to enforce the RFC 8555 sec. 7.4 CSR-set match");
         return _post(_clientUrl(order.finalize), finalize, { csr: o.csr, identifiers: order.identifiers, accountJwk }, "kid").then(function(res) {
@@ -37646,9 +38241,9 @@ var require_acme = __commonJS({
         });
       }
       function _poll(kind, url, budget) {
-        budget = budget || {};
         var capPolls, capWait;
         try {
+          budget = _gateOpts(budget, _METHOD_OPTS.poll, "poll");
           capPolls = budget.maxPolls != null ? guard.limits.cap(budget.maxPolls, "maxPolls", maxPolls, { E, code: "acme/bad-input", min: 1, max: 1e3 }) : maxPolls;
           capWait = budget.maxTotalWait != null ? guard.limits.cap(budget.maxTotalWait, "maxTotalWait", maxTotalWait, { E, code: "acme/bad-input", min: 0, max: retryAfter.MAX_RETRY_AFTER_SECONDS }) : maxTotalWait;
           url = _clientUrl(url);
@@ -37747,8 +38342,8 @@ var require_acme = __commonJS({
         }
       }
       function _downloadCertificate(url, opts2) {
-        opts2 = opts2 || {};
         return Promise.resolve().then(function() {
+          opts2 = _gateOpts(opts2, _METHOD_OPTS.download, "downloadCertificate");
           var select = opts2.selectChain;
           if (select !== void 0 && typeof select !== "function") throw E("acme/bad-input", "downloadCertificate opts.selectChain must be a function");
           var maxAlt = guard.limits.cap(opts2.maxAlternates, "maxAlternates", DEFAULT_MAX_ALTERNATES, { E, code: "acme/bad-input", min: 0, max: 64 });
@@ -37797,22 +38392,24 @@ var require_acme = __commonJS({
         });
       }
       function _revokeCert(o) {
-        o = o || {};
-        if (!Buffer.isBuffer(o.certificate)) return Promise.reject(E("acme/bad-input", "revokeCert requires a DER certificate Buffer (opts.certificate)"));
-        var certKeyMode = o.certKey != null || _isObject(o.certJwk) || o.certAlg != null;
-        if (certKeyMode && !(o.certKey != null && _isObject(o.certJwk) && _isString(o.certAlg))) return Promise.reject(E("acme/bad-input", "revokeCert certificate-key mode requires certKey, certJwk, AND certAlg together, or none (RFC 8555 sec. 7.6)"));
-        var extra = { certificate: o.certificate };
-        if (o.reason !== void 0) extra.reason = o.reason;
-        return _resource("revokeCert").then(function(url) {
-          if (certKeyMode) {
-            return _postJws(url, function(nonce) {
-              return revokeCert(Object.assign({}, extra, { key: o.certKey, alg: o.certAlg, nonce, url, jwk: o.certJwk }));
-            }).then(function() {
+        return _promised(function() {
+          o = _gateOpts(o, _METHOD_OPTS.revoke, "revokeCert");
+          if (!Buffer.isBuffer(o.certificate)) throw E("acme/bad-input", "revokeCert requires a DER certificate Buffer (opts.certificate)");
+          var certKeyMode = o.certKey != null || _isObject(o.certJwk) || o.certAlg != null;
+          if (certKeyMode && !(o.certKey != null && _isObject(o.certJwk) && _isString(o.certAlg))) throw E("acme/bad-input", "revokeCert certificate-key mode requires certKey, certJwk, AND certAlg together, or none (RFC 8555 sec. 7.6)");
+          var extra = { certificate: o.certificate };
+          if (o.reason !== void 0) extra.reason = o.reason;
+          return _resource("revokeCert").then(function(url) {
+            if (certKeyMode) {
+              return _postJws(url, function(nonce) {
+                return revokeCert(Object.assign({}, extra, { key: o.certKey, alg: o.certAlg, nonce, url, jwk: o.certJwk }));
+              }).then(function() {
+                return true;
+              });
+            }
+            return _post(url, revokeCert, extra, "kid").then(function() {
               return true;
             });
-          }
-          return _post(url, revokeCert, extra, "kid").then(function() {
-            return true;
           });
         });
       }
@@ -37836,7 +38433,7 @@ var require_acme = __commonJS({
         });
       }
       function _keyChangeBody(o) {
-        o = o || {};
+        o = _gateOpts(o, _METHOD_OPTS.keyChange, "keyChange");
         if (!o.newKey || !_isObject(o.newJwk) || !_isString(o.newAlg)) throw E("acme/bad-input", "keyChange requires newKey, newJwk, and newAlg");
         var account = _requireKid();
         return _resource("keyChange").then(function(url) {
@@ -37895,8 +38492,8 @@ var require_acme = __commonJS({
         });
       }
       function _renewalWindow(certDer, o) {
-        o = o || {};
         return Promise.resolve().then(function() {
+          o = _gateOpts(o, _METHOD_OPTS.renewalWindow, "renewalWindow");
           if (!Buffer.isBuffer(certDer)) throw E("acme/bad-input", "renewalWindow requires a DER certificate Buffer");
           if (o.random !== void 0 && typeof o.random !== "function") throw E("acme/bad-input", "renewalWindow opts.random must be a function returning a number in [0, 1]");
           if (o.clock !== void 0 && typeof o.clock !== "function") throw E("acme/bad-input", "renewalWindow opts.clock must be a function returning epoch milliseconds");