@blamejs/core 0.18.43 → 0.18.44

package/lib/vendor/blamejs-pki.cjs

@@ -1,4 +1,4 @@
-// @blamejs/pki v0.5.17 — vendored (Apache-2.0). Zero-dep pure CJS.
+// @blamejs/pki v0.5.23 — 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.17",
+      version: "0.5.23",
       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",
@@ -713,6 +713,7 @@ var require_guard_intrinsic = __commonJS({
     var _bufferIsBuffer = Buffer.isBuffer;
     var _bufferByteLength = Buffer.byteLength;
     var _bufferCompare = Buffer.compare;
+    var _bufferEquals = uncurry(Buffer.prototype.equals);
     var _isView = ArrayBuffer.isView;
     var _isInteger = Number.isInteger;
     var _isSafeInteger = Number.isSafeInteger;
@@ -732,6 +733,8 @@ var require_guard_intrinsic = __commonJS({
     var _mathFloor = Math.floor;
     var _mathCeil = Math.ceil;
     var _mathMin = Math.min;
+    var _mathMax = Math.max;
+    var _parseInt = parseInt;
     var _promiseResolve = Promise.resolve;
     var _promiseReject = Promise.reject;
     var _arrForEach = uncurry(Array.prototype.forEach);
@@ -744,6 +747,14 @@ var require_guard_intrinsic = __commonJS({
     var _arrConcat = uncurry(Array.prototype.concat);
     var _arrSlice = uncurry(Array.prototype.slice);
     var _arrJoin = uncurry(Array.prototype.join);
+    var _arrPush = uncurry(Array.prototype.push);
+    var _strToUpperCase = uncurry(String.prototype.toUpperCase);
+    var _strToLowerCase = uncurry(String.prototype.toLowerCase);
+    var _strIndexOf = uncurry(String.prototype.indexOf);
+    var _taSubarray = uncurry(Uint8Array.prototype.subarray);
+    var _abSlice = uncurry(ArrayBuffer.prototype.slice);
+    var _numToString = uncurry(Number.prototype.toString);
+    var _bigIntToString = uncurry(BigInt.prototype.toString);
     var _setAdd = uncurry(Set.prototype.add);
     var _setHas = uncurry(Set.prototype.has);
     var _mapGet = uncurry(Map.prototype.get);
@@ -812,6 +823,7 @@ var require_guard_intrinsic = __commonJS({
       isBuffer: _bufferIsBuffer,
       byteLength: _bufferByteLength,
       compare: _bufferCompare,
+      bufferEquals: _bufferEquals,
       isView: _isView,
       isInteger: _isInteger,
       isSafeInteger: _isSafeInteger,
@@ -831,6 +843,16 @@ var require_guard_intrinsic = __commonJS({
       floor: _mathFloor,
       ceil: _mathCeil,
       min: _mathMin,
+      max: _mathMax,
+      parseInt: _parseInt,
+      push: _arrPush,
+      toUpperCase: _strToUpperCase,
+      toLowerCase: _strToLowerCase,
+      stringIndexOf: _strIndexOf,
+      subarray: _taSubarray,
+      arrayBufferSlice: _abSlice,
+      numberToString: _numToString,
+      bigIntToString: _bigIntToString,
       promiseResolve: _promiseResolve,
       promiseReject: _promiseReject,
       forEach: _arrForEach,
@@ -2198,13 +2220,52 @@ var require_webcrypto = __commonJS({
     var constants = require_constants();
     var asn1 = require_asn1_der();
     var oid = require_oid();
+    var intrinsic = require_guard_intrinsic();
+    var _isArray = intrinsic.isArray;
+    var _hasOwn = intrinsic.hasOwn;
+    var _stringify = intrinsic.stringify;
+    var _bufferFrom = intrinsic.bufferFrom;
+    var _bufToString = intrinsic.uncurry(Buffer.prototype.toString);
+    var _bufferConcat = intrinsic.bufferConcat;
+    var _bufferAlloc = intrinsic.bufferAlloc;
+    var _isBuffer = intrinsic.isBuffer;
+    var _keys = intrinsic.keys;
+    var _map = intrinsic.map;
+    var _forEach = intrinsic.forEach;
+    var _indexOf = intrinsic.indexOf;
+    var _isInteger = intrinsic.isInteger;
+    var _join = intrinsic.join;
+    var _filter = intrinsic.filter;
+    var _arraySlice = intrinsic.arraySlice;
+    var _defineProperty = intrinsic.defineProperty;
+    var _max = intrinsic.max;
+    var _parseInt = intrinsic.parseInt;
+    var _isFinite = intrinsic.isFinite;
+    var _String = intrinsic.String;
+    var _Number = intrinsic.Number;
+    var _BigInt = intrinsic.BigInt;
+    var _Uint8Array = intrinsic.Uint8Array;
+    var _assign = intrinsic.assign;
+    var _create = intrinsic.create;
+    var _isView = intrinsic.isView;
+    var _toUpperCase = intrinsic.toUpperCase;
+    var _toLowerCase = intrinsic.toLowerCase;
+    var _stringIndexOf = intrinsic.stringIndexOf;
+    var _subarray = intrinsic.subarray;
+    var _arrayBufferSlice = intrinsic.arrayBufferSlice;
+    var _numberToString = intrinsic.numberToString;
+    var _bigIntToString = intrinsic.bigIntToString;
+    var _push = intrinsic.push;
+    var _concat = intrinsic.concat;
+    var _resolve = intrinsic.uncurry(intrinsic.promiseResolve);
+    var _types = intrinsic.types;
     var WebCryptoError = frameworkError.defineClass("WebCryptoError", { withCause: true });
     var MAX_RANDOM_BYTES = 65536;
     function _toBuf(data, who) {
       return guard.bytes.source(data, WebCryptoError, "webcrypto/data", who || "input");
     }
     function _toArrayBuffer(buf) {
-      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+      return _arrayBufferSlice(buf.buffer, buf.byteOffset, buf.byteOffset + buf.byteLength);
     }
     function _wcErr(code, msg) {
       return new WebCryptoError(code, msg);
@@ -2213,7 +2274,7 @@ var require_webcrypto = __commonJS({
       return guard.encoding.base64url(s, null, _wcErr, "webcrypto/data", who || "base64url value");
     }
     function _bufToB64url(buf) {
-      return Buffer.from(buf).toString("base64url");
+      return _bufToString(_bufferFrom(buf), "base64url");
     }
     function _normalizeAlg(algorithm, who) {
       var alg = typeof algorithm === "string" ? { name: algorithm } : algorithm;
@@ -2222,9 +2283,9 @@ var require_webcrypto = __commonJS({
       }
       var out = {};
       for (var k in alg) {
-        if (Object.prototype.hasOwnProperty.call(alg, k)) out[k] = alg[k];
+        if (_hasOwn(alg, k)) out[k] = alg[k];
       }
-      out.name = alg.name.toUpperCase();
+      out.name = _toUpperCase(alg.name);
       return out;
     }
     var _STD_ALG_NAME = { "RSASSA-PKCS1-V1_5": "RSASSA-PKCS1-v1_5", "ED25519": "Ed25519", "ED448": "Ed448" };
@@ -2247,8 +2308,8 @@ var require_webcrypto = __commonJS({
     };
     function _hashNode(h, who) {
       var name = typeof h === "string" ? h : h && h.name;
-      var node = HASH_NODE[String(name).toUpperCase()];
-      if (!node) throw new WebCryptoError("webcrypto/not-supported", (who || "operation") + ": unsupported hash " + JSON.stringify(name));
+      var node = HASH_NODE[_toUpperCase(_String(name))];
+      if (!node) throw new WebCryptoError("webcrypto/not-supported", (who || "operation") + ": unsupported hash " + _stringify(name));
       return node;
     }
     var HMAC_BLOCK_BITS = {
@@ -2262,10 +2323,10 @@ var require_webcrypto = __commonJS({
     };
     function _hmacLengthBits(alg, who) {
       var name = typeof alg.hash === "string" ? alg.hash : alg.hash && alg.hash.name;
-      var blockBits = HMAC_BLOCK_BITS[String(name).toUpperCase()];
-      if (!blockBits) throw new WebCryptoError("webcrypto/not-supported", who + ": unsupported hash " + JSON.stringify(name));
+      var blockBits = HMAC_BLOCK_BITS[_toUpperCase(_String(name))];
+      if (!blockBits) throw new WebCryptoError("webcrypto/not-supported", who + ": unsupported hash " + _stringify(name));
       if (alg.length == null) return blockBits;
-      if (typeof alg.length !== "number" || !isFinite(alg.length) || alg.length <= 0 || alg.length % 8 !== 0) {
+      if (typeof alg.length !== "number" || !_isFinite(alg.length) || alg.length <= 0 || alg.length % 8 !== 0) {
         throw new WebCryptoError("webcrypto/syntax", who + ": HMAC length must be a positive multiple of 8 bits");
       }
       return alg.length;
@@ -2289,10 +2350,10 @@ var require_webcrypto = __commonJS({
       "shake-256s",
       "shake-256f"
     ].forEach(function(s) {
-      SLH_DSA_NODE["SLH-DSA-" + s.toUpperCase()] = "slh-dsa-" + s;
+      SLH_DSA_NODE["SLH-DSA-" + _toUpperCase(s)] = "slh-dsa-" + s;
     });
     var SIGN_VERIFY_NAMES = {};
-    ["RSASSA-PKCS1-V1_5", "RSA-PSS", "ECDSA", "ED25519", "ED448", "HMAC"].concat(Object.keys(ML_DSA_NODE), Object.keys(SLH_DSA_NODE)).forEach(function(n) {
+    ["RSASSA-PKCS1-V1_5", "RSA-PSS", "ECDSA", "ED25519", "ED448", "HMAC"].concat(_keys(ML_DSA_NODE), _keys(SLH_DSA_NODE)).forEach(function(n) {
       SIGN_VERIFY_NAMES[n] = true;
     });
     var ENCRYPT_DECRYPT_NAMES = { "RSA-OAEP": true, "AES-GCM": true, "AES-CBC": true, "AES-CTR": true };
@@ -2302,8 +2363,11 @@ var require_webcrypto = __commonJS({
       this.type = type;
       this.extractable = !!extractable;
       this.algorithm = algorithm;
-      this.usages = usages ? usages.slice() : [];
-      Object.defineProperty(this, "_handle", { value: handle, enumerable: false });
+      if (usages != null && !_isArray(usages)) {
+        throw new WebCryptoError("webcrypto/syntax", "usages must be an array of key-usage strings");
+      }
+      this.usages = usages ? _arraySlice(usages) : [];
+      _defineProperty(this, "_handle", { value: handle, enumerable: false });
     }
     function _requireOwnKey(key, who) {
       if (key instanceof CryptoKey) return;
@@ -2314,27 +2378,30 @@ var require_webcrypto = __commonJS({
     }
     function _requireUsage(key, usage) {
       _requireOwnKey(key, usage);
-      if (key.usages.indexOf(usage) === -1) {
-        throw new WebCryptoError("webcrypto/invalid-access", "key is not permitted for '" + usage + "' (usages: " + key.usages.join(",") + ")");
+      if (_indexOf(key.usages, usage) === -1) {
+        throw new WebCryptoError("webcrypto/invalid-access", "key is not permitted for '" + usage + "' (usages: " + _join(key.usages, ",") + ")");
       }
     }
     function _requireAlgMatch(alg, key, who) {
       var keyName = key && key.algorithm && key.algorithm.name;
-      if (String(keyName).toUpperCase() !== alg.name) {
-        throw new WebCryptoError("webcrypto/invalid-access", who + ": algorithm " + JSON.stringify(alg.name) + " does not match the key's algorithm " + JSON.stringify(keyName));
+      if (_toUpperCase(_String(keyName)) !== alg.name) {
+        throw new WebCryptoError("webcrypto/invalid-access", who + ": algorithm " + _stringify(alg.name) + " does not match the key's algorithm " + _stringify(keyName));
       }
     }
     function SubtleCrypto() {
     }
     SubtleCrypto.prototype.digest = async function digest(algorithm, data) {
       var name = _normalizeAlg(algorithm, "digest").name;
-      var xof = XOF_NODE[String(name).toUpperCase()];
+      var xof = XOF_NODE[_toUpperCase(_String(name))];
       var h = xof ? nodeCrypto.createHash(xof.node, { outputLength: xof.length }) : nodeCrypto.createHash(_hashNode(name, "digest"));
       h.update(_toBuf(data, "digest"));
       return _toArrayBuffer(h.digest());
     };
     SubtleCrypto.prototype.generateKey = async function generateKey(algorithm, extractable, keyUsages) {
       var alg = _normalizeAlg(algorithm, "generateKey");
+      if (keyUsages != null && !_isArray(keyUsages)) {
+        throw new WebCryptoError("webcrypto/syntax", "generateKey: keyUsages must be an array of key-usage strings");
+      }
       var usages = keyUsages || [];
       var name = alg.name;
       if (name === "AES-GCM" || name === "AES-CBC" || name === "AES-CTR" || name === "AES-KW") {
@@ -2350,10 +2417,10 @@ var require_webcrypto = __commonJS({
       }
       var pair = _generateKeyPair(alg);
       var pubAlg = pair.algorithm;
-      var privUsages = usages.filter(function(u) {
+      var privUsages = _filter(usages, function(u) {
         return u === "sign" || u === "deriveKey" || u === "deriveBits" || u === "decrypt" || u === "unwrapKey" || u === "decapsulateKey" || u === "decapsulateBits";
       });
-      var pubUsages = usages.filter(function(u) {
+      var pubUsages = _filter(usages, function(u) {
         return u === "verify" || u === "encrypt" || u === "wrapKey" || u === "encapsulateKey" || u === "encapsulateBits";
       });
       return {
@@ -2372,11 +2439,11 @@ var require_webcrypto = __commonJS({
         algorithm = { name: _stdName(name), modulusLength: alg.modulusLength || 2048, publicExponent: alg.publicExponent, hash: rsaHash };
       } else if (name === "ECDSA" || name === "ECDH") {
         var curve = alg.namedCurve;
-        if (!CURVE_NODE[curve]) throw new WebCryptoError("webcrypto/not-supported", name + ": unsupported curve " + JSON.stringify(curve));
+        if (!CURVE_NODE[curve]) throw new WebCryptoError("webcrypto/not-supported", name + ": unsupported curve " + _stringify(curve));
         kp = nodeCrypto.generateKeyPairSync("ec", { namedCurve: CURVE_NODE[curve] });
         algorithm = { name, namedCurve: curve };
       } else if (name === "ED25519" || name === "ED448" || name === "X25519" || name === "X448") {
-        kp = nodeCrypto.generateKeyPairSync(name.toLowerCase());
+        kp = nodeCrypto.generateKeyPairSync(_toLowerCase(name));
         algorithm = { name: _stdName(name) };
       } else if (ML_DSA_NODE[name]) {
         kp = nodeCrypto.generateKeyPairSync(ML_DSA_NODE[name]);
@@ -2388,7 +2455,7 @@ var require_webcrypto = __commonJS({
         kp = nodeCrypto.generateKeyPairSync(SLH_DSA_NODE[name]);
         algorithm = { name };
       } else {
-        throw new WebCryptoError("webcrypto/not-supported", "generateKey: unsupported algorithm " + JSON.stringify(name));
+        throw new WebCryptoError("webcrypto/not-supported", "generateKey: unsupported algorithm " + _stringify(name));
       }
       return { publicKey: kp.publicKey, privateKey: kp.privateKey, algorithm };
     }
@@ -2409,18 +2476,18 @@ var require_webcrypto = __commonJS({
       if (b.length === 0) {
         throw new WebCryptoError("webcrypto/syntax", "publicExponent must be a non-empty BigInteger octet string");
       }
-      var v = BigInt("0x" + b.toString("hex"));
+      var v = _BigInt("0x" + _bufToString(b, "hex"));
       if (v > 0xffffffffn) {
-        throw new WebCryptoError("webcrypto/syntax", "publicExponent " + v.toString() + " exceeds the 2^32-1 bound");
+        throw new WebCryptoError("webcrypto/syntax", "publicExponent " + _bigIntToString(v) + " exceeds the 2^32-1 bound");
       }
-      return Number(v);
+      return _Number(v);
     }
     SubtleCrypto.prototype.sign = async function sign(algorithm, key, data) {
       var alg = _normalizeAlg(algorithm, "sign");
       _requireUsage(key, "sign");
       var buf = _toBuf(data, "sign");
       var name = alg.name;
-      if (!SIGN_VERIFY_NAMES[name]) throw new WebCryptoError("webcrypto/not-supported", "sign: unsupported algorithm " + JSON.stringify(name));
+      if (!SIGN_VERIFY_NAMES[name]) throw new WebCryptoError("webcrypto/not-supported", "sign: unsupported algorithm " + _stringify(name));
       _requireAlgMatch(alg, key, "sign");
       if (name === "RSASSA-PKCS1-V1_5") {
         return _toArrayBuffer(nodeCrypto.sign(_hashNode(key.algorithm.hash, "sign"), buf, key._handle));
@@ -2446,7 +2513,7 @@ var require_webcrypto = __commonJS({
         hm.update(buf);
         return _toArrayBuffer(hm.digest());
       }
-      throw new WebCryptoError("webcrypto/not-supported", "sign: unsupported algorithm " + JSON.stringify(name));
+      throw new WebCryptoError("webcrypto/not-supported", "sign: unsupported algorithm " + _stringify(name));
     };
     SubtleCrypto.prototype.verify = async function verify(algorithm, key, signature, data) {
       var alg = _normalizeAlg(algorithm, "verify");
@@ -2454,7 +2521,7 @@ var require_webcrypto = __commonJS({
       var sig = _toBuf(signature, "verify");
       var buf = _toBuf(data, "verify");
       var name = alg.name;
-      if (!SIGN_VERIFY_NAMES[name]) throw new WebCryptoError("webcrypto/not-supported", "verify: unsupported algorithm " + JSON.stringify(name));
+      if (!SIGN_VERIFY_NAMES[name]) throw new WebCryptoError("webcrypto/not-supported", "verify: unsupported algorithm " + _stringify(name));
       _requireAlgMatch(alg, key, "verify");
       if (name === "RSASSA-PKCS1-V1_5") {
         return nodeCrypto.verify(_hashNode(key.algorithm.hash, "verify"), buf, key._handle, sig);
@@ -2481,7 +2548,7 @@ var require_webcrypto = __commonJS({
         var digest = hm.digest();
         return guard.crypto.constantTimeEqual(digest, sig);
       }
-      throw new WebCryptoError("webcrypto/not-supported", "verify: unsupported algorithm " + JSON.stringify(name));
+      throw new WebCryptoError("webcrypto/not-supported", "verify: unsupported algorithm " + _stringify(name));
     };
     function _runCipher(fn, who) {
       try {
@@ -2495,7 +2562,7 @@ var require_webcrypto = __commonJS({
       _requireUsage(key, "encrypt");
       var buf = _toBuf(data, "encrypt");
       var name = alg.name;
-      if (!ENCRYPT_DECRYPT_NAMES[name]) throw new WebCryptoError("webcrypto/not-supported", "encrypt: unsupported algorithm " + JSON.stringify(name));
+      if (!ENCRYPT_DECRYPT_NAMES[name]) throw new WebCryptoError("webcrypto/not-supported", "encrypt: unsupported algorithm " + _stringify(name));
       _requireAlgMatch(alg, key, "encrypt");
       if (name === "RSA-OAEP") {
         return _toArrayBuffer(nodeCrypto.publicEncrypt({
@@ -2513,7 +2580,7 @@ var require_webcrypto = __commonJS({
             var cipher = nodeCrypto.createCipheriv("aes-" + key.algorithm.length + "-gcm", kb, iv, { authTagLength: (alg.tagLength || 128) / 8 });
             if (aad) cipher.setAAD(aad);
             var ct = guard.secret.cipherFinish(cipher, buf, WebCryptoError, "webcrypto/operation", "an AES-GCM encrypt intermediate");
-            return Buffer.concat([ct, cipher.getAuthTag()]);
+            return _bufferConcat([ct, cipher.getAuthTag()]);
           });
         }, "encrypt"));
       }
@@ -2536,14 +2603,14 @@ var require_webcrypto = __commonJS({
           });
         }, "encrypt"));
       }
-      throw new WebCryptoError("webcrypto/not-supported", "encrypt: unsupported algorithm " + JSON.stringify(name));
+      throw new WebCryptoError("webcrypto/not-supported", "encrypt: unsupported algorithm " + _stringify(name));
     };
     SubtleCrypto.prototype.decrypt = async function decrypt(algorithm, key, data) {
       var alg = _normalizeAlg(algorithm, "decrypt");
       _requireUsage(key, "decrypt");
       var buf = _toBuf(data, "decrypt");
       var name = alg.name;
-      if (!ENCRYPT_DECRYPT_NAMES[name]) throw new WebCryptoError("webcrypto/not-supported", "decrypt: unsupported algorithm " + JSON.stringify(name));
+      if (!ENCRYPT_DECRYPT_NAMES[name]) throw new WebCryptoError("webcrypto/not-supported", "decrypt: unsupported algorithm " + _stringify(name));
       _requireAlgMatch(alg, key, "decrypt");
       if (name === "RSA-OAEP") {
         var oaepOut = nodeCrypto.privateDecrypt({
@@ -2562,8 +2629,8 @@ var require_webcrypto = __commonJS({
         var tagLen = (alg.tagLength || 128) / 8;
         var iv = _toBuf(alg.iv, "AES-GCM iv");
         if (buf.length < tagLen) throw new WebCryptoError("webcrypto/operation", "decrypt: AES-GCM ciphertext is shorter than its authentication tag");
-        var ct = buf.subarray(0, buf.length - tagLen);
-        var tag = buf.subarray(buf.length - tagLen);
+        var ct = _subarray(buf, 0, buf.length - tagLen);
+        var tag = _subarray(buf, buf.length - tagLen);
         var gcmAad = alg.additionalData ? _toBuf(alg.additionalData, "AES-GCM aad") : null;
         return _toArrayBuffer(_runCipher(function() {
           return _withSecretBytes(key, function(kb) {
@@ -2593,7 +2660,7 @@ var require_webcrypto = __commonJS({
           });
         }, "decrypt"));
       }
-      throw new WebCryptoError("webcrypto/not-supported", "decrypt: unsupported algorithm " + JSON.stringify(name));
+      throw new WebCryptoError("webcrypto/not-supported", "decrypt: unsupported algorithm " + _stringify(name));
     };
     function _withSecretBytes(key, fn) {
       var kb = key._handle.export();
@@ -2624,11 +2691,11 @@ var require_webcrypto = __commonJS({
       }
     }
     function _requireDeriveLength(length, who) {
-      if (typeof length !== "number" || !isFinite(length) || length <= 0 || length % 8 !== 0) {
+      if (typeof length !== "number" || !_isFinite(length) || length <= 0 || length % 8 !== 0) {
         throw new WebCryptoError("webcrypto/operation", who + ": length must be a positive multiple of 8 bits");
       }
     }
-    var _PBKDF2_MAX_CONCURRENT = Math.max(1, (parseInt(process.env.UV_THREADPOOL_SIZE, 10) || 4) - 2);
+    var _PBKDF2_MAX_CONCURRENT = _max(1, (_parseInt(process.env.UV_THREADPOOL_SIZE, 10) || 4) - 2);
     var _pbkdf2InFlight = 0;
     var _pbkdf2Waiters = [];
     function _pbkdf2Async(pw, salt, iterations, keylen, digest) {
@@ -2664,7 +2731,7 @@ var require_webcrypto = __commonJS({
           if (length / 8 > secret.length) {
             throw new WebCryptoError("webcrypto/operation", name + ": requested " + length + " bits but the shared secret has " + secret.length * 8);
           }
-          return _toArrayBuffer(secret.subarray(0, length / 8));
+          return _toArrayBuffer(_subarray(secret, 0, length / 8));
         } finally {
           guard.secret.zeroize(secret, WebCryptoError, "webcrypto/operation", "the raw key-agreement shared secret");
         }
@@ -2672,8 +2739,8 @@ var require_webcrypto = __commonJS({
       if (name === "HKDF") {
         _requireDeriveLength(length, "HKDF");
         return _withSecretBytes(key, function(ikm) {
-          var derived = nodeCrypto.hkdfSync(_hashNode(alg.hash, "HKDF"), ikm, _toBuf(alg.salt, "HKDF salt"), _toBuf(alg.info || Buffer.alloc(0), "HKDF info"), length / 8);
-          return derived instanceof ArrayBuffer ? derived : _toArrayBuffer(Buffer.from(derived));
+          var derived = nodeCrypto.hkdfSync(_hashNode(alg.hash, "HKDF"), ikm, _toBuf(alg.salt, "HKDF salt"), _toBuf(alg.info || _bufferAlloc(0), "HKDF info"), length / 8);
+          return derived instanceof ArrayBuffer ? derived : _toArrayBuffer(_bufferFrom(derived));
         });
       }
       if (name === "PBKDF2") {
@@ -2691,7 +2758,7 @@ var require_webcrypto = __commonJS({
       if (name === "X963KDF") {
         _requireDeriveLength(length, "X963KDF");
         return _withSecretBytes(key, function(z) {
-          var derived = _x963Kdf(_hashNode(alg.hash, "X963KDF"), z, _toBuf(alg.info || Buffer.alloc(0), "X963KDF SharedInfo"), length / 8);
+          var derived = _x963Kdf(_hashNode(alg.hash, "X963KDF"), z, _toBuf(alg.info || _bufferAlloc(0), "X963KDF SharedInfo"), length / 8);
           try {
             return _toArrayBuffer(derived);
           } finally {
@@ -2699,21 +2766,21 @@ var require_webcrypto = __commonJS({
           }
         });
       }
-      throw new WebCryptoError("webcrypto/not-supported", "deriveBits: unsupported algorithm " + JSON.stringify(name));
+      throw new WebCryptoError("webcrypto/not-supported", "deriveBits: unsupported algorithm " + _stringify(name));
     }
     function _x963Kdf(hashNode, z, sharedInfo, lenBytes) {
       var blocks = [], counter = 1, got = 0;
       while (got < lenBytes) {
         if (counter > 4294967295) throw new WebCryptoError("webcrypto/operation", "X963KDF: requested output exceeds the counter range");
-        var ctr = Buffer.alloc(4);
+        var ctr = _bufferAlloc(4);
         ctr.writeUInt32BE(counter, 0);
         var h = nodeCrypto.createHash(hashNode).update(z).update(ctr).update(sharedInfo).digest();
-        blocks.push(h);
+        _push(blocks, h);
         got += h.length;
         counter += 1;
       }
-      var joined = Buffer.concat(blocks);
-      var exact = Buffer.alloc(lenBytes);
+      var joined = _bufferConcat(blocks);
+      var exact = _bufferAlloc(lenBytes);
       joined.copy(exact, 0, 0, lenBytes);
       guard.secret.zeroize(joined, WebCryptoError, "webcrypto/operation", "the KDF accumulator");
       for (var bi = 0; bi < blocks.length; bi++) guard.secret.zeroize(blocks[bi], WebCryptoError, "webcrypto/operation", "a KDF block");
@@ -2722,18 +2789,18 @@ var require_webcrypto = __commonJS({
     SubtleCrypto.prototype.deriveBits = async function deriveBits(algorithm, key, length) {
       var alg = _normalizeAlg(algorithm, "deriveBits");
       _requireUsage(key, "deriveBits");
-      if (!DERIVE_NAMES[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "deriveBits: unsupported algorithm " + JSON.stringify(alg.name));
+      if (!DERIVE_NAMES[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "deriveBits: unsupported algorithm " + _stringify(alg.name));
       _requireAlgMatch(alg, key, "deriveBits");
       return _deriveBitsRaw(alg, key, length);
     };
     SubtleCrypto.prototype.deriveKey = async function deriveKey(algorithm, baseKey, derivedKeyType, extractable, keyUsages) {
       _requireUsage(baseKey, "deriveKey");
       var alg = _normalizeAlg(algorithm, "deriveKey");
-      if (!DERIVE_NAMES[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "deriveKey: unsupported algorithm " + JSON.stringify(alg.name));
+      if (!DERIVE_NAMES[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "deriveKey: unsupported algorithm " + _stringify(alg.name));
       _requireAlgMatch(alg, baseKey, "deriveKey");
       var dk = _normalizeAlg(derivedKeyType, "deriveKey");
       var bits;
-      if (dk.name.indexOf("AES") === 0) {
+      if (_stringIndexOf(dk.name, "AES") === 0) {
         if (dk.length !== 128 && dk.length !== 192 && dk.length !== 256) {
           throw new WebCryptoError("webcrypto/syntax", "deriveKey: " + dk.name + " length must be 128/192/256");
         }
@@ -2747,15 +2814,15 @@ var require_webcrypto = __commonJS({
       try {
         return await this.importKey("raw", raw, dk, extractable, keyUsages);
       } finally {
-        guard.secret.zeroize(new Uint8Array(raw), WebCryptoError, "webcrypto/operation", "the derived key material");
+        guard.secret.zeroize(new _Uint8Array(raw), WebCryptoError, "webcrypto/operation", "the derived key material");
       }
     };
     SubtleCrypto.prototype.encapsulateBits = async function encapsulateBits(algorithm, encapsulationKey) {
       var alg = _normalizeAlg(algorithm, "encapsulateBits");
       _requireUsage(encapsulationKey, "encapsulateBits");
-      if (!ML_KEM_NODE[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "encapsulateBits: unsupported algorithm " + JSON.stringify(alg.name));
+      if (!ML_KEM_NODE[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "encapsulateBits: unsupported algorithm " + _stringify(alg.name));
       _requireAlgMatch(alg, encapsulationKey, "encapsulateBits");
-      if (encapsulationKey.type !== "public") throw new WebCryptoError("webcrypto/invalid-access", "encapsulateBits requires a public (encapsulation) key, got " + JSON.stringify(encapsulationKey.type));
+      if (encapsulationKey.type !== "public") throw new WebCryptoError("webcrypto/invalid-access", "encapsulateBits requires a public (encapsulation) key, got " + _stringify(encapsulationKey.type));
       var r;
       try {
         r = nodeCrypto.encapsulate(encapsulationKey._handle);
@@ -2771,9 +2838,9 @@ var require_webcrypto = __commonJS({
     SubtleCrypto.prototype.decapsulateBits = async function decapsulateBits(algorithm, decapsulationKey, ciphertext) {
       var alg = _normalizeAlg(algorithm, "decapsulateBits");
       _requireUsage(decapsulationKey, "decapsulateBits");
-      if (!ML_KEM_NODE[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "decapsulateBits: unsupported algorithm " + JSON.stringify(alg.name));
+      if (!ML_KEM_NODE[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "decapsulateBits: unsupported algorithm " + _stringify(alg.name));
       _requireAlgMatch(alg, decapsulationKey, "decapsulateBits");
-      if (decapsulationKey.type !== "private") throw new WebCryptoError("webcrypto/invalid-access", "decapsulateBits requires a private (decapsulation) key, got " + JSON.stringify(decapsulationKey.type));
+      if (decapsulationKey.type !== "private") throw new WebCryptoError("webcrypto/invalid-access", "decapsulateBits requires a private (decapsulation) key, got " + _stringify(decapsulationKey.type));
       var ct = _toBuf(ciphertext, "decapsulateBits ciphertext");
       var kemRow = oid.kemParams("id-" + ML_KEM_NODE[alg.name]);
       if (kemRow && ct.length !== kemRow.ct) {
@@ -2796,19 +2863,19 @@ var require_webcrypto = __commonJS({
     };
     SubtleCrypto.prototype.wrapKey = async function wrapKey(format, key, wrappingKey, wrapAlgorithm) {
       var exported = await this.exportKey(format, key);
-      var bytes = format === "jwk" ? Buffer.from(JSON.stringify(exported)) : Buffer.from(exported);
+      var bytes = format === "jwk" ? _bufferFrom(_stringify(exported)) : _bufferFrom(exported);
       try {
         var alg = _normalizeAlg(wrapAlgorithm, "wrapKey");
         _requireUsage(wrappingKey, "wrapKey");
-        if (alg.name !== "AES-KW" && !ENCRYPT_DECRYPT_NAMES[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "wrapKey: unsupported algorithm " + JSON.stringify(alg.name));
+        if (alg.name !== "AES-KW" && !ENCRYPT_DECRYPT_NAMES[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "wrapKey: unsupported algorithm " + _stringify(alg.name));
         _requireAlgMatch(alg, wrappingKey, "wrapKey");
         if (alg.name === "AES-KW") {
           if (bytes.length < 16 || bytes.length % 8 !== 0) {
-            throw new WebCryptoError("webcrypto/operation", "wrapKey: AES-KW requires the serialized key be a multiple of 8 bytes (>= 16); got " + bytes.length + " -- format " + JSON.stringify(format) + " is not AES-KW-wrappable");
+            throw new WebCryptoError("webcrypto/operation", "wrapKey: AES-KW requires the serialized key be a multiple of 8 bytes (>= 16); got " + bytes.length + " -- format " + _stringify(format) + " is not AES-KW-wrappable");
           }
           try {
             return _withSecretBytes(wrappingKey, function(wkBytes) {
-              var c = nodeCrypto.createCipheriv("aes" + wrappingKey.algorithm.length + "-wrap", wkBytes, Buffer.from("A6A6A6A6A6A6A6A6", "hex"));
+              var c = nodeCrypto.createCipheriv("aes" + wrappingKey.algorithm.length + "-wrap", wkBytes, _bufferFrom("A6A6A6A6A6A6A6A6", "hex"));
               return _toArrayBuffer(guard.secret.cipherFinish(c, bytes, WebCryptoError, "webcrypto/operation", "an AES-KW wrap intermediate"));
             });
           } catch (e) {
@@ -2824,7 +2891,7 @@ var require_webcrypto = __commonJS({
     SubtleCrypto.prototype.unwrapKey = async function unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) {
       var alg = _normalizeAlg(unwrapAlgorithm, "unwrapKey");
       _requireUsage(unwrappingKey, "unwrapKey");
-      if (alg.name !== "AES-KW" && !ENCRYPT_DECRYPT_NAMES[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "unwrapKey: unsupported algorithm " + JSON.stringify(alg.name));
+      if (alg.name !== "AES-KW" && !ENCRYPT_DECRYPT_NAMES[alg.name]) throw new WebCryptoError("webcrypto/not-supported", "unwrapKey: unsupported algorithm " + _stringify(alg.name));
       _requireAlgMatch(alg, unwrappingKey, "unwrapKey");
       var bytes;
       if (alg.name === "AES-KW") {
@@ -2834,7 +2901,7 @@ var require_webcrypto = __commonJS({
         }
         try {
           bytes = _withSecretBytes(unwrappingKey, function(kwBytes) {
-            var d = nodeCrypto.createDecipheriv("aes" + unwrappingKey.algorithm.length + "-wrap", kwBytes, Buffer.from("A6A6A6A6A6A6A6A6", "hex"));
+            var d = nodeCrypto.createDecipheriv("aes" + unwrappingKey.algorithm.length + "-wrap", kwBytes, _bufferFrom("A6A6A6A6A6A6A6A6", "hex"));
             return guard.secret.cipherFinish(d, wrapped, WebCryptoError, "webcrypto/operation", "the unwrapped key material");
           });
         } catch (e) {
@@ -2842,7 +2909,7 @@ var require_webcrypto = __commonJS({
         }
       } else {
         var unwrapKeyClone = _cloneWithUsage(unwrappingKey, "decrypt");
-        bytes = Buffer.from(await this.decrypt(unwrapAlgorithm, unwrapKeyClone, wrappedKey));
+        bytes = _bufferFrom(await this.decrypt(unwrapAlgorithm, unwrapKeyClone, wrappedKey));
       }
       var keyData;
       if (format === "jwk") {
@@ -2866,7 +2933,7 @@ var require_webcrypto = __commonJS({
       }
     };
     function _cloneWithUsage(key, usage) {
-      var k = new CryptoKey(key.type, key.extractable, key.algorithm, key.usages.concat([usage]), key._handle);
+      var k = new CryptoKey(key.type, key.extractable, key.algorithm, _concat(key.usages, [usage]), key._handle);
       return k;
     }
     function _assertAesImportLen(name, byteLen) {
@@ -2915,7 +2982,7 @@ var require_webcrypto = __commonJS({
       throw new WebCryptoError("webcrypto/data", "an ML-KEM private key must be the seed, expandedKey, or both CHOICE (RFC 9935 sec. 6)");
     }
     var PKCS8_INNER_VALIDATORS = {};
-    Object.keys(ML_KEM_INNER).forEach(function(o) {
+    _forEach(_keys(ML_KEM_INNER), function(o) {
       PKCS8_INNER_VALIDATORS[o] = function(inner) {
         _validateMlKemInner(inner, ML_KEM_INNER[o]);
       };
@@ -2968,7 +3035,7 @@ var require_webcrypto = __commonJS({
       }
       if (format === "jwk") {
         var jwk = keyData;
-        if (jwk === null || typeof jwk !== "object" || Array.isArray(jwk)) {
+        if (jwk === null || typeof jwk !== "object" || _isArray(jwk)) {
           throw new WebCryptoError("webcrypto/data", "importKey jwk: keyData must be a JsonWebKey object");
         }
         if (jwk.kty === "oct") {
@@ -2978,13 +3045,13 @@ var require_webcrypto = __commonJS({
           var a2 = name === "HMAC" ? { name, hash: _hashObj(alg.hash, "importKey jwk HMAC"), length: kbuf.length * 8 } : { name, length: kbuf.length * 8 };
           return new CryptoKey("secret", extractable, a2, usages, s2);
         }
-        var isPrivate = Object.prototype.hasOwnProperty.call(jwk, "d") || jwk.kty === "AKP" && Object.prototype.hasOwnProperty.call(jwk, "priv");
+        var isPrivate = _hasOwn(jwk, "d") || jwk.kty === "AKP" && _hasOwn(jwk, "priv");
         var ko = _nodeKey(function() {
           return isPrivate ? nodeCrypto.createPrivateKey({ key: jwk, format: "jwk" }) : nodeCrypto.createPublicKey({ key: jwk, format: "jwk" });
         }, "importKey jwk");
         return new CryptoKey(isPrivate ? "private" : "public", isPrivate ? extractable : true, _algFromImport(name, alg, ko), usages, ko);
       }
-      throw new WebCryptoError("webcrypto/not-supported", "importKey: unsupported format " + JSON.stringify(format));
+      throw new WebCryptoError("webcrypto/not-supported", "importKey: unsupported format " + _stringify(format));
     };
     function _importRawPublic(name, alg, raw, extractable, usages) {
       if (name === "ED25519" || name === "ED448" || name === "X25519" || name === "X448") {
@@ -2995,11 +3062,11 @@ var require_webcrypto = __commonJS({
       if (name === "ECDSA" || name === "ECDH") {
         var fb = CURVE_FIELD_BYTES[alg.namedCurve];
         if (!fb || raw[0] !== 4 || raw.length !== 1 + 2 * fb) throw new WebCryptoError("webcrypto/data", "importKey raw EC: expected an uncompressed point for " + alg.namedCurve);
-        var ecjwk = { kty: "EC", crv: alg.namedCurve, x: _bufToB64url(raw.subarray(1, 1 + fb)), y: _bufToB64url(raw.subarray(1 + fb)) };
+        var ecjwk = { kty: "EC", crv: alg.namedCurve, x: _bufToB64url(_subarray(raw, 1, 1 + fb)), y: _bufToB64url(_subarray(raw, 1 + fb)) };
         var eck = nodeCrypto.createPublicKey({ key: ecjwk, format: "jwk" });
         return new CryptoKey("public", true, { name, namedCurve: alg.namedCurve }, usages, eck);
       }
-      throw new WebCryptoError("webcrypto/not-supported", "importKey raw: unsupported public-key algorithm " + JSON.stringify(name));
+      throw new WebCryptoError("webcrypto/not-supported", "importKey raw: unsupported public-key algorithm " + _stringify(name));
     }
     var IMPORT_KEY_TYPE = {
       "RSASSA-PKCS1-V1_5": { rsa: 1 },
@@ -3013,7 +3080,7 @@ var require_webcrypto = __commonJS({
       "X448": { x448: 1 }
     };
     [ML_DSA_NODE, ML_KEM_NODE, SLH_DSA_NODE].forEach(function(m) {
-      Object.keys(m).forEach(function(webName) {
+      _forEach(_keys(m), function(webName) {
         var t = {};
         t[m[webName]] = 1;
         IMPORT_KEY_TYPE[webName] = t;
@@ -3030,7 +3097,7 @@ var require_webcrypto = __commonJS({
           throw new WebCryptoError("webcrypto/not-supported", name + ": imported key uses an unsupported EC curve");
         }
         if (alg.namedCurve && alg.namedCurve !== actualCurve) {
-          throw new WebCryptoError("webcrypto/data", name + ": importKey namedCurve " + JSON.stringify(alg.namedCurve) + " does not match the imported key's curve " + JSON.stringify(actualCurve));
+          throw new WebCryptoError("webcrypto/data", name + ": importKey namedCurve " + _stringify(alg.namedCurve) + " does not match the imported key's curve " + _stringify(actualCurve));
         }
         return { name, namedCurve: actualCurve };
       }
@@ -3069,19 +3136,19 @@ var require_webcrypto = __commonJS({
         }
         return _toArrayBuffer(_rawPublic(key));
       }
-      throw new WebCryptoError("webcrypto/not-supported", "exportKey: unsupported format " + JSON.stringify(format));
+      throw new WebCryptoError("webcrypto/not-supported", "exportKey: unsupported format " + _stringify(format));
     };
     function _rawPublic(key) {
       var jwk = key._handle.export({ format: "jwk" });
       if (jwk.kty === "OKP") return _b64urlToBuf(jwk.x);
-      if (jwk.kty === "EC") return Buffer.concat([Buffer.from([4]), _b64urlToBuf(jwk.x), _b64urlToBuf(jwk.y)]);
+      if (jwk.kty === "EC") return _bufferConcat([_bufferFrom([4]), _b64urlToBuf(jwk.x), _b64urlToBuf(jwk.y)]);
       throw new WebCryptoError("webcrypto/not-supported", "exportKey raw: unsupported key type " + jwk.kty);
     }
     function Crypto() {
       this.subtle = new SubtleCrypto();
     }
     Crypto.prototype.getRandomValues = function getRandomValues(typedArray) {
-      if (!ArrayBuffer.isView(typedArray) || typedArray instanceof Float32Array || typedArray instanceof Float64Array || typedArray instanceof DataView) {
+      if (!_isView(typedArray) || _types.isFloat32Array(typedArray) || _types.isFloat64Array(typedArray) || _types.isDataView(typedArray)) {
         throw new WebCryptoError("webcrypto/data", "getRandomValues: expected an integer TypedArray");
       }
       var out = guard.bytes.outputView(typedArray, WebCryptoError, "webcrypto/data", "getRandomValues");
@@ -3104,18 +3171,18 @@ var require_webcrypto = __commonJS({
       }
     }
     var _crypto = new Crypto();
-    var _EXPORT_FORMAT = Object.assign(/* @__PURE__ */ Object.create(null), { "private": "pkcs8", "public": "spki", "secret": "raw" });
+    var _EXPORT_FORMAT = _assign(_create(null), { "private": "pkcs8", "public": "spki", "secret": "raw" });
     function isCryptoKeyLike(x) {
-      return !!x && typeof x === "object" && typeof x.type === "string" && typeof x.extractable === "boolean" && !!x.algorithm && typeof x.algorithm === "object" && typeof x.algorithm.name === "string" && Array.isArray(x.usages);
+      return !!x && typeof x === "object" && typeof x.type === "string" && typeof x.extractable === "boolean" && !!x.algorithm && typeof x.algorithm === "object" && typeof x.algorithm.name === "string" && _isArray(x.usages);
     }
     function exportAnyKey(key, E, code) {
       var format = _EXPORT_FORMAT[key && key.type];
       if (!format) throw E(code, "a CryptoKey with a private, public, or secret type is required");
       if (key instanceof CryptoKey) {
-        return Promise.resolve().then(function() {
+        return _resolve(Promise).then(function() {
           return _crypto.subtle.exportKey(format, key);
         }).then(function(b) {
-          return Buffer.from(b);
+          return _bufferFrom(b);
         });
       }
       if (!key.extractable) {
@@ -3123,31 +3190,31 @@ var require_webcrypto = __commonJS({
       }
       var handle = key._handle;
       if (handle instanceof nodeCrypto.KeyObject && handle.type === key.type) {
-        return Promise.resolve().then(function() {
+        return _resolve(Promise).then(function() {
           return format === "raw" ? handle.export() : handle.export({ format: "der", type: format });
         }).then(function(b) {
-          return Buffer.from(b);
+          return _bufferFrom(b);
         }, function(e) {
           throw E(code, "the CryptoKey comes from a different copy of this WebCrypto engine and its key material could not be read; import it through pki.webcrypto.subtle, or pass the key as DER", e);
         });
       }
-      return Promise.resolve().then(function() {
+      return _resolve(Promise).then(function() {
         return nodeCrypto.webcrypto.subtle.exportKey(format, key);
       }).then(function(b) {
-        return Buffer.from(b);
+        return _bufferFrom(b);
       }, function(e) {
         throw E(code, "the CryptoKey comes from a different WebCrypto implementation and could not be exported for re-import; import it through pki.webcrypto.subtle, or pass the key as DER", e);
       });
     }
     function adoptKey(key, importParams, usages, E, code) {
-      if (key instanceof CryptoKey) return Promise.resolve(key);
-      if (!Array.isArray(key.usages)) throw E(code, "a CryptoKey carrying its permitted usages is required");
+      if (key instanceof CryptoKey) return _resolve(Promise, key);
+      if (!_isArray(key.usages)) throw E(code, "a CryptoKey carrying its permitted usages is required");
       for (var i = 0; i < usages.length; i++) {
-        if (key.usages.indexOf(usages[i]) === -1) {
-          throw E(code, "the CryptoKey is not permitted for '" + usages[i] + "' (usages: " + key.usages.join(",") + ")");
+        if (_indexOf(key.usages, usages[i]) === -1) {
+          throw E(code, "the CryptoKey is not permitted for '" + usages[i] + "' (usages: " + _join(key.usages, ",") + ")");
         }
       }
-      return Promise.resolve().then(function() {
+      return _resolve(Promise).then(function() {
         return exportAnyKey(key, E, code);
       }).then(function(der) {
         return _crypto.subtle.importKey(_EXPORT_FORMAT[key.type], der, importParams || key.algorithm, false, usages);
@@ -4012,6 +4079,39 @@ var require_guard_crypto = __commonJS({
   }
 });
 
+// node_modules/@blamejs/pki/lib/guard-list.js
+var require_guard_list = __commonJS({
+  "node_modules/@blamejs/pki/lib/guard-list.js"(exports2, module2) {
+    "use strict";
+    function contains(list, value) {
+      if (!list) return false;
+      for (var i = 0, n = list.length; i < n; i++) if (list[i] === value) return true;
+      return false;
+    }
+    function containsAll(list, values) {
+      if (!values) return true;
+      for (var i = 0, n = values.length; i < n; i++) if (!contains(list, values[i])) return false;
+      return true;
+    }
+    function anyMatches(list, predicate) {
+      if (!list) return false;
+      for (var i = 0, n = list.length; i < n; i++) if (predicate(list[i], i)) return true;
+      return false;
+    }
+    function allMatch(list, predicate) {
+      if (!list) return true;
+      for (var i = 0, n = list.length; i < n; i++) if (!predicate(list[i], i)) return false;
+      return true;
+    }
+    module2.exports = {
+      contains,
+      containsAll,
+      anyMatches,
+      allMatch
+    };
+  }
+});
+
 // node_modules/@blamejs/pki/lib/guard-range.js
 var require_guard_range = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-range.js"(exports2, module2) {
@@ -4724,6 +4824,7 @@ var require_guard_all = __commonJS({
     var text = require_guard_text();
     var limits = require_guard_limits();
     var crypto = require_guard_crypto();
+    var list = require_guard_list();
     var range = require_guard_range();
     var time = require_guard_time();
     var name = require_guard_name();
@@ -4736,12 +4837,12 @@ var require_guard_all = __commonJS({
     var secret = require_guard_secret();
     var parsed = require_guard_parsed();
     var async_ = require_guard_async();
-    var intrinsic = require_guard_intrinsic();
     module2.exports = {
       bytes,
       text,
       limits,
       crypto,
+      list,
       range,
       time,
       name,
@@ -4753,8 +4854,7 @@ var require_guard_all = __commonJS({
       compress,
       secret,
       parsed,
-      async: async_,
-      intrinsic
+      async: async_
     };
   }
 });
@@ -4766,6 +4866,8 @@ var require_asn1_der = __commonJS({
     var constants = require_constants();
     var frameworkError = require_framework_error();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _isArray = intrinsic.isArray;
     var Asn1Error = frameworkError.Asn1Error;
     var OidError = frameworkError.OidError;
     function _asn1Error(c, m) {
@@ -5400,7 +5502,7 @@ var require_asn1_der = __commonJS({
       // encoder composes, so the minimal-encoding rule lives once (the CHECK side is
       // schema.assertMinimalNamedBits). No bits asserted -> the empty BIT STRING.
       namedBitString: function(positions) {
-        if (!Array.isArray(positions)) throw new Asn1Error("asn1/bad-bit-string", "namedBitString requires an array of bit positions");
+        if (!_isArray(positions)) throw new Asn1Error("asn1/bad-bit-string", "namedBitString requires an array of bit positions");
         var hi = -1, i, p;
         for (i = 0; i < positions.length; i++) {
           p = positions[i];
@@ -5498,7 +5600,7 @@ var require_asn1_der = __commonJS({
       return content;
     }
     function _asBufferArray(arr, who) {
-      if (!Array.isArray(arr)) throw new Asn1Error("asn1/bad-children", who + ": expected an array of TLV buffers");
+      if (!_isArray(arr)) throw new Asn1Error("asn1/bad-children", who + ": expected an array of TLV buffers");
       return arr.map(function(b) {
         return _asBuffer(b, who);
       });
@@ -7074,6 +7176,8 @@ var require_validator_attcert = __commonJS({
     "use strict";
     var oid = require_oid();
     var asn1 = require_asn1_der();
+    var guard = require_guard_all();
+    var _asserts = guard.list.contains;
     function requireV3(cert, E, code) {
       if (cert.version !== 3) throw new E(code, "an attestation certificate must be X.509 version 3");
     }
@@ -7103,7 +7207,7 @@ var require_validator_attcert = __commonJS({
       assertNotCa(cert, exts, E, code);
       if ((cert.subject.rdns || []).length !== 0) throw new E(code, "the tpm AIK certificate subject MUST be empty (WebAuthn 8.3.1)");
       var eku = exts.decode(cert, "extKeyUsage");
-      if (!eku || !Array.isArray(eku.value) || eku.value.indexOf(oid.byName("tcgKpAikCertificate")) === -1) {
+      if (!eku || !Array.isArray(eku.value) || !_asserts(eku.value, oid.byName("tcgKpAikCertificate"))) {
         throw new E(code, "the tpm AIK certificate lacks the tcg-kp-AIKCertificate extended key purpose (WebAuthn 8.3.1)");
       }
       var san = exts.decode(cert, "subjectAltName");
@@ -7991,6 +8095,8 @@ var require_ct = __commonJS({
     var constants = require_constants();
     var frameworkError = require_framework_error();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var ByteReader = require_byte_reader();
     var ByteWriter = require_byte_writer();
     var oid = require_oid();
@@ -8345,7 +8451,7 @@ var require_ct = __commonJS({
     function _parseLogState(state) {
       if (state == null || typeof state !== "object") throw _ctErr("ct/bad-state", "a CT log entry is missing its state");
       var keys = Object.keys(state);
-      if (keys.length !== 1 || !Object.prototype.hasOwnProperty.call(LOG_STATE_TRUST, keys[0])) {
+      if (keys.length !== 1 || !_hasOwn(LOG_STATE_TRUST, keys[0])) {
         throw _ctErr("ct/bad-state", "a CT log state must carry exactly one recognized member (pending/qualified/usable/readonly/retired/rejected)");
       }
       var name = keys[0], member = state[name];
@@ -8603,6 +8709,8 @@ var require_schema_pkix = __commonJS({
     var constants = require_constants();
     var schema = require_schema_engine();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var ct = require_ct();
     var PEM_RE = /-----BEGIN ([A-Z0-9 ]+)-----([\s\S]*?)-----END \1-----/;
     function pemDecode(text, label, PemError) {
@@ -8690,7 +8798,7 @@ var require_schema_pkix = __commonJS({
     function versionReader(ns, accept) {
       return schema.decode(function(n) {
         var key = asn1.read.integer(n).toString();
-        if (Object.prototype.hasOwnProperty.call(accept, key)) return accept[key];
+        if (_hasOwn(accept, key)) return accept[key];
         throw ns.E(ns.prefix + "/bad-version", "unsupported version " + key);
       });
     }
@@ -11793,6 +11901,8 @@ var require_schema_crl = __commonJS({
     var pkix = require_schema_pkix();
     var oid = require_oid();
     var frameworkError = require_framework_error();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var CrlError = frameworkError.CrlError;
     var PemError = frameworkError.PemError;
     var TAGS = asn1.TAGS;
@@ -11814,7 +11924,7 @@ var require_schema_crl = __commonJS({
           if (value < 0n) throw new Error("cRLNumber must be non-negative (INTEGER 0..MAX)");
         } else if (ext.oid === OID_REASON_CODE) {
           var reason = asn1.read.enumerated(asn1.decode(ext.value));
-          if (!Object.prototype.hasOwnProperty.call(CRL_REASONS, reason.toString())) throw new Error("undefined CRLReason " + reason.toString());
+          if (!_hasOwn(CRL_REASONS, reason.toString())) throw new Error("undefined CRLReason " + reason.toString());
           value = Number(reason);
         } else if (ext.oid === OID_INVALIDITY_DATE) {
           var n = asn1.decode(ext.value);
@@ -13678,6 +13788,8 @@ var require_schema_ocsp = __commonJS({
     var oid = require_oid();
     var constants = require_constants();
     var frameworkError = require_framework_error();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var OcspError = frameworkError.OcspError;
     var PemError = frameworkError.PemError;
     var NS = pkix.makeNS("ocsp", OcspError, oid);
@@ -13693,13 +13805,13 @@ var require_schema_ocsp = __commonJS({
     var OCSP_RESPONSE_STATUS = schema.decode(function(n, ctx) {
       var v = asn1.read.enumerated(n);
       var key = v.toString();
-      if (!Object.prototype.hasOwnProperty.call(STATUS_NAMES, key)) throw ctx.E("ocsp/bad-response-status", "undefined OCSPResponseStatus " + key + " (RFC 6960 sec. 4.2.1)");
+      if (!_hasOwn(STATUS_NAMES, key)) throw ctx.E("ocsp/bad-response-status", "undefined OCSPResponseStatus " + key + " (RFC 6960 sec. 4.2.1)");
       return { code: Number(v), name: STATUS_NAMES[key] };
     });
     var CRL_REASON = schema.decode(function(n, ctx) {
       var v = asn1.read.enumerated(n);
       var key = v.toString();
-      if (!Object.prototype.hasOwnProperty.call(CRL_REASONS, key)) throw ctx.E("ocsp/bad-revocation-reason", "undefined CRLReason " + key + " (RFC 5280 sec. 5.3.1)");
+      if (!_hasOwn(CRL_REASONS, key)) throw ctx.E("ocsp/bad-revocation-reason", "undefined CRLReason " + key + " (RFC 5280 sec. 5.3.1)");
       return CRL_REASONS[key];
     });
     function certificateBytes() {
@@ -15803,6 +15915,8 @@ var require_schema_attrcert = __commonJS({
     var pkix = require_schema_pkix();
     var oid = require_oid();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var frameworkError = require_framework_error();
     var AttrCertError = frameworkError.AttrCertError;
     var PemError = frameworkError.PemError;
@@ -15816,7 +15930,7 @@ var require_schema_attrcert = __commonJS({
     var DIGESTED_OBJECT_TYPE = schema.decode(function(n, ctx) {
       var v = asn1.read.enumerated(n);
       var k = v.toString();
-      if (!Object.prototype.hasOwnProperty.call(ODT_NAMES, k)) {
+      if (!_hasOwn(ODT_NAMES, k)) {
         throw ctx.E("attrcert/bad-digested-object-type", "digestedObjectType " + k + " is not a defined value (RFC 5755 sec. 4.1)");
       }
       if (k === "2") {
@@ -17578,6 +17692,7 @@ var require_ocsp_verify = __commonJS({
     "use strict";
     var asn1 = require_asn1_der();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
     var oid = require_oid();
     var x509 = require_schema_x509();
     var compositeSig = require_composite_sig();
@@ -17589,12 +17704,15 @@ var require_ocsp_verify = __commonJS({
     OCSP_CERTID_HASHES[oid.byName("sha384")] = "SHA-384";
     OCSP_CERTID_HASHES[oid.byName("sha512")] = "SHA-512";
     var OID_OCSP_SIGNING = oid.byName("ocspSigning");
+    var _asserts = guard.list.contains;
+    var _bufferFrom = intrinsic.bufferFrom;
+    var _bytesEqual = intrinsic.bufferEquals;
     var OID_OCSP_NOCHECK = oid.byName("ocspNoCheck");
     var OID_EKU = oid.byName("extKeyUsage");
     var OID_KEY_USAGE = oid.byName("keyUsage");
     function ocspDigest(alg, buf) {
       return subtle.digest(alg, buf).then(function(h) {
-        return Buffer.from(h);
+        return _bufferFrom(h);
       });
     }
     function ocspKeyValue(spkiDer) {
@@ -17633,12 +17751,12 @@ var require_ocsp_verify = __commonJS({
       }
       async function ocspCertIdMatches(certID, cert, issuerNameCandidates, issuerKeyBits) {
         if (certID.serialNumberHex !== cert.serialNumberHex) return false;
-        var hashName = OCSP_CERTID_HASHES[certID.hashAlgorithm.oid];
+        var hashName = intrinsic.hasOwn(OCSP_CERTID_HASHES, certID.hashAlgorithm.oid) ? OCSP_CERTID_HASHES[certID.hashAlgorithm.oid] : null;
         if (!hashName) return false;
         var keyHash = await ocspDigest(hashName, issuerKeyBits);
-        if (!certID.issuerKeyHash.equals(keyHash)) return false;
+        if (!_bytesEqual(certID.issuerKeyHash, keyHash)) return false;
         for (var i = 0; i < issuerNameCandidates.length; i++) {
-          if (certID.issuerNameHash.equals(await ocspDigest(hashName, issuerNameCandidates[i]))) return true;
+          if (_bytesEqual(certID.issuerNameHash, await ocspDigest(hashName, issuerNameCandidates[i]))) return true;
         }
         return false;
       }
@@ -17647,7 +17765,7 @@ var require_ocsp_verify = __commonJS({
         var matchesIssuer = false;
         try {
           if (rid.byName) matchesIssuer = dnEqual(rid.byName.rdns, cert.issuer.rdns);
-          else if (rid.byKey) matchesIssuer = rid.byKey.equals(await ocspDigest("SHA-1", issuerKeyBits));
+          else if (rid.byKey) matchesIssuer = _bytesEqual(rid.byKey, await ocspDigest("SHA-1", issuerKeyBits));
         } catch (_e) {
           matchesIssuer = false;
         }
@@ -17662,7 +17780,7 @@ var require_ocsp_verify = __commonJS({
           var identifies = false;
           try {
             if (rid.byName) identifies = dnEqual(rid.byName.rdns, rc.subject.rdns);
-            else if (rid.byKey) identifies = rid.byKey.equals(await ocspDigest("SHA-1", ocspKeyValue(rc.subjectPublicKeyInfo.bytes)));
+            else if (rid.byKey) identifies = _bytesEqual(rid.byKey, await ocspDigest("SHA-1", ocspKeyValue(rc.subjectPublicKeyInfo.bytes)));
           } catch (_e) {
             identifies = false;
           }
@@ -17683,7 +17801,7 @@ var require_ocsp_verify = __commonJS({
           } catch (_e) {
             continue;
           }
-          if (!eku || eku.value.indexOf(OID_OCSP_SIGNING) === -1) continue;
+          if (!eku || !_asserts(eku.value, OID_OCSP_SIGNING)) continue;
           var ku;
           try {
             ku = decodeExt(rc, OID_KEY_USAGE);
@@ -17847,11 +17965,20 @@ var require_sign_scheme = __commonJS({
     var subtle = webcrypto.webcrypto.subtle;
     var validator = require_validator_all();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
     var compositeSig = require_composite_sig();
     var b = asn1.build;
     function O(name) {
       return oid.byName(name);
     }
+    var _BigInt = intrinsic.BigInt;
+    var _String = intrinsic.String;
+    var _filter = intrinsic.filter;
+    var _stringify = intrinsic.stringify;
+    var _toUpperCase = intrinsic.toUpperCase;
+    var _isBuffer = intrinsic.isBuffer;
+    var _bufferFrom = intrinsic.bufferFrom;
+    var _isU8 = intrinsic.types.isUint8Array;
     var HASH = { sha256: "SHA-256", sha384: "SHA-384", sha512: "SHA-512" };
     var NODE_DIGEST = { sha256: "sha256", sha384: "sha384", sha512: "sha512", shake128: "shake128", shake256: "shake256" };
     var PSS_SALT = { "SHA-256": 32, "SHA-384": 48, "SHA-512": 64 };
@@ -17874,6 +18001,11 @@ var require_sign_scheme = __commonJS({
       "ML-DSA-65": { sha384: 1, sha512: 1, shake256: 1 },
       "ML-DSA-87": { sha512: 1, shake256: 1 }
     };
+    function mldsaDigestSuitable(mlName, md) {
+      if (!intrinsic.hasOwn(MLDSA_SUITABLE_DIGEST, mlName)) return false;
+      var row = MLDSA_SUITABLE_DIGEST[mlName];
+      return !!row && intrinsic.hasOwn(row, md) && !!row[md];
+    }
     var SLHDSA_BY_OID = {};
     [
       ["sha2-128s", "sha256"],
@@ -17897,7 +18029,7 @@ var require_sign_scheme = __commonJS({
     function _pssAlgId(digestName) {
       var hashAlg = b.sequence([b.oid(O(digestName)), b.nullValue()]);
       var mgf = b.sequence([b.oid(O("mgf1")), hashAlg]);
-      var params = b.sequence([b.explicit(0, hashAlg), b.explicit(1, mgf), b.explicit(2, b.integer(BigInt(PSS_SALT[HASH[digestName]])))]);
+      var params = b.sequence([b.explicit(0, hashAlg), b.explicit(1, mgf), b.explicit(2, b.integer(_BigInt(PSS_SALT[HASH[digestName]])))]);
       return b.sequence([b.oid(O("rsassaPss")), params]);
     }
     function _pssHashFromSpki(cert, E) {
@@ -17912,7 +18044,7 @@ var require_sign_scheme = __commonJS({
       if (node.tagClass !== "universal" || node.tagNumber !== asn1.TAGS.SEQUENCE || !node.children) {
         throw E("unsupported-algorithm", "the id-RSASSA-PSS key parameters are not an RSASSA-PSS-params SEQUENCE (RFC 4055 sec. 3.1)");
       }
-      var hashField = node.children.filter(function(c) {
+      var hashField = _filter(node.children, function(c) {
         return c.tagClass === "context" && c.tagNumber === 0;
       })[0];
       if (!hashField) return "sha1";
@@ -17941,15 +18073,15 @@ var require_sign_scheme = __commonJS({
       var comp = compositeSig.COMPOSITE_ALGS[keyOid];
       if (comp) {
         if (comp.trad.unsupported) throw E("unsupported-algorithm", "composite " + comp.name + ": " + comp.trad.unsupported);
-        if (so.digestAlgorithm && so.digestAlgorithm !== comp.phCms) throw E("bad-input", "composite " + comp.name + " fixes the digestAlgorithm to " + comp.phCms + " (draft-ietf-lamps-cms-composite-sigs sec. 3.4); " + JSON.stringify(so.digestAlgorithm) + " conflicts");
+        if (so.digestAlgorithm && so.digestAlgorithm !== comp.phCms) throw E("bad-input", "composite " + comp.name + " fixes the digestAlgorithm to " + comp.phCms + " (draft-ietf-lamps-cms-composite-sigs sec. 3.4); " + _stringify(so.digestAlgorithm) + " conflicts");
         return { composite: comp, digest: comp.phCms, digestAlgId: _algId(comp.phCms, "absent"), sigAlgId: _algId(comp.name, "absent") };
       }
       if (keyOid === O("rsaEncryption") || keyOid === O("rsassaPss")) {
         var isPssKey = keyOid === O("rsassaPss");
         var pinned = isPssKey ? _pssHashFromSpki(cert, E) : null;
-        if (pinned && so.digestAlgorithm && so.digestAlgorithm !== pinned) throw E("bad-input", "the signer key restricts the RSASSA-PSS digest to " + pinned + ", but digestAlgorithm " + JSON.stringify(so.digestAlgorithm) + " was requested");
+        if (pinned && so.digestAlgorithm && so.digestAlgorithm !== pinned) throw E("bad-input", "the signer key restricts the RSASSA-PSS digest to " + pinned + ", but digestAlgorithm " + _stringify(so.digestAlgorithm) + " was requested");
         var d = so.digestAlgorithm || pinned || "sha256";
-        if (!HASH[d]) throw E("unsupported-algorithm", "unsupported RSA digest algorithm " + JSON.stringify(d));
+        if (!HASH[d]) throw E("unsupported-algorithm", "unsupported RSA digest algorithm " + _stringify(d));
         if (so.pss || isPssKey) return { digest: d, digestAlgId: _algId(d, "absent"), sigAlgId: _pssAlgId(d), imp: { name: "RSA-PSS", hash: HASH[d] }, sign: { name: "RSA-PSS", saltLength: PSS_SALT[HASH[d]] }, ecdsaDer: false };
         var rsaSigAlgId = so.combinedRsaSig ? _algId(RSA_PKCS1_SIG[d], "null") : _algId("rsaEncryption", "null");
         return { digest: d, digestAlgId: _algId(d, "absent"), sigAlgId: rsaSigAlgId, imp: { name: "RSASSA-PKCS1-v1_5", hash: HASH[d] }, sign: { name: "RSASSA-PKCS1-v1_5" }, ecdsaDer: false };
@@ -17964,13 +18096,13 @@ var require_sign_scheme = __commonJS({
         var ec = EC_BY_CURVE_OID[curveOid];
         if (!ec) throw E("unsupported-algorithm", "the signer key is on an unsupported EC curve");
         var de = so.digestAlgorithm || "sha256";
-        if (!HASH[de]) throw E("unsupported-algorithm", "unsupported ECDSA digest algorithm " + JSON.stringify(de));
+        if (!HASH[de]) throw E("unsupported-algorithm", "unsupported ECDSA digest algorithm " + _stringify(de));
         return { digest: de, digestAlgId: _algId(de, "absent"), sigAlgId: _algId(ECDSA_ALG[de], "absent"), imp: { name: "ECDSA", namedCurve: ec.curve }, sign: { name: "ECDSA", hash: HASH[de] }, ecdsaDer: true, coordLen: ec.coordLen };
       }
       if (keyOid === O("Ed25519") || keyOid === O("Ed448")) {
         var name = keyOid === O("Ed25519") ? "Ed25519" : "Ed448";
         var dd = so.digestAlgorithm || (name === "Ed25519" ? "sha512" : "shake256");
-        if (!NODE_DIGEST[dd]) throw E("unsupported-algorithm", "unsupported " + name + " digest algorithm " + JSON.stringify(dd));
+        if (!NODE_DIGEST[dd]) throw E("unsupported-algorithm", "unsupported " + name + " digest algorithm " + _stringify(dd));
         return { digest: dd, digestAlgId: _algId(dd, "absent"), sigAlgId: _algId(name, "absent"), imp: { name }, sign: { name }, ecdsaDer: false };
       }
       if (MLDSA_BY_OID[keyOid]) {
@@ -17980,27 +18112,27 @@ var require_sign_scheme = __commonJS({
           md = "sha512";
         } else {
           md = so.digestAlgorithm || "sha512";
-          if (!NODE_DIGEST[md]) throw E("unsupported-algorithm", "unsupported ML-DSA message digest " + JSON.stringify(md));
-          if (!MLDSA_SUITABLE_DIGEST[mlName][md]) throw E("unsupported-algorithm", "the " + md + " message digest is below the security strength of " + mlName + " (RFC 9882 sec. 3.3)");
+          if (!NODE_DIGEST[md]) throw E("unsupported-algorithm", "unsupported ML-DSA message digest " + _stringify(md));
+          if (!mldsaDigestSuitable(mlName, md)) throw E("unsupported-algorithm", "the " + md + " message digest is below the security strength of " + mlName + " (RFC 9882 sec. 3.3)");
         }
         return { digest: md, digestAlgId: _algId(md, "absent"), sigAlgId: _algId(oid.name(keyOid), "absent"), imp: { name: mlName }, sign: { name: mlName }, ecdsaDer: false };
       }
       if (SLHDSA_BY_OID[keyOid]) {
         var slh = SLHDSA_BY_OID[keyOid];
-        if (so.digestAlgorithm && so.digestAlgorithm !== slh.digest) throw E("bad-input", "SLH-DSA " + slh.wc + " requires the " + slh.digest + " message digest (RFC 9814 sec. 4); digestAlgorithm " + JSON.stringify(so.digestAlgorithm) + " conflicts");
+        if (so.digestAlgorithm && so.digestAlgorithm !== slh.digest) throw E("bad-input", "SLH-DSA " + slh.wc + " requires the " + slh.digest + " message digest (RFC 9814 sec. 4); digestAlgorithm " + _stringify(so.digestAlgorithm) + " conflicts");
         return { digest: slh.digest, digestAlgId: _algId(slh.digest, "absent"), sigAlgId: _algId(oid.name(keyOid), "absent"), imp: { name: slh.wc }, sign: { name: slh.wc }, ecdsaDer: false };
       }
       throw E("unsupported-algorithm", "unsupported signer key algorithm " + keyOid);
     }
     function _assertKeyMatchesScheme(key, imp, E) {
       var ka = key.algorithm || {};
-      if (String(ka.name).toUpperCase() !== String(imp.name).toUpperCase()) 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))) throw E("bad-input", "the signer CryptoKey algorithm (" + ka.name + ") does not match the certificate's key algorithm (" + imp.name + ")");
       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 + ")");
     }
     function _normPkcs8(k, label, E) {
-      if (Buffer.isBuffer(k)) return guard.bytes.view(k, E, "bad-input", label);
-      if (k instanceof Uint8Array) return guard.bytes.snapshot(k, E, "bad-input", label);
+      if (_isBuffer(k)) return guard.bytes.view(k, E, "bad-input", label);
+      if (_isU8(k)) return guard.bytes.snapshot(k, E, "bad-input", label);
       if (typeof k === "string") {
         try {
           return pkcs8.pemDecode(k);
@@ -18011,19 +18143,19 @@ var require_sign_scheme = __commonJS({
       throw E("bad-input", label + " must be a PKCS#8 DER Buffer, Uint8Array, or PEM string");
     }
     function _normCompositeKeys(key, comp, E) {
-      if (!key || typeof key !== "object" || Buffer.isBuffer(key) || key instanceof Uint8Array || key.mldsa == null || key.trad == null) {
+      if (!key || typeof key !== "object" || _isBuffer(key) || _isU8(key) || key.mldsa == null || key.trad == null) {
         throw E("bad-input", "a composite " + comp.name + " signer key must be { mldsa: <PKCS#8>, trad: <PKCS#8> }");
       }
       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" && !Buffer.isBuffer(key) && !(key instanceof Uint8Array) && key.type === "private") {
+      if (key && typeof key === "object" && !_isBuffer(key) && !_isU8(key) && key.type === "private") {
         _assertKeyMatchesScheme(key, imp, E);
         return webcrypto.adoptKey(key, imp, ["sign"], E, "bad-input");
       }
       var der, owned = false;
-      if (Buffer.isBuffer(key)) der = guard.bytes.view(key, E, "bad-input", "the signer private key");
-      else if (key instanceof Uint8Array) {
+      if (_isBuffer(key)) der = guard.bytes.view(key, E, "bad-input", "the signer private key");
+      else if (_isU8(key)) {
         der = guard.bytes.snapshot(key, E, "bad-input", "the signer private key");
         owned = true;
       } else if (typeof key === "string") {
@@ -18047,12 +18179,12 @@ var require_sign_scheme = __commonJS({
     function signOverTbs(scheme, key, signedBytes, E) {
       if (scheme.composite) {
         return compositeSig.compositeSign(scheme.composite, _normCompositeKeys(key, scheme.composite, E), signedBytes).then(function(sig) {
-          return Buffer.from(sig);
+          return _bufferFrom(sig);
         });
       }
       return _importKey(key, scheme.imp, E).then(function(priv) {
         return subtle.sign(scheme.sign, priv, signedBytes).then(function(sigRaw) {
-          var sig = Buffer.from(sigRaw);
+          var sig = _bufferFrom(sigRaw);
           if (scheme.ecdsaDer) sig = validator.sig.rawToEcdsaDer(sig, scheme.coordLen);
           return sig;
         });
@@ -18063,6 +18195,7 @@ var require_sign_scheme = __commonJS({
       pssSpkiPinnedHash,
       signOverTbs,
       MLDSA_SUITABLE_DIGEST,
+      mldsaDigestSuitable,
       SLHDSA_BY_OID
     };
   }
@@ -18124,6 +18257,8 @@ var require_pki_build = __commonJS({
     var schema = require_schema_engine();
     var compositeSig = require_composite_sig();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _isArray = intrinsic.isArray;
     var oid = require_oid();
     var ipUtils = require_ip_utils();
     var nodeCrypto = require("crypto");
@@ -18193,7 +18328,7 @@ var require_pki_build = __commonJS({
           return spec;
         }
         if (typeof spec === "string") spec = [{ commonName: spec }];
-        if (!Array.isArray(spec)) throw E("bad-name", "a name must be a string, an array of RDNs, or raw Name DER");
+        if (!_isArray(spec)) throw E("bad-name", "a name must be a string, an array of RDNs, or raw Name DER");
         return b.sequence(spec.map(encodeRdn));
       }
       function assertValidNameDer(der) {
@@ -18264,7 +18399,7 @@ var require_pki_build = __commonJS({
         }
       }
       function extKeyUsage(names) {
-        if (!Array.isArray(names) || !names.length) throw E("bad-input", "keyUsage must assert at least one bit (RFC 5280 sec. 4.2.1.3)");
+        if (!_isArray(names) || !names.length) throw E("bad-input", "keyUsage must assert at least one bit (RFC 5280 sec. 4.2.1.3)");
         var positions = names.map(function(n) {
           var pos = KU_BIT[n];
           if (pos == null) throw E("bad-input", "unknown keyUsage bit " + JSON.stringify(n));
@@ -18286,7 +18421,7 @@ var require_pki_build = __commonJS({
         throw E("bad-input", "unknown " + label + " " + JSON.stringify(n) + " (expected a registered name or a dotted-decimal OID)");
       }
       function extExtKeyUsage(names) {
-        if (!Array.isArray(names) || !names.length) throw E("bad-input", "extendedKeyUsage must list at least one KeyPurposeId");
+        if (!_isArray(names) || !names.length) throw E("bad-input", "extendedKeyUsage must list at least one KeyPurposeId");
         return b.sequence(names.map(function(n) {
           return b.oid(_resolveOid(n, "extendedKeyUsage purpose"));
         }));
@@ -18314,7 +18449,7 @@ var require_pki_build = __commonJS({
         return b.sequence([b.contextPrimitive(0, keyid)]);
       }
       function encodeGeneralNames(entries, implicitTag) {
-        if (!Array.isArray(entries) || !entries.length) throw E("bad-input", "a GeneralNames must carry at least one GeneralName");
+        if (!_isArray(entries) || !entries.length) throw E("bad-input", "a GeneralNames must carry at least one GeneralName");
         var members = entries.map(encodeGeneralName);
         if (implicitTag == null) return b.sequence(members);
         return b.contextConstructed(implicitTag, Buffer.concat(members));
@@ -18323,7 +18458,7 @@ var require_pki_build = __commonJS({
         return encodeGeneralNames(entries);
       }
       function extCertPolicies(names) {
-        if (!Array.isArray(names) || !names.length) throw E("bad-input", "certificatePolicies must list at least one policy OID");
+        if (!_isArray(names) || !names.length) throw E("bad-input", "certificatePolicies must list at least one policy OID");
         var seen = {};
         return b.sequence(names.map(function(n) {
           var pOid = _resolveOid(n, "certificate policy");
@@ -18404,7 +18539,7 @@ var require_pki_build = __commonJS({
       };
       function requestedExtensions(extSpec, spki) {
         var EXT_DECODERS = ctx.EXT_DECODERS;
-        if (Array.isArray(extSpec)) {
+        if (_isArray(extSpec)) {
           if (!extSpec.length) throw E("bad-input", "the requested extensions list must carry at least one extension");
           var seen = {};
           return b.sequence(extSpec.map(function(e, i) {
@@ -19161,6 +19296,8 @@ var require_cmp_build = __commonJS({
     var CRMF_BODY = { ir: 1, cr: 1, kur: 1 };
     var CERT_REP_ARM = { ip: 1, cp: 1, kup: 1, ccp: 1 };
     var KNOWN_OPTS_KEYS = { key: 1, cert: 1, mac: 1, extraCerts: 1, pem: 1, pss: 1, digestAlgorithm: 1 };
+    var KNOWN_OPTS_SIG_KEYS = { key: 1, cert: 1, extraCerts: 1, pem: 1, pss: 1, digestAlgorithm: 1 };
+    var KNOWN_OPTS_MAC_KEYS = { mac: 1, extraCerts: 1, pem: 1 };
     var KNOWN_MESSAGE_KEYS = { header: 1, body: 1 };
     var KNOWN_MAC_KEYS = { secret: 1, salt: 1, iterationCount: 1, prf: 1, keyLength: 1, algorithm: 1 };
     var PBMAC1_DEFAULT_ITER = 1e5;
@@ -19615,7 +19752,16 @@ var require_cmp_build = __commonJS({
       guard.identifier.assertKnownKeys(message, KNOWN_MESSAGE_KEYS, _err, "cmp/bad-input", function(k) {
         return "unknown message field " + JSON.stringify(k) + " (a message carries only header + body)";
       });
-      guard.identifier.assertKnownKeys(opts, KNOWN_OPTS_KEYS, _err, "cmp/bad-input", "unknown opts field ");
+      var sigForm = opts.key != null || opts.cert != null, macForm = opts.mac != null;
+      guard.identifier.assertKnownKeys(
+        opts,
+        sigForm === macForm ? KNOWN_OPTS_KEYS : sigForm ? KNOWN_OPTS_SIG_KEYS : KNOWN_OPTS_MAC_KEYS,
+        _err,
+        "cmp/bad-input",
+        function(k) {
+          return "unknown opts field " + JSON.stringify(k) + (macForm && (k === "pss" || k === "digestAlgorithm") ? " for MAC protection; the signature parameters are read only by the { key, cert } form" : "");
+        }
+      );
       if (message.header == null) throw _err("cmp/bad-input", "message.header is required");
       if (message.body == null) throw _err("cmp/bad-input", "message.body is required");
       var prot = _resolveProtection(opts);
@@ -20428,6 +20574,7 @@ var require_cms_sign = __commonJS({
     var webcrypto = require_webcrypto();
     var signScheme = require_sign_scheme();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
     var pkiBuild = require_pki_build();
     var cms = require_schema_cms();
     var subtle = webcrypto.webcrypto.subtle;
@@ -20453,6 +20600,8 @@ var require_cms_sign = __commonJS({
       certificates: 1,
       pem: 1
     };
+    var KNOWN_SIGNER_CERT_KEYS = { cert: 1, key: 1, pss: 1, digestAlgorithm: 1, combinedRsaSig: 1 };
+    var KNOWN_SIGNER_KEY_ONLY_KEYS = { spki: 1, keyIdentifier: 1, key: 1, pss: 1, digestAlgorithm: 1, combinedRsaSig: 1 };
     var KNOWN_COUNTERSIGN_OPTS = {
       signerIndex: 1,
       countersignatureOf: 1,
@@ -20507,7 +20656,7 @@ var require_cms_sign = __commonJS({
     function _buildSignedAttrs(pairs) {
       var seenTypes = {};
       var attrs = pairs.map(function(p) {
-        if (guard.intrinsic.hasOwn(seenTypes, p.type)) throw _err("cms/bad-input", "signedAttrs must not repeat an attribute type (RFC 5652 sec. 5.3): " + p.type);
+        if (intrinsic.hasOwn(seenTypes, p.type)) throw _err("cms/bad-input", "signedAttrs must not repeat an attribute type (RFC 5652 sec. 5.3): " + p.type);
         seenTypes[p.type] = 1;
         return b.sequence([b.oid(p.type), b.set(p.values)]);
       });
@@ -20536,8 +20685,8 @@ var require_cms_sign = __commonJS({
       var pairs = _resolveAttrPairs(list, "an unsigned attribute value");
       var seen = {};
       pairs.forEach(function(p) {
-        if (guard.intrinsic.hasOwn(UNSIGNED_FORBIDDEN, p.type)) throw _err("cms/bad-input", "the " + UNSIGNED_FORBIDDEN[p.type] + " attribute must not appear as an unsigned attribute (RFC 5652 sec. 11)");
-        if (guard.intrinsic.hasOwn(seen, p.type)) throw _err("cms/bad-input", "unsignedAttrs must not repeat an attribute type (RFC 5652 sec. 5.3): " + p.type);
+        if (intrinsic.hasOwn(UNSIGNED_FORBIDDEN, p.type)) throw _err("cms/bad-input", "the " + UNSIGNED_FORBIDDEN[p.type] + " attribute must not appear as an unsigned attribute (RFC 5652 sec. 11)");
+        if (intrinsic.hasOwn(seen, p.type)) throw _err("cms/bad-input", "unsignedAttrs must not repeat an attribute type (RFC 5652 sec. 5.3): " + p.type);
         seen[p.type] = 1;
       });
       var setOf = b.set(pairs.map(function(p) {
@@ -20924,7 +21073,14 @@ var require_cms_sign = __commonJS({
         return opts.pem ? pkix.pemEncode(newCi, "CMS", frameworkError.PemError) : newCi;
       });
     }
-    module2.exports = { sign, countersign };
+    module2.exports = {
+      sign,
+      countersign,
+      // @internal -- the signer-descriptor field tables, for a verb that AUTHORS signer descriptors
+      // from its own caller's options and gates them at its own door.
+      KNOWN_SIGNER_CERT_KEYS,
+      KNOWN_SIGNER_KEY_ONLY_KEYS
+    };
   }
 });
 
@@ -20940,6 +21096,7 @@ var require_cms_encrypt = __commonJS({
     var webcrypto = require_webcrypto();
     var frameworkError = require_framework_error();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
     var pbes2 = require_pbes2();
     var b = asn1.build;
     var subtle = webcrypto.webcrypto.subtle;
@@ -21213,22 +21370,64 @@ var require_cms_encrypt = __commonJS({
       if (!PRF_HASH[prf]) throw _err("cms/bad-input", "unsupported pwri prf " + JSON.stringify(prf));
       return PRF_HASH[prf];
     }
-    async function _buildRecipient(cek, desc, opts) {
+    var _PWRI_KEYS = { password: 1, iterations: 1, prf: 1, salt: 1 };
+    var _KEKRI_KEYS = { kek: 1, kekId: 1 };
+    var _KTRI_RECIPIENT_KEYS = { cert: 1, oaepHash: 1, keyIdentifier: 1 };
+    var _AGREE_RECIPIENT_KEYS = { cert: 1, keyIdentifier: 1, ukm: 1 };
+    var _RECIPIENT_DEFAULTS = ["oaepHash", "keyIdentifier", "ukm"];
+    function _assertRecipientKeys(desc, known, arm) {
+      guard.identifier.assertKnownKeys(desc, known, _err, "cms/bad-input", function(k) {
+        return "unknown field " + JSON.stringify(k) + " on a " + arm + " recipient; that field is not read for this recipient type";
+      });
+    }
+    function _assertDefaultsConsumed(opts, consumed) {
+      for (var i = 0; i < _RECIPIENT_DEFAULTS.length; i++) {
+        var name = _RECIPIENT_DEFAULTS[i];
+        if (opts[name] != null && !consumed[name]) {
+          throw _err("cms/bad-input", "opts." + name + " is a per-recipient default and no recipient of this message reads it" + (name === "oaepHash" ? " (only an RSA certificate recipient does)" : name === "ukm" ? " (only a key-agreement or KEM certificate recipient does)" : " (only a certificate recipient does)"));
+        }
+      }
+    }
+    async function _buildRecipient(cek, desc, opts, consumed) {
       if (desc == null || typeof desc !== "object") throw _err("cms/bad-input", "each recipient must be a descriptor object");
-      if (desc.password != null) return _buildPwri(cek, desc);
-      if (desc.kek != null) return _buildKekri(cek, desc);
+      if (desc.password != null) {
+        _assertRecipientKeys(desc, _PWRI_KEYS, "password");
+        return _buildPwri(cek, desc);
+      }
+      if (desc.kek != null) {
+        _assertRecipientKeys(desc, _KEKRI_KEYS, "KEK");
+        return _buildKekri(cek, desc);
+      }
       if (desc.cert != null) {
         var cert = x509.parse(_normCertDer(desc.cert, "a recipient certificate"));
         var keyOid = cert.subjectPublicKeyInfo.algorithm.oid;
-        if (keyOid === O("rsaEncryption") || keyOid === O("rsassaPss")) return _buildKtri(cek, cert, mergeOpts(opts, desc));
-        if (keyOid === O("ecPublicKey") || MONT_KA[keyOid]) return _buildKari(cek, cert, mergeOpts(opts, desc));
-        if (KEM_WC[keyOid]) return _buildKemri(cek, cert, mergeOpts(opts, desc));
+        if (keyOid === O("rsaEncryption") || keyOid === O("rsassaPss")) {
+          _assertRecipientKeys(desc, _KTRI_RECIPIENT_KEYS, "RSA certificate");
+          return _buildKtri(cek, cert, mergeOpts(opts, desc, _KTRI_RECIPIENT_KEYS, consumed));
+        }
+        if (keyOid === O("ecPublicKey") || MONT_KA[keyOid]) {
+          _assertRecipientKeys(desc, _AGREE_RECIPIENT_KEYS, "key-agreement certificate");
+          return _buildKari(cek, cert, mergeOpts(opts, desc, _AGREE_RECIPIENT_KEYS, consumed));
+        }
+        if (KEM_WC[keyOid]) {
+          _assertRecipientKeys(desc, _AGREE_RECIPIENT_KEYS, "KEM certificate");
+          return _buildKemri(cek, cert, mergeOpts(opts, desc, _AGREE_RECIPIENT_KEYS, consumed));
+        }
         throw _err("cms/unsupported-algorithm", "unsupported recipient certificate key algorithm " + keyOid);
       }
       throw _err("cms/bad-input", "a recipient needs { cert }, { password }, or { kek, kekId }");
     }
-    function mergeOpts(opts, desc) {
-      return { oaepHash: desc.oaepHash || opts.oaepHash, keyIdentifier: desc.keyIdentifier || opts.keyIdentifier, ukm: desc.ukm != null ? desc.ukm : opts.ukm };
+    function _pickDefault(desc, opts, name, known, consumed, nullish) {
+      var supplied = desc[name], fromDesc = nullish ? supplied != null : !!supplied;
+      if (!fromDesc && known[name] && consumed && opts[name] != null) consumed[name] = 1;
+      return fromDesc ? supplied : opts[name];
+    }
+    function mergeOpts(opts, desc, known, consumed) {
+      return {
+        oaepHash: _pickDefault(desc, opts, "oaepHash", known, consumed, false),
+        keyIdentifier: _pickDefault(desc, opts, "keyIdentifier", known, consumed, false),
+        ukm: _pickDefault(desc, opts, "ukm", known, consumed, true)
+      };
     }
     function _taggedRecipient(r) {
       if (r.tag == null) return r.node;
@@ -21244,19 +21443,67 @@ var require_cms_encrypt = __commonJS({
       });
       return forcesTwo ? 2 : 0;
     }
+    var _ENCRYPT_OPTS_AEAD = {
+      contentEncryptionAlgorithm: 1,
+      contentType: 1,
+      authAttrs: 1,
+      oaepHash: 1,
+      keyIdentifier: 1,
+      ukm: 1,
+      pem: 1
+    };
+    var _ENCRYPT_OPTS_CBC = {
+      contentEncryptionAlgorithm: 1,
+      contentType: 1,
+      oaepHash: 1,
+      keyIdentifier: 1,
+      ukm: 1,
+      pem: 1
+    };
+    var _AUTHENTICATE_OPTS_ATTRS = {
+      macAlgorithm: 1,
+      digestAlgorithm: 1,
+      authenticatedAttributes: 1,
+      authAttrs: 1,
+      contentType: 1,
+      keyIdentifier: 1,
+      oaepHash: 1,
+      ukm: 1,
+      pem: 1
+    };
+    var _AUTHENTICATE_OPTS_BARE = {
+      macAlgorithm: 1,
+      authenticatedAttributes: 1,
+      contentType: 1,
+      keyIdentifier: 1,
+      oaepHash: 1,
+      ukm: 1,
+      pem: 1
+    };
     async function encrypt(content, recipients, opts) {
       opts = opts || {};
-      var contentBytes = guard.bytes.view(content, CmsError, "cms/bad-input", "content");
       var algName = opts.contentEncryptionAlgorithm || "aes-256-gcm";
       var ca = CONTENT_ALGS[algName];
       if (!ca) throw _err("cms/bad-input", "unsupported contentEncryptionAlgorithm " + JSON.stringify(algName));
+      guard.identifier.assertKnownKeys(
+        opts,
+        ca.aead ? _ENCRYPT_OPTS_AEAD : _ENCRYPT_OPTS_CBC,
+        _err,
+        "cms/bad-input",
+        function(k) {
+          return "pki.cms.encrypt has an unknown option " + JSON.stringify(k) + (!ca.aead && k === "authAttrs" ? " for a CBC content algorithm; authenticated attributes are carried only by an AuthEnvelopedData, which an AEAD algorithm produces" : "");
+        }
+      );
+      var contentBytes = guard.bytes.view(content, CmsError, "cms/bad-input", "content");
       var contentType = opts.contentType || "data";
       var cek = nodeCrypto.randomBytes(ca.keyBits / 8);
       try {
         if (!Array.isArray(recipients)) return _encryptedData(contentBytes, recipients, ca, contentType, opts, cek);
         if (!recipients.length) throw _err("cms/bad-input", "at least one recipient is required (RFC 5652 sec. 6.1)");
         var recips = [];
-        for (var i = 0; i < recipients.length; i++) recips.push(await _buildRecipient(cek, recipients[i], opts));
+        var consumed = {};
+        for (var i = 0; i < recipients.length; i++) recips.push(await _buildRecipient(cek, recipients[i], opts, consumed));
+        _assertDefaultsConsumed(opts, consumed);
         var riNodes = recips.map(_taggedRecipient);
         if (ca.aead) return _emit(_authEnvelopedData(contentBytes, cek, ca, contentType, opts, riNodes, recips), "authEnvelopedData", opts);
         return _emit(_envelopedData(contentBytes, cek, ca, contentType, riNodes, recips), "envelopedData", opts);
@@ -21292,7 +21539,7 @@ var require_cms_encrypt = __commonJS({
         } catch (e) {
           throw _err("cms/bad-input", "an authenticated attribute type is not an OBJECT IDENTIFIER", e);
         }
-        if (guard.intrinsic.hasOwn(seenTypes, t)) throw _err("cms/bad-input", "authenticated attributes must not repeat an attribute type (RFC 5652): " + t);
+        if (intrinsic.hasOwn(seenTypes, t)) throw _err("cms/bad-input", "authenticated attributes must not repeat an attribute type (RFC 5652): " + t);
         seenTypes[t] = 1;
         if (forbidden && t === forbidden.oid) throw _err("cms/bad-input", forbidden.why);
       });
@@ -21321,8 +21568,18 @@ var require_cms_encrypt = __commonJS({
       void recips;
       return b.sequence(kids);
     }
+    var _ENCRYPTED_DATA_CEK_KEYS = { cek: 1 };
+    var _ENCRYPTED_DATA_PW_KEYS = { password: 1, iterations: 1, salt: 1, prf: 1 };
     function _encryptedData(contentBytes, desc, ca, contentType, opts, cek) {
       if (ca.aead) throw _err("cms/bad-input", "EncryptedData supports only CBC content encryption");
+      _assertDefaultsConsumed(opts, {});
+      if (desc != null && typeof desc === "object") {
+        var edKeys = desc.cek != null ? _ENCRYPTED_DATA_CEK_KEYS : _ENCRYPTED_DATA_PW_KEYS;
+        var edArm = desc.cek != null ? "cek" : "password";
+        guard.identifier.assertKnownKeys(desc, edKeys, _err, "cms/bad-input", function(k) {
+          return "unknown field " + JSON.stringify(k) + " on a " + edArm + " EncryptedData descriptor; that field is not read for this arm";
+        });
+      }
       var iv = nodeCrypto.randomBytes(16);
       var contentAlgNode, encKey;
       if (desc && desc.cek != null) {
@@ -21352,7 +21609,7 @@ var require_cms_encrypt = __commonJS({
         var contentAlg = pbes2.pbes2AlgId(salt, iterations, prf, ca.oid, iv);
         var eci = b.sequence([b.oid(O(contentType)), contentAlg, b.contextPrimitive(0, enc)]);
         var inner = b.sequence([b.integer(0n), eci]);
-        return _emit(inner, "encryptedData", { pem: opts && opts.pem != null ? opts.pem : desc.pem });
+        return _emit(inner, "encryptedData", opts);
       } finally {
         guard.secret.zeroize(key, CmsError, "cms/bad-input", "the password-derived content-encryption key");
       }
@@ -21377,22 +21634,33 @@ var require_cms_encrypt = __commonJS({
     var SUPPORTED_DIGEST = { sha256: 1, sha384: 1, sha512: 1 };
     async function authenticate(content, recipients, opts) {
       opts = opts || {};
+      var withAttrs = opts.authenticatedAttributes !== false;
+      guard.identifier.assertKnownKeys(
+        opts,
+        withAttrs ? _AUTHENTICATE_OPTS_ATTRS : _AUTHENTICATE_OPTS_BARE,
+        _err,
+        "cms/bad-input",
+        function(k) {
+          return "pki.cms.authenticate has an unknown option " + JSON.stringify(k) + (!withAttrs && (k === "digestAlgorithm" || k === "authAttrs") ? " with authenticatedAttributes: false; the MAC then covers the content octets directly and no attribute set is built" : "");
+        }
+      );
       var contentBytes = guard.bytes.view(content, CmsError, "cms/bad-input", "content");
       var macName = opts.macAlgorithm || "hmac-sha256";
       var mac = MAC_ALGS[macName];
       if (!mac) throw _err("cms/bad-input", "unsupported macAlgorithm " + JSON.stringify(macName) + " (hmac-sha256/384/512)");
       if (!Array.isArray(recipients) || !recipients.length) throw _err("cms/bad-input", "at least one recipient is required (RFC 5652 sec. 9.1)");
       var contentType = opts.contentType || "data";
-      var withAttrs = opts.authenticatedAttributes !== false;
       if (contentType !== "data" && !withAttrs) throw _err("cms/bad-input", "AuthenticatedData with a non-data contentType requires authenticated attributes (RFC 5652 sec. 9.1)");
       var macKey = nodeCrypto.randomBytes(MAC_KEY_OCTETS);
       try {
         var recips = [];
-        for (var i = 0; i < recipients.length; i++) recips.push(await _buildRecipient(macKey, recipients[i], opts));
+        var consumedAuth = {};
+        for (var i = 0; i < recipients.length; i++) recips.push(await _buildRecipient(macKey, recipients[i], opts, consumedAuth));
+        _assertDefaultsConsumed(opts, consumedAuth);
         var riNodes = recips.map(_taggedRecipient);
-        var digestName = opts.digestAlgorithm || mac.node;
         var digestAlgTagged = null, authAttrsDer = null, preimage;
         if (withAttrs) {
+          var digestName = opts.digestAlgorithm || mac.node;
           if (!SUPPORTED_DIGEST[digestName]) throw _err("cms/bad-input", "unsupported digestAlgorithm " + JSON.stringify(digestName) + " (sha256/384/512)");
           var mdDigest = nodeCrypto.createHash(digestName).update(contentBytes).digest();
           var pairs = [
@@ -21444,6 +21712,7 @@ var require_cms_decrypt = __commonJS({
     var webcrypto = require_webcrypto();
     var frameworkError = require_framework_error();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
     var pbes2 = require_pbes2();
     var b = asn1.build;
     var subtle = webcrypto.webcrypto.subtle;
@@ -21746,8 +22015,8 @@ var require_cms_decrypt = __commonJS({
     }
     function _assertContentCipherMode(eci, ct) {
       var oidStr = eci.contentEncryptionAlgorithm.oid;
-      var isAead = guard.intrinsic.hasOwn(AEAD_ALGS, oidStr);
-      if (!isAead && !guard.intrinsic.hasOwn(CONTENT_MODE, oidStr)) return;
+      var isAead = intrinsic.hasOwn(AEAD_ALGS, oidStr);
+      if (!isAead && !intrinsic.hasOwn(CONTENT_MODE, oidStr)) return;
       if (ct === "authEnvelopedData") {
         if (isAead) return;
         throw _err("cms/unsupported-algorithm", "contentEncryptionAlgorithm " + oidStr + " is not an authenticated encryption algorithm, which authEnvelopedData requires (RFC 5083 sec. 2)");
@@ -21757,9 +22026,9 @@ var require_cms_decrypt = __commonJS({
     }
     async function _openContent(parsed, eci, cek, ct) {
       var alg = eci.contentEncryptionAlgorithm;
-      var keyBits = guard.intrinsic.hasOwn(CONTENT_KEYBITS, alg.oid) ? CONTENT_KEYBITS[alg.oid] : 0;
+      var keyBits = intrinsic.hasOwn(CONTENT_KEYBITS, alg.oid) ? CONTENT_KEYBITS[alg.oid] : 0;
       if (!keyBits) {
-        if (guard.intrinsic.hasOwn(AEAD_ALGS, alg.oid) && AEAD_ALGS[alg.oid] === "ccm") {
+        if (intrinsic.hasOwn(AEAD_ALGS, alg.oid) && AEAD_ALGS[alg.oid] === "ccm") {
           throw _err("cms/unsupported-algorithm", "contentEncryptionAlgorithm " + alg.oid + " is AES-CCM. RFC 5084 sec. 3.1 permits it for this content type; this toolkit implements AES-GCM only for content encryption");
         }
         throw _err("cms/unsupported-algorithm", "unsupported contentEncryptionAlgorithm " + alg.oid);
@@ -22192,11 +22461,12 @@ var require_cms_verify = __commonJS({
     var cmsDecrypt = require_cms_decrypt();
     var cmsCompress = require_cms_compress();
     var signScheme = require_sign_scheme();
-    var MLDSA_SUITABLE_DIGEST = signScheme.MLDSA_SUITABLE_DIGEST;
+    var _mldsaDigestSuitable = signScheme.mldsaDigestSuitable;
     var SLHDSA_BY_OID = signScheme.SLHDSA_BY_OID;
     var validator = require_validator_all();
     var compositeSig = require_composite_sig();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
     var frameworkError = require_framework_error();
     var pkix = require_schema_pkix();
     var CmsError = frameworkError.CmsError;
@@ -22216,7 +22486,7 @@ var require_cms_verify = __commonJS({
     };
     var SIG_HASH = { sha1: "SHA-1", sha256: "SHA-256", sha384: "SHA-384", sha512: "SHA-512" };
     function _supportedDigest(name) {
-      return !!DIGEST_HASH[name];
+      return intrinsic.hasOwn(DIGEST_HASH, name) && !!DIGEST_HASH[name];
     }
     function _computeDigest(name, content) {
       return subtle.digest(DIGEST_HASH[name], content).then(function(d) {
@@ -22454,7 +22724,7 @@ var require_cms_verify = __commonJS({
       if ((scheme.kind === "mldsa" || scheme.kind === "slhdsa") && si.signedAttrsBytes && (si.digestAlgorithm.name === "shake128" || si.digestAlgorithm.name === "shake256") && dp !== null && dp !== void 0) return Promise.resolve({ ok: false, code: "cms/unsupported-algorithm", sid: si.sid, message: "a SHAKE digestAlgorithm carries no parameters (RFC 8702 sec. 3.1)" });
       var sigHash = pss ? pss.hash : scheme.hash || digestHash;
       if (scheme.kind !== "eddsa" && scheme.kind !== "mldsa" && scheme.kind !== "slhdsa" && !sigHash || si.signedAttrsBytes && !_supportedDigest(si.digestAlgorithm.name)) return Promise.resolve({ ok: false, code: "cms/unsupported-algorithm", sid: si.sid, message: "unsupported digest algorithm " + JSON.stringify(si.digestAlgorithm.name) });
-      if (scheme.kind === "mldsa" && si.signedAttrsBytes && !MLDSA_SUITABLE_DIGEST[scheme.name][si.digestAlgorithm.name]) return Promise.resolve({ ok: false, code: "cms/unsupported-algorithm", sid: si.sid, message: "the " + si.digestAlgorithm.name + " message digest is below the security strength of " + scheme.name + " (RFC 9882 sec. 3.3)" });
+      if (scheme.kind === "mldsa" && si.signedAttrsBytes && !_mldsaDigestSuitable(scheme.name, si.digestAlgorithm.name)) return Promise.resolve({ ok: false, code: "cms/unsupported-algorithm", sid: si.sid, message: "the " + si.digestAlgorithm.name + " message digest is below the security strength of " + scheme.name + " (RFC 9882 sec. 3.3)" });
       if (scheme.kind === "slhdsa" && si.signedAttrsBytes && si.digestAlgorithm.name !== scheme.digest) return Promise.resolve({ ok: false, code: "cms/unsupported-algorithm", sid: si.sid, message: "SLH-DSA " + scheme.name + " requires the " + scheme.digest + " message digest (RFC 9814 sec. 4)" });
       var signers = _findSignerCerts(si.sid, parsedCerts);
       if (!signers.length) return Promise.resolve({ ok: false, code: "cms/signer-cert-not-found", sid: si.sid, message: "no certificate matches this SignerInfo's signer identifier" });
@@ -22666,7 +22936,9 @@ var require_cms_verify = __commonJS({
         });
       })).then(function(signers) {
         var res = {
-          valid: signers.length > 0 && signers.every(function(s) {
+          // Signature soundness is decided by comparison for the same reason the trust verdict below
+          // is: `every` replaced after load reports the whole set sound without reading one signer.
+          valid: signers.length > 0 && guard.list.allMatch(signers, function(s) {
             return s.ok === true;
           }),
           eContentType: parsed.encapContentInfo.eContentType,
@@ -22696,7 +22968,7 @@ var require_cms_verify = __commonJS({
       });
       var out = {}, k;
       for (k in v) {
-        if (!Object.prototype.hasOwnProperty.call(v, k)) continue;
+        if (!intrinsic.hasOwn(v, k)) continue;
         out[k] = _cloneAnchorValue(v[k], depth + 1);
       }
       return out;
@@ -22736,6 +23008,11 @@ var require_cms_verify = __commonJS({
       }
       return true;
     }
+    function _allTrusted(signers) {
+      return guard.list.allMatch(signers, function(s) {
+        return s.trusted === true;
+      });
+    }
     function _applyTrust(res, parsedCerts, cfg) {
       res.trusted = false;
       res.signers.forEach(function(s) {
@@ -22780,9 +23057,7 @@ var require_cms_verify = __commonJS({
           });
         });
       }, Promise.resolve()).then(function() {
-        res.trusted = res.valid && res.signers.length > 0 && res.signers.every(function(s) {
-          return s.trusted === true;
-        });
+        res.trusted = res.valid && res.signers.length > 0 && _allTrusted(res.signers);
       });
     }
     function _addCert(out, der) {
@@ -23688,6 +23963,7 @@ var require_path_validate = __commonJS({
     var cmsVerify = require_cms_verify();
     var cmpSession = require_cmp_session();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
     var constants = require_constants();
     var validator = require_validator_all();
     var cms = require_schema_cms();
@@ -23702,6 +23978,13 @@ var require_path_validate = __commonJS({
     function pathCode(e, fallback) {
       return e && typeof e.code === "string" && e.code.indexOf("path/") === 0 ? e.code : fallback;
     }
+    var contains = guard.list.contains;
+    var containsAll = guard.list.containsAll;
+    function mapsAnyPolicy(mappings) {
+      return guard.list.anyMatches(mappings, function(m) {
+        return !!m && (m.issuerDomainPolicy === OID.anyPolicy || m.subjectDomainPolicy === OID.anyPolicy);
+      });
+    }
     var NS = pkix.makeNS("path", PathError, oid);
     var EXT_DECODERS = pkix.certExtensionDecoders(NS).byOid;
     var subtle = webcrypto.webcrypto.subtle;
@@ -24171,7 +24454,7 @@ var require_path_validate = __commonJS({
           return (Buffer.isBuffer(base) || base instanceof Uint8Array) && (base.length === 8 || base.length === 32);
         // iPAddress: address + mask
         case 4:
-          return base !== null && typeof base === "object" && !!base.rdns && Array.isArray(base.rdns);
+          return base !== null && typeof base === "object" && !!base.rdns && intrinsic.isArray(base.rdns);
         // directoryName
         default:
           return base !== void 0;
@@ -24179,7 +24462,7 @@ var require_path_validate = __commonJS({
     }
     function checkedSubtreeSeeds(list, optName) {
       if (list === void 0 || list === null) return [];
-      if (!Array.isArray(list)) throw E("path/bad-input", "validate: opts." + optName + " must be an array of { tag, base } subtree entries");
+      if (!intrinsic.isArray(list)) throw E("path/bad-input", "validate: opts." + optName + " must be an array of { tag, base } subtree entries");
       return list.map(function(st) {
         if (!st || typeof st !== "object" || !Number.isInteger(st.tag) || st.tag < 0 || st.tag > 8 || !isSubtreeBaseValid(st.tag, st.base)) {
           throw E("path/bad-input", "validate: opts." + optName + " entries must be { tag: <GeneralName tag number 0..8>, base: <that form's constraint value> }");
@@ -24238,7 +24521,7 @@ var require_path_validate = __commonJS({
           }
           var matched = false;
           leavesAt(state.validPolicyTree, depth).forEach(function(node) {
-            if (node.expectedPolicySet.indexOf(p.policyIdentifier) !== -1) {
+            if (contains(node.expectedPolicySet, p.policyIdentifier)) {
               addChild(state, node, p.policyIdentifier, p.qualifiersBytes, [p.policyIdentifier], checks);
               matched = true;
             }
@@ -24252,7 +24535,7 @@ var require_path_validate = __commonJS({
         if (anyPolicyPresent && anyPolicyActive) {
           leavesAt(state.validPolicyTree, depth).forEach(function(node) {
             node.expectedPolicySet.forEach(function(ep) {
-              var already = node.children.some(function(ch) {
+              var already = guard.list.anyMatches(node.children, function(ch) {
                 return ch.validPolicy === ep;
               });
               if (!already) addChild(state, node, ep, anyPolicyQualifiers, [ep], checks);
@@ -24314,9 +24597,7 @@ var require_path_validate = __commonJS({
       }
       if (!eku) return false;
       var purposes = eku.value;
-      var ok = purposes.indexOf(OID.anyExtendedKeyUsage) !== -1 || requiredEku.every(function(p) {
-        return purposes.indexOf(p) !== -1;
-      });
+      var ok = contains(purposes, OID.anyExtendedKeyUsage) || containsAll(purposes, requiredEku);
       checks.push({ name: "extendedKeyUsage", ok, code: ok ? void 0 : "path/eku-not-permitted" });
       return !ok;
     }
@@ -24333,9 +24614,7 @@ var require_path_validate = __commonJS({
         return { fatal: true, error: e };
       }
       if (pm) {
-        var badAny = pm.value.some(function(m) {
-          return m.issuerDomainPolicy === OID.anyPolicy || m.subjectDomainPolicy === OID.anyPolicy;
-        });
+        var badAny = mapsAnyPolicy(pm.value);
         if (badAny) {
           checks.push({ name: "policyMappings", ok: false, code: "path/bad-policy" });
           return { fatal: true, error: E("path/bad-policy", "policyMappings must not map to or from anyPolicy (RFC 5280 6.1.4(a))") };
@@ -24464,8 +24743,8 @@ var require_path_validate = __commonJS({
       for (var i = 0; i < cert.extensions.length; i++) {
         var ext = cert.extensions[i];
         if (!ext.critical) continue;
-        if (!PROCESSED_EXTENSIONS[ext.oid]) return ext.oid;
-        if (isTarget && TARGET_UNPROCESSED_IF_CRITICAL[ext.oid]) return ext.oid;
+        if (!intrinsic.hasOwn(PROCESSED_EXTENSIONS, ext.oid)) return ext.oid;
+        if (isTarget && intrinsic.hasOwn(TARGET_UNPROCESSED_IF_CRITICAL, ext.oid)) return ext.oid;
       }
       return null;
     }
@@ -24511,7 +24790,7 @@ var require_path_validate = __commonJS({
         "path/bad-input",
         "pki.path.validate has an unknown option. The anchor here is `trustAnchor`, singular; pki.path.build takes `trustAnchors`. The unknown option was: "
       );
-      if (!Array.isArray(path)) throw E("path/bad-input", "validate: path must be an array of certificates");
+      if (!intrinsic.isArray(path)) throw E("path/bad-input", "validate: path must be an array of certificates");
       var maxCerts = guard.limits.cap(opts.maxPathCerts, "validate: opts.maxPathCerts", constants.LIMITS.PATH_MAX_CERTS, { E, code: "path/bad-input", min: 1 });
       if (path.length > maxCerts) throw E("path/bad-input", "validate: the certification path has " + path.length + " certificates, exceeding the maxPathCerts limit (" + maxCerts + ")");
       var certs = path.map(function(c, ci) {
@@ -24523,7 +24802,7 @@ var require_path_validate = __commonJS({
       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) {
-        var uipsOk = Array.isArray(opts.userInitialPolicySet) && opts.userInitialPolicySet.length > 0 && opts.userInitialPolicySet.every(function(p) {
+        var uipsOk = intrinsic.isArray(opts.userInitialPolicySet) && opts.userInitialPolicySet.length > 0 && guard.list.allMatch(opts.userInitialPolicySet, function(p) {
           return typeof p === "string" && p.length > 0;
         });
         if (!uipsOk) throw E("path/bad-input", "validate: opts.userInitialPolicySet must be a non-empty array of policy OID strings");
@@ -24682,9 +24961,7 @@ var require_path_validate = __commonJS({
             checks.push({ name: "policyMappings", ok: false, code: "path/bad-policy" });
             failed = true;
           }
-          if (lpm && lpm.value.some(function(m) {
-            return m.issuerDomainPolicy === OID.anyPolicy || m.subjectDomainPolicy === OID.anyPolicy;
-          })) {
+          if (lpm && mapsAnyPolicy(lpm.value)) {
             checks.push({ name: "policyMappings", ok: false, code: "path/bad-policy" });
             failed = true;
           }
@@ -24718,7 +24995,7 @@ var require_path_validate = __commonJS({
           }
           if (checkPurpose && ta.purposes) {
             anchorPurposeApplied = true;
-            if (ta.purposes[checkPurpose] !== true) {
+            if (!intrinsic.hasOwn(ta.purposes, checkPurpose) || ta.purposes[checkPurpose] !== true) {
               checks.push({ name: "purposeTrust", ok: false, code: "path/purpose-not-trusted" });
               failed = true;
             }
@@ -24741,7 +25018,7 @@ var require_path_validate = __commonJS({
       var policyOk = state.explicitPolicy > 0 || ucps.length > 0;
       if (!policyOk) {
         var last = state.results[state.results.length - 1];
-        if (!last.checks.some(function(c) {
+        if (!guard.list.anyMatches(last.checks, function(c) {
           return c.code === "path/policy-required";
         })) {
           last.checks.push({ name: "policy", ok: false, code: "path/policy-required" });
@@ -24776,7 +25053,7 @@ var require_path_validate = __commonJS({
     function userConstrainedPolicies(state, n) {
       if (!state.validPolicyTree) return [];
       var uips = state.userInitialPolicySet;
-      var anyUser = uips.indexOf(OID.anyPolicy) !== -1;
+      var anyUser = contains(uips, OID.anyPolicy);
       var leaves = leavesAt(state.validPolicyTree, n);
       var explicit = {}, hasAnyLeaf = false;
       leaves.forEach(function(node) {
@@ -24785,7 +25062,7 @@ var require_path_validate = __commonJS({
       });
       var set = {};
       Object.keys(explicit).forEach(function(p) {
-        if (anyUser || uips.indexOf(p) !== -1) set[p] = true;
+        if (anyUser || contains(uips, p)) set[p] = true;
       });
       if (hasAnyLeaf) {
         if (anyUser) set[OID.anyPolicy] = true;
@@ -25137,7 +25414,7 @@ var require_path_validate = __commonJS({
           }
           for (var dj = 0; dj < classified.deltas.length; dj++) {
             var dRec = classified.deltas[dj];
-            if (consumedDeltas.indexOf(dRec) !== -1) continue;
+            if (contains(consumedDeltas, dRec)) continue;
             if (dRec.accounted) continue;
             if (!await gateCrl(dRec)) continue;
             sawUnmergedDelta = true;
@@ -25229,7 +25506,7 @@ var require_path_validate = __commonJS({
           var historical = ctx.historicalMode === true;
           var issuerNameCandidates = [cert.issuer.bytes];
           function addNameCandidate(nm) {
-            if (nm && nm.bytes && !issuerNameCandidates.some(function(e) {
+            if (nm && nm.bytes && !guard.list.anyMatches(issuerNameCandidates, function(e) {
               return e.equals(nm.bytes);
             })) issuerNameCandidates.push(nm.bytes);
           }
@@ -25311,7 +25588,7 @@ var require_path_validate = __commonJS({
         var issuerCtx = { workingPublicKey: issuerCert.subjectPublicKeyInfo.bytes, workingIssuerName: issuerCert.subject, issuerCert };
         var issuerNameCandidates = [cert.issuer.bytes];
         function add(nm) {
-          if (nm && nm.bytes && !issuerNameCandidates.some(function(e) {
+          if (nm && nm.bytes && !guard.list.anyMatches(issuerNameCandidates, function(e) {
             return e.equals(nm.bytes);
           })) issuerNameCandidates.push(nm.bytes);
         }
@@ -25355,20 +25632,20 @@ var require_path_validate = __commonJS({
     }
     function _hasPurposeScopedMetadata(ta) {
       if (!ta || typeof ta !== "object") return false;
-      return ["distrustAfter", "purposes"].some(function(k) {
+      return guard.list.anyMatches(["distrustAfter", "purposes"], function(k) {
         var m = ta[k];
         return !!m && typeof m === "object" && Object.keys(m).length > 0;
       });
     }
     function assertAnchorConstraints(ta, checkPurpose) {
-      var d = checkPurpose && ta && ta.distrustAfter ? ta.distrustAfter[checkPurpose] : null;
+      var d = checkPurpose && ta && ta.distrustAfter && intrinsic.hasOwn(ta.distrustAfter, checkPurpose) ? ta.distrustAfter[checkPurpose] : null;
       if (d == null) return null;
       return guard.time.assertValid(d, E, "path/bad-input", "trustAnchor.distrustAfter." + checkPurpose);
     }
     function resolvePurposeOpts(opts) {
       var requiredEku = null;
       if (opts.requiredEku !== void 0) {
-        if (!Array.isArray(opts.requiredEku) || opts.requiredEku.length === 0) {
+        if (!intrinsic.isArray(opts.requiredEku) || opts.requiredEku.length === 0) {
           throw E("path/bad-input", "validate: opts.requiredEku must be a non-empty array of key-purpose OID names or dotted OID strings");
         }
         requiredEku = opts.requiredEku.map(function(p) {
@@ -25396,7 +25673,7 @@ var require_path_validate = __commonJS({
     }
     function toAnchor(entry) {
       if (entry && typeof entry === "object" && !Buffer.isBuffer(entry) && entry.name && entry.publicKey && entry.algorithm) {
-        if (!Array.isArray(entry.name.rdns) || !Buffer.isBuffer(entry.publicKey) || typeof entry.algorithm !== "string") {
+        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 }");
         }
         return entry;
@@ -25450,9 +25727,9 @@ var require_path_validate = __commonJS({
         counter.tick();
         n += 1;
         var cand = scored[ci].cand, candKey = identityKey(cand);
-        if (frame.keys.has(candKey)) continue;
+        if (intrinsic.setHas(frame.keys, candKey)) continue;
         var childKeys = new Set(frame.keys);
-        childKeys.add(candKey);
+        intrinsic.setAdd(childKeys, candKey);
         stack.push({ chain: [cand].concat(frame.chain), hop: frame.hop + 1, keys: childKeys });
       }
       return n;
@@ -25509,16 +25786,16 @@ var require_path_validate = __commonJS({
         if (_isBlockedAiaHost(u.hostname)) continue;
         if (net.isIP(u.hostname.replace(/^\[(.*)\]$/, "$1")) === 0 && !aia.transportGuardsAddresses) continue;
         u.hash = "";
-        if (aia.fetchedUrls.has(u.href) || seenThisCert.has(u.href)) continue;
+        if (intrinsic.setHas(aia.fetchedUrls, u.href) || intrinsic.setHas(seenThisCert, u.href)) continue;
         if (seenThisCert.size >= aia.maxPerCert) break;
-        seenThisCert.add(u.href);
+        intrinsic.setAdd(seenThisCert, u.href);
         uris.push(u.href);
       }
       var out = [];
       for (var k = 0; k < uris.length; k++) {
-        if (aia.fetchedUrls.has(uris[k])) continue;
+        if (intrinsic.setHas(aia.fetchedUrls, uris[k])) continue;
         if (aia.fetches >= aia.maxFetches) break;
-        aia.fetchedUrls.add(uris[k]);
+        intrinsic.setAdd(aia.fetchedUrls, uris[k]);
         aia.fetches += 1;
         var certs;
         try {
@@ -25579,7 +25856,7 @@ var require_path_validate = __commonJS({
       }
       var poolInput = opts.candidates !== void 0 ? opts.candidates : opts.intermediates;
       if (poolInput === void 0) poolInput = [];
-      if (!Array.isArray(poolInput)) throw E("path/bad-input", "build: opts.candidates must be an array of certificates");
+      if (!intrinsic.isArray(poolInput)) throw E("path/bad-input", "build: opts.candidates must be an array of certificates");
       var poolCeiling = constants.LIMITS.PATH_BUILD_MAX_CANDIDATES;
       if (poolInput.length > poolCeiling) throw E("path/bad-input", "build: the candidate pool has " + poolInput.length + " certificates, exceeding the " + poolCeiling + " ceiling");
       var pool;
@@ -25589,8 +25866,8 @@ var require_path_validate = __commonJS({
         throw E("path/bad-input", "build: a candidate certificate did not parse", e);
       }
       var poolDerKeys = /* @__PURE__ */ new Set();
-      for (var pdk = 0; pdk < pool.length; pdk++) poolDerKeys.add(certDerKey(pool[pdk]));
-      if (!Array.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");
+      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);
       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 });
@@ -25647,7 +25924,7 @@ var require_path_validate = __commonJS({
       };
       var forwarded = /* @__PURE__ */ Object.create(null);
       Object.keys(_VALIDATE_OPTS).forEach(function(k) {
-        if (Object.prototype.hasOwnProperty.call(BUILD_ONLY_OPT, k)) return;
+        if (intrinsic.hasOwn(BUILD_ONLY_OPT, k)) return;
         if (k in opts) forwarded[k] = opts[k];
       });
       function validateOpts(anchor) {
@@ -25686,8 +25963,8 @@ var require_path_validate = __commonJS({
             var fetched = await _fetchAiaIssuers(fbCur, aiaCtx);
             for (var fj = 0; fj < fetched.length; fj++) {
               var fdk = certDerKey(fetched[fj]);
-              if (poolDerKeys.has(fdk)) continue;
-              poolDerKeys.add(fdk);
+              if (intrinsic.setHas(poolDerKeys, fdk)) continue;
+              intrinsic.setAdd(poolDerKeys, fdk);
               if (pool.length < poolCeiling) pool.push(fetched[fj]);
             }
           }
@@ -25768,6 +26045,8 @@ var require_tls_cert_compress = __commonJS({
     "use strict";
     var C = require_constants();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var frameworkError = require_framework_error();
     var validator = require_validator_all();
     var ByteWriter = require_byte_writer();
@@ -25798,7 +26077,7 @@ var require_tls_cert_compress = __commonJS({
       }
     };
     var SUPPORTED = guard.compress.algorithms().filter(function(n) {
-      return Object.prototype.hasOwnProperty.call(ALG_BY_NAME, n) && typeof COMPRESS[n] === "function";
+      return _hasOwn(ALG_BY_NAME, n) && typeof COMPRESS[n] === "function";
     });
     var MIN_CERT_MSG_BYTES = validator.tls.MIN_CERT_MSG_BYTES;
     var MAX_VECTOR_24 = validator.tls.MAX_VECTOR_24;
@@ -26765,6 +27044,8 @@ var require_cmc_build = __commonJS({
     var oid = require_oid();
     var cmsSign = require_cms_sign();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var frameworkError = require_framework_error();
     var CmcError = frameworkError.CmcError;
     var b = asn1.build;
@@ -27254,7 +27535,7 @@ var require_cmc_build = __commonJS({
         if (!s || typeof s !== "object") return s;
         var out = {}, k;
         for (k in s) {
-          if (!Object.prototype.hasOwnProperty.call(s, k)) continue;
+          if (!_hasOwn(s, k)) continue;
           out[k] = copyValue(s[k], k === "key");
         }
         return out;
@@ -27264,7 +27545,7 @@ var require_cmc_build = __commonJS({
         if (!v || typeof v !== "object" || typeof v.type === "string") return v;
         var c = {}, ck;
         for (ck in v) {
-          if (!Object.prototype.hasOwnProperty.call(v, ck)) continue;
+          if (!_hasOwn(v, ck)) continue;
           var cv = v[ck];
           c[ck] = Buffer.isBuffer(cv) || cv instanceof Uint8Array ? _own(Buffer.from(cv), isSecret) : cv;
         }
@@ -27378,6 +27659,8 @@ var require_cmc_verify = __commonJS({
     var cmsVerify = require_cms_verify();
     var cmsDecrypt = require_cms_decrypt();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var frameworkError = require_framework_error();
     var CmcError = frameworkError.CmcError;
     function E(code, message, cause) {
@@ -27574,7 +27857,7 @@ var require_cmc_verify = __commonJS({
     function _snapshotSent(sent) {
       var out = {}, k;
       for (k in sent) {
-        if (Object.prototype.hasOwnProperty.call(sent, k)) out[k] = sent[k];
+        if (_hasOwn(sent, k)) out[k] = sent[k];
       }
       if (out.transactionId != null) {
         out.transactionIdValue = guard.range.authoredInteger(out.transactionId, E, "cmc/bad-input", "sent.transactionId");
@@ -27590,7 +27873,7 @@ var require_cmc_verify = __commonJS({
       if (out.recipient && typeof out.recipient === "object") {
         var r = {}, rk;
         for (rk in out.recipient) {
-          if (!Object.prototype.hasOwnProperty.call(out.recipient, rk)) continue;
+          if (!_hasOwn(out.recipient, rk)) continue;
           r[rk] = _copyAnyBytes(out.recipient[rk]);
         }
         out.recipient = r;
@@ -27755,6 +28038,7 @@ var require_tsp_sign = __commonJS({
     var smime = require_schema_smime();
     var schemaTsp = require_schema_tsp();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
     var frameworkError = require_framework_error();
     var pkix = require_schema_pkix();
     var pkiBuild = require_pki_build();
@@ -27817,9 +28101,36 @@ var require_tsp_sign = __commonJS({
         [opts, "pki.tsp.sign options"]
       ], _sign);
     }
+    var _TSA_KEYS = { cert: 1, key: 1 };
+    var _IMPRINT_KEYS = { hashAlgorithm: 1, hashedMessage: 1 };
+    var _SIGN_OPTS = {
+      policy: 1,
+      serialNumber: 1,
+      genTime: 1,
+      nonce: 1,
+      accuracy: 1,
+      ordering: 1,
+      sid: 1,
+      digestAlgorithm: 1,
+      certHashAlgorithm: 1,
+      additionalSignedAttributes: 1,
+      pss: 1,
+      pem: 1
+    };
     function _sign(messageImprint, tsa, opts) {
       opts = opts || {};
+      if (messageImprint && typeof messageImprint === "object" && !Buffer.isBuffer(messageImprint)) {
+        guard.identifier.assertKnownKeys(messageImprint, _IMPRINT_KEYS, _err, "tsp/bad-input", function(k) {
+          return "unknown messageImprint field " + JSON.stringify(k) + " (the imprint is { hashAlgorithm, hashedMessage })";
+        });
+      }
+      guard.identifier.assertKnownKeys(opts, _SIGN_OPTS, _err, "tsp/bad-input", "pki.tsp.sign has an unknown option ");
       if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("tsp/bad-input", "pki.tsp.sign options must be an object");
+      if (tsa && typeof tsa === "object" && !Buffer.isBuffer(tsa)) {
+        guard.identifier.assertKnownKeys(tsa, _TSA_KEYS, _err, "tsp/bad-input", function(k) {
+          return "unknown TSA field " + JSON.stringify(k) + " (the TSA is { cert, key }; a signing option belongs in the third argument)";
+        });
+      }
       var mi = messageImprint || {};
       if (!mi.hashAlgorithm || !NODE_DIGEST[mi.hashAlgorithm]) throw _err("tsp/unsupported-algorithm", "messageImprint.hashAlgorithm must be a supported hash name");
       if (!Buffer.isBuffer(mi.hashedMessage) && !(mi.hashedMessage instanceof Uint8Array)) throw _err("tsp/bad-input", "messageImprint.hashedMessage must be a Buffer");
@@ -27848,7 +28159,11 @@ var require_tsp_sign = __commonJS({
         pem: opts.pem
       });
     }
+    var _ACCURACY_KEYS = { seconds: 1, millis: 1, micros: 1 };
     function _accuracy(a) {
+      guard.identifier.assertKnownKeys(a, _ACCURACY_KEYS, _err, "tsp/bad-input", function(k) {
+        return "unknown accuracy field " + JSON.stringify(k) + "; Accuracy is { seconds?, millis?, micros? }";
+      });
       var f = [];
       if (a.seconds != null) {
         var s = Number(a.seconds);
@@ -27888,10 +28203,17 @@ var require_tsp_sign = __commonJS({
       if (!Buffer.isBuffer(mi.hashedMessage) && !(mi.hashedMessage instanceof Uint8Array)) throw _err("tsp/bad-input", "messageImprint.hashedMessage must be a Buffer");
       if (mi.hashedMessage.length !== HASH_LEN[mi.hashAlgorithm]) throw _err("tsp/bad-input", "messageImprint.hashedMessage length (" + mi.hashedMessage.length + ") does not match the " + mi.hashAlgorithm + " digest length (" + HASH_LEN[mi.hashAlgorithm] + ")");
     }
+    var _REQUEST_OPTS = { reqPolicy: 1, nonce: 1, certReq: 1, extensions: 1, pem: 1 };
     function request(messageImprint, opts) {
       opts = opts || {};
       if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("tsp/bad-input", "pki.tsp.request options must be an object");
+      guard.identifier.assertKnownKeys(opts, _REQUEST_OPTS, _err, "tsp/bad-input", "pki.tsp.request has an unknown option ");
       var mi = messageImprint || {};
+      if (mi && typeof mi === "object" && !Buffer.isBuffer(mi)) {
+        guard.identifier.assertKnownKeys(mi, _IMPRINT_KEYS, _err, "tsp/bad-input", function(k) {
+          return "unknown messageImprint field " + JSON.stringify(k) + " (the imprint is { hashAlgorithm, hashedMessage }; a request option belongs in the second argument)";
+        });
+      }
       _assertImprint(mi);
       var imprint = b.sequence([_hashAlgId(mi.hashAlgorithm), b.octetString(Buffer.from(mi.hashedMessage))]);
       var fields = [b.integer(1n), imprint];
@@ -27900,7 +28222,7 @@ var require_tsp_sign = __commonJS({
       if (opts.certReq != null && typeof opts.certReq !== "boolean") throw _err("tsp/bad-input", "certReq must be a boolean");
       if (opts.certReq === true) fields.push(b.boolean(true));
       if (opts.extensions != null) {
-        if (!Array.isArray(opts.extensions) || !opts.extensions.every(function(e) {
+        if (!Array.isArray(opts.extensions) || !guard.list.allMatch(opts.extensions, function(e) {
           return Buffer.isBuffer(e) || e instanceof Uint8Array;
         })) throw _err("tsp/bad-input", "extensions must be an array of encoded Extension DER buffers");
         var seenExt = {};
@@ -27920,9 +28242,11 @@ var require_tsp_sign = __commonJS({
     function parseRequest(input) {
       return schemaTsp.parseRequest(input);
     }
+    var _RESPONSE_OPTS = { status: 1, statusString: 1, failInfo: 1, pem: 1 };
     function response(token, opts) {
       opts = opts || {};
       if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("tsp/bad-input", "pki.tsp.response options must be an object");
+      guard.identifier.assertKnownKeys(opts, _RESPONSE_OPTS, _err, "tsp/bad-input", "pki.tsp.response has an unknown option ");
       var status = opts.status == null ? 0 : Number(opts.status);
       if (!Number.isInteger(status) || status < 0 || status > 5) throw _err("tsp/bad-input", "PKIStatus must be an integer in 0..5 (RFC 3161 sec. 2.4.2)");
       var granted = status === 0 || status === 1;
@@ -27953,7 +28277,7 @@ var require_tsp_sign = __commonJS({
     var _BIND_DIGEST = { sha256: "sha256", sha384: "sha384", sha512: "sha512" };
     function _imprintMatches(mi, data) {
       var name = mi.hashAlgorithm && mi.hashAlgorithm.name;
-      var nodeAlg = name && _VERIFY_DIGEST[name];
+      var nodeAlg = name && intrinsic.hasOwn(_VERIFY_DIGEST, name) ? _VERIFY_DIGEST[name] : null;
       if (!nodeAlg) return "tsp/unsupported-algorithm";
       var wantLen = _VERIFY_DIGEST_LEN[name];
       if (mi.hashedMessage.length !== wantLen) return "tsp/imprint-mismatch";
@@ -28102,6 +28426,11 @@ var require_tsp_sign = __commonJS({
       });
     }
     var _VERIFY_OPTS = { certs: 1, trustAnchor: 1, nonce: 1, reqPolicy: 1, revocationChecker: 1 };
+    function _anyCritical(extensions) {
+      return guard.list.anyMatches(extensions, function(e) {
+        return !!e && !!e.critical;
+      });
+    }
     async function verify(token, data, opts) {
       opts = opts || {};
       if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("tsp/bad-input", "pki.tsp.verify options must be an object");
@@ -28112,7 +28441,7 @@ var require_tsp_sign = __commonJS({
         "tsp/bad-input",
         "pki.tsp.verify has an unknown option (note the anchor option here is `trustAnchor`, singular, an anchor tuple -- not the `trustAnchors` certificate list pki.cms.verify takes) "
       );
-      if (opts.certs != null && (!Array.isArray(opts.certs) || !opts.certs.every(function(c) {
+      if (opts.certs != null && (!Array.isArray(opts.certs) || !guard.list.allMatch(opts.certs, function(c) {
         return Buffer.isBuffer(c) || c instanceof Uint8Array;
       }))) {
         throw _err("tsp/bad-input", "pki.tsp.verify opts.certs must be an array of DER certificate Buffers");
@@ -28140,9 +28469,7 @@ var require_tsp_sign = __commonJS({
         var wantPolicy = /^\d+(\.\d+)+$/.test(opts.reqPolicy) ? opts.reqPolicy : O(opts.reqPolicy);
         if (tst.policy !== wantPolicy) return fail("tsp/policy-mismatch");
       }
-      if (tst.extensions && tst.extensions.some(function(e) {
-        return e.critical;
-      })) {
+      if (tst.extensions && _anyCritical(tst.extensions)) {
         return fail("tsp/unknown-critical-extension");
       }
       var bind = _checkCertBinding(parsed.signerInfo, tsaCertDer);
@@ -28611,6 +28938,8 @@ var require_x509_sign = __commonJS({
     var x509 = require_schema_x509();
     var signScheme = require_sign_scheme();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _isArray = intrinsic.isArray;
     var frameworkError = require_framework_error();
     var schema = require_schema_engine();
     var pkix = require_schema_pkix();
@@ -28631,6 +28960,17 @@ var require_x509_sign = __commonJS({
       return oid.byName(n);
     }
     var OID_SKI = O("subjectKeyIdentifier");
+    var KNOWN_SPEC_KEYS = {
+      subject: 1,
+      subjectPublicKey: 1,
+      notBefore: 1,
+      notAfter: 1,
+      serialNumber: 1,
+      extensions: 1
+    };
+    var KNOWN_ISSUER_CERT_KEYS = { key: 1, cert: 1 };
+    var KNOWN_ISSUER_EXPLICIT_KEYS = { key: 1, name: 1, publicKey: 1 };
+    var KNOWN_SIGN_OPTS = { digestAlgorithm: 1, pem: 1, pss: 1 };
     var KNOWN_EXT_KEYS = {
       subjectKeyIdentifier: 1,
       authorityKeyIdentifier: 1,
@@ -28688,7 +29028,7 @@ var require_x509_sign = __commonJS({
     }
     function _buildExtensions(extSpec, ctx) {
       if (extSpec == null) return [];
-      if (Array.isArray(extSpec)) {
+      if (_isArray(extSpec)) {
         var seenExt = {}, arrCa = false, arrKeyCertSign = false, arrPathLen = false;
         var oidBc = O("basicConstraints"), oidKu = O("keyUsage");
         var arr = extSpec.map(function(e, i) {
@@ -28729,7 +29069,7 @@ var require_x509_sign = __commonJS({
       if (bc != null) _validateBcSpec(bc);
       var caTrue = !!(bc && bc.cA === true);
       var ku = extSpec.keyUsage;
-      var assertsKeyCertSign = Array.isArray(ku) && ku.indexOf("keyCertSign") >= 0;
+      var assertsKeyCertSign = _isArray(ku) && ku.indexOf("keyCertSign") >= 0;
       if (assertsKeyCertSign && !caTrue) throw _err("x509/bad-input", "keyUsage keyCertSign requires basicConstraints cA=TRUE (RFC 5280 sec. 4.2.1.3)");
       if (bc && bc.pathLen != null) {
         if (!caTrue) throw _err("x509/bad-input", "basicConstraints pathLenConstraint requires cA=TRUE (RFC 5280 sec. 4.2.1.9)");
@@ -28784,7 +29124,7 @@ var require_x509_sign = __commonJS({
     }
     function _issuedCaInfo(extSpec) {
       if (extSpec == null) return { cA: false, pathLen: null };
-      if (!Array.isArray(extSpec)) {
+      if (!_isArray(extSpec)) {
         var bc = extSpec.basicConstraints;
         return { cA: !!(bc && bc.cA === true), pathLen: bc && bc.pathLen != null ? Number(bc.pathLen) : null };
       }
@@ -28798,7 +29138,7 @@ var require_x509_sign = __commonJS({
     }
     function _hasCriticalSan(extSpec) {
       if (extSpec == null) return false;
-      if (!Array.isArray(extSpec)) return !!extSpec.subjectAltName;
+      if (!_isArray(extSpec)) return !!extSpec.subjectAltName;
       var sanOid = O("subjectAltName");
       for (var i = 0; i < extSpec.length; i++) {
         var n = asn1.decode(_reqDer(extSpec[i], "extension"));
@@ -28817,6 +29157,20 @@ var require_x509_sign = __commonJS({
       opts = opts || {};
       if (!spec || typeof spec !== "object" || Buffer.isBuffer(spec)) throw _err("x509/bad-input", "the certificate spec must be an object");
       issuer = issuer || {};
+      guard.identifier.assertKnownKeys(spec, KNOWN_SPEC_KEYS, _err, "x509/bad-input", function(k) {
+        return "unknown certificate spec field " + JSON.stringify(k) + (k === "issuer" ? "; the issuer is the SECOND argument to pki.x509.sign, not a spec field" : "") + (k === "extension" ? "; the extensions spec field is `extensions`" : "");
+      });
+      var byCert = issuer.cert != null;
+      guard.identifier.assertKnownKeys(
+        issuer,
+        byCert ? KNOWN_ISSUER_CERT_KEYS : KNOWN_ISSUER_EXPLICIT_KEYS,
+        _err,
+        "x509/bad-input",
+        function(k) {
+          return "unknown issuer field " + JSON.stringify(k) + " for the " + (byCert ? "certificate form; issuer.cert supplies the name and the public key, so they are not read here" : "explicit form; the issuer takes { key, name, publicKey }, or { key, cert } to take both from a certificate");
+        }
+      );
+      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");
       var spki = _reqDer(spec.subjectPublicKey, "spec.subjectPublicKey (the SPKI DER of the certified key)");
       _assertValidSpki(spki, "spec.subjectPublicKey");
@@ -28844,12 +29198,13 @@ var require_x509_sign = __commonJS({
       guard.time.assertValid(spec.notAfter, _err, "x509/bad-input", "notAfter");
       if (guard.time.instantOf(spec.notBefore) > guard.time.instantOf(spec.notAfter)) throw _err("x509/bad-input", "notBefore must not be after notAfter (RFC 5280 sec. 4.1.2.5)");
       var validityDer = b.sequence([_timeDer(spec.notBefore, "notBefore"), _timeDer(spec.notAfter, "notAfter")]);
-      var exts = _buildExtensions(spec.extensions, { spki, issuerSpki, issuerCert, subjectEmpty });
-      if (subjectEmpty && !_hasCriticalSan(spec.extensions)) {
+      var extSpec = spec.extensions;
+      var exts = _buildExtensions(extSpec, { spki, issuerSpki, issuerCert, subjectEmpty });
+      if (subjectEmpty && !_hasCriticalSan(extSpec)) {
         throw _err("x509/bad-input", "an empty subject requires a critical subjectAltName (RFC 5280 sec. 4.1.2.6)");
       }
       if (issuerPathLen != null) {
-        var issued = _issuedCaInfo(spec.extensions);
+        var issued = _issuedCaInfo(extSpec);
         var selfIssued = guard.name.dnEqual(
           schema.walk(NAME_SCHEMA, asn1.decode(subjectDer), NS).result.rdns,
           schema.walk(NAME_SCHEMA, asn1.decode(issuerDer), NS).result.rdns,
@@ -29030,6 +29385,8 @@ var require_attrcert_sign = __commonJS({
     var x509 = require_schema_x509();
     var signScheme = require_sign_scheme();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var pkix = require_schema_pkix();
     var schema = require_schema_engine();
     require_path_validate();
@@ -29361,10 +29718,10 @@ var require_attrcert_sign = __commonJS({
       return b.sequence(attrs);
     }
     function _assertRevocationSchemesExclusive(seen) {
-      if (!Object.prototype.hasOwnProperty.call(seen, O("noRevAvail"))) return;
+      if (!_hasOwn(seen, O("noRevAvail"))) return;
       var names = Object.keys(REVOCATION_POINTERS);
       for (var i = 0; i < names.length; i++) {
-        if (Object.prototype.hasOwnProperty.call(seen, names[i])) {
+        if (_hasOwn(seen, names[i])) {
           throw _err("attrcert/bad-input", "an attribute certificate must not carry both noRevAvail and a " + REVOCATION_POINTERS[names[i]] + " revocation pointer (RFC 5755 sec. 6)");
         }
       }
@@ -29619,7 +29976,7 @@ var require_attrcert_sign = __commonJS({
       for (var i = 0; i < ac.extensions.length; i++) {
         var e = ac.extensions[i];
         if (e.critical !== true) continue;
-        if (!Object.prototype.hasOwnProperty.call(SUPPORTED_CRITICAL, e.oid)) return e.oid;
+        if (!_hasOwn(SUPPORTED_CRITICAL, e.oid)) return e.oid;
         if (e.decoded === null || e.decoded === void 0 || e.decoded.opaque === true) return e.oid;
       }
       return null;
@@ -29645,7 +30002,7 @@ var require_attrcert_sign = __commonJS({
       }
       var revocationStatus = null;
       if (o.revocationStatus !== void 0) {
-        if (typeof o.revocationStatus !== "string" || !Object.prototype.hasOwnProperty.call(REVOCATION_STATUS, o.revocationStatus)) {
+        if (typeof o.revocationStatus !== "string" || !_hasOwn(REVOCATION_STATUS, o.revocationStatus)) {
           throw _err("attrcert/bad-input", 'pki.attrcert.verify opts.revocationStatus must be "notRevoked" or "revoked"');
         }
         revocationStatus = o.revocationStatus;
@@ -29665,7 +30022,7 @@ var require_attrcert_sign = __commonJS({
         var e = ac.extensions[i];
         if (e.name === "noRevAvail") out.noRevAvail = true;
         var p = REVOCATION_POINTERS[e.oid];
-        if (p !== void 0 && Object.prototype.hasOwnProperty.call(REVOCATION_POINTERS, e.oid)) out.pointer = p;
+        if (p !== void 0 && _hasOwn(REVOCATION_POINTERS, e.oid)) out.pointer = p;
       }
       return out;
     }
@@ -29757,6 +30114,8 @@ var require_crl_sign = __commonJS({
     var x509Schema = require_schema_x509();
     var signScheme = require_sign_scheme();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var frameworkError = require_framework_error();
     var pkix = require_schema_pkix();
     var schema = require_schema_engine();
@@ -29801,7 +30160,33 @@ var require_crl_sign = __commonJS({
       REASON_BY_NAME[CRL_REASON[v]] = Number(v);
     });
     var KNOWN_CRL_EXT_KEYS = { authorityKeyIdentifier: 1, issuingDistributionPoint: 1, deltaCRLIndicator: 1, freshestCRL: 1, authorityInfoAccess: 1 };
+    var KNOWN_SPEC_KEYS = {
+      issuer: 1,
+      thisUpdate: 1,
+      nextUpdate: 1,
+      revoked: 1,
+      crlNumber: 1,
+      extensions: 1
+    };
+    var KNOWN_SPEC_KEYS_ISSUER_NAMED = {
+      thisUpdate: 1,
+      nextUpdate: 1,
+      revoked: 1,
+      crlNumber: 1,
+      extensions: 1
+    };
+    var KNOWN_ISSUER_CERT_KEYS = { key: 1, cert: 1 };
+    var KNOWN_ISSUER_EXPLICIT_KEYS = { key: 1, name: 1, publicKey: 1 };
+    var KNOWN_SIGN_OPTS = { digestAlgorithm: 1, pem: 1, pss: 1 };
     var KNOWN_IDP_KEYS = { fullName: 1, onlyContainsUserCerts: 1, onlyContainsCACerts: 1, onlyContainsAttributeCerts: 1, indirectCRL: 1 };
+    var KNOWN_REVOKED_KEYS = {
+      serialNumber: 1,
+      revocationDate: 1,
+      reason: 1,
+      invalidityDate: 1,
+      certificateIssuer: 1,
+      extensions: 1
+    };
     var REQUIRED_CRITICALITY = {};
     [
       ["cRLNumber", false],
@@ -29857,10 +30242,10 @@ var require_crl_sign = __commonJS({
       var codeNum;
       if (typeof reason === "number") codeNum = reason;
       else if (typeof reason === "string") {
-        if (!Object.prototype.hasOwnProperty.call(REASON_BY_NAME, reason)) throw _err("crl/bad-reason-code", "unknown CRLReason " + JSON.stringify(reason));
+        if (!_hasOwn(REASON_BY_NAME, reason)) throw _err("crl/bad-reason-code", "unknown CRLReason " + JSON.stringify(reason));
         codeNum = REASON_BY_NAME[reason];
       } else throw _err("crl/bad-reason-code", "reason must be a CRLReason name or number");
-      if (!Object.prototype.hasOwnProperty.call(CRL_REASON, String(codeNum))) throw _err("crl/bad-reason-code", "undefined or reserved CRLReason " + codeNum + " (RFC 5280 sec. 5.3.1)");
+      if (!_hasOwn(CRL_REASON, String(codeNum))) throw _err("crl/bad-reason-code", "undefined or reserved CRLReason " + codeNum + " (RFC 5280 sec. 5.3.1)");
       if (codeNum === 8 && !isDelta) throw _err("crl/bad-reason-code", "removeFromCRL(8) may appear only in a delta CRL (RFC 5280 sec. 5.3.1)");
       return codeNum;
     }
@@ -29964,7 +30349,7 @@ var require_crl_sign = __commonJS({
           var extnId = asn1.read.oid(node.children[0]);
           if (seen[extnId]) throw _err("crl/bad-input", "duplicate extension " + extnId + " (RFC 5280 sec. 5.2)");
           seen[extnId] = true;
-          if (Object.prototype.hasOwnProperty.call(REQUIRED_CRITICALITY, extnId)) {
+          if (_hasOwn(REQUIRED_CRITICALITY, extnId)) {
             if (node.children.length === 3 !== REQUIRED_CRITICALITY[extnId]) {
               throw _err("crl/bad-input", "pre-encoded " + (oid.name(extnId) || extnId) + " extension has the wrong criticality (RFC 5280 sec. 5.2 requires it " + (REQUIRED_CRITICALITY[extnId] ? "critical" : "non-critical") + ")");
             }
@@ -30012,6 +30397,9 @@ var require_crl_sign = __commonJS({
       var anyExt = false, seenSerials = {};
       var entries = entryList.map(function(e, idx) {
         if (!e || typeof e !== "object" || Buffer.isBuffer(e)) throw _err("crl/bad-input", "each revoked entry must be an object");
+        guard.identifier.assertKnownKeys(e, KNOWN_REVOKED_KEYS, _err, "crl/bad-input", function(k) {
+          return "unknown field " + JSON.stringify(k) + " in revoked entry [" + idx + "]; an entry is { serialNumber, revocationDate, reason?, invalidityDate?, extensions? }";
+        });
         if (e.serialNumber == null) throw _err("crl/bad-input", "revoked entry [" + idx + "] requires a serialNumber");
         var serialTlv = _serialInteger(e.serialNumber);
         var serialKey = asn1.decode(serialTlv).content.toString("hex");
@@ -30044,13 +30432,13 @@ var require_crl_sign = __commonJS({
             if (seen[extnId]) throw _err("crl/bad-input", "duplicate entry extension " + extnId + " in revoked entry [" + idx + "]");
             seen[extnId] = true;
             if (extnId === O("certificateIssuer")) throw _err("crl/bad-input", _CERT_ISSUER_DEFERRED);
-            if (Object.prototype.hasOwnProperty.call(REQUIRED_ENTRY_CRITICALITY, extnId)) {
+            if (_hasOwn(REQUIRED_ENTRY_CRITICALITY, extnId)) {
               if (xnode.children.length === 3 !== REQUIRED_ENTRY_CRITICALITY[extnId]) throw _err("crl/bad-input", "pre-encoded entry extension " + (oid.name(extnId) || extnId) + " has the wrong criticality (RFC 5280 sec. 5.3 requires it " + (REQUIRED_ENTRY_CRITICALITY[extnId] ? "critical" : "non-critical") + ")");
               var einner = _extInner(xnode, oid.name(extnId) || extnId);
               if (extnId === O("reasonCode")) {
                 if (einner.tagClass !== "universal" || einner.tagNumber !== TAGS.ENUMERATED) throw _err("crl/bad-reason-code", "pre-encoded reasonCode value must be an ENUMERATED (RFC 5280 sec. 5.3.1)");
                 var rc = asn1.read.enumerated(einner);
-                if (!Object.prototype.hasOwnProperty.call(CRL_REASON, rc.toString())) throw _err("crl/bad-reason-code", "pre-encoded reasonCode " + rc + " is undefined or reserved (RFC 5280 sec. 5.3.1)");
+                if (!_hasOwn(CRL_REASON, rc.toString())) throw _err("crl/bad-reason-code", "pre-encoded reasonCode " + rc + " is undefined or reserved (RFC 5280 sec. 5.3.1)");
                 if (rc === 8n && !isDelta) throw _err("crl/bad-reason-code", "removeFromCRL(8) may appear only in a delta CRL (RFC 5280 sec. 5.3.1)");
               } else if (extnId === O("invalidityDate")) {
                 if (einner.tagClass !== "universal" || einner.tagNumber !== TAGS.GENERALIZED_TIME) throw _err("crl/bad-input", "pre-encoded invalidityDate value must be a GeneralizedTime (RFC 5280 sec. 5.3.2)");
@@ -30093,9 +30481,29 @@ var require_crl_sign = __commonJS({
       opts = opts || {};
       if (!spec || typeof spec !== "object" || Buffer.isBuffer(spec)) throw _err("crl/bad-input", "the CRL spec must be an object");
       issuer = issuer || {};
+      var byCert = issuer.cert != null, byName = issuer.name != null;
+      guard.identifier.assertKnownKeys(
+        spec,
+        byCert || byName ? KNOWN_SPEC_KEYS_ISSUER_NAMED : KNOWN_SPEC_KEYS,
+        _err,
+        "crl/bad-input",
+        function(k) {
+          return "unknown CRL spec field " + JSON.stringify(k) + (k === "revokedCertificates" ? "; the producer reads `revoked` (the parser reports the same list as `revokedCertificates`)" : k === "issuer" ? "; the issuer argument already names one, through " + (byCert ? "issuer.cert" : "issuer.name") + ", and that is the name the CRL is signed under" : "");
+        }
+      );
+      guard.identifier.assertKnownKeys(
+        issuer,
+        byCert ? KNOWN_ISSUER_CERT_KEYS : KNOWN_ISSUER_EXPLICIT_KEYS,
+        _err,
+        "crl/bad-input",
+        function(k) {
+          return "unknown issuer field " + JSON.stringify(k) + " for the " + (byCert ? "certificate form; issuer.cert supplies the name and the public key, so they are not read here" : "explicit form; the issuer takes { key, name, publicKey }, or { key, cert } to take both from a certificate");
+        }
+      );
+      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");
       var issuerDer, issuerSpki, issuerCert = null;
-      if (issuer.cert != null) {
+      if (byCert) {
         issuerCert = _parseIssuerCert(issuer.cert);
         _assertIssuerCanSignCrl(issuerCert);
         issuerDer = pkiBuild.tbsNameField(issuerCert, "subject");
@@ -30103,7 +30511,7 @@ var require_crl_sign = __commonJS({
       } else {
         issuerSpki = _reqDer(issuer.publicKey, "issuer.publicKey (the issuer SPKI DER)");
         _assertValidSpki(issuerSpki, "issuer.publicKey");
-        var dnSource = issuer.name != null ? issuer.name : spec.issuer;
+        var dnSource = byName ? issuer.name : spec.issuer;
         if (dnSource == null) throw _err("crl/bad-issuer", "an issuer distinguished name is required (issuer.name or spec.issuer) when no issuer.cert is given");
         issuerDer = _encodeName(dnSource);
       }
@@ -30458,6 +30866,7 @@ var require_key = __commonJS({
       }
       var algorithm = opts.algorithm != null ? opts.algorithm : _inferAlgorithm(detected);
       var isPublic = detected.format === "spki";
+      if (opts.usages != null && !Array.isArray(opts.usages)) throw _err("key/bad-input", "opts.usages must be an array of key-usage strings");
       var usages = opts.usages || _importUsages(_algName(algorithm), isPublic);
       var extractable = opts.extractable != null ? opts.extractable : false;
       try {
@@ -30478,6 +30887,7 @@ var require_key = __commonJS({
         "pki.key.generate has an unknown option (the WebCrypto spelling is `extractable`): "
       );
       var extractable = opts.extractable != null ? opts.extractable : true;
+      if (opts.usages != null && !Array.isArray(opts.usages)) throw _err("key/bad-input", "opts.usages must be an array of key-usage strings");
       var usages = opts.usages || _generateUsages(_algName(algorithm));
       var pair;
       try {
@@ -30940,10 +31350,12 @@ var require_pkcs12_build = __commonJS({
     var schemaCrl = require_schema_crl();
     var key = require_key();
     var cms = require_cms_verify();
+    var cmsSign = require_cms_sign();
     var cmsDecrypt = require_cms_decrypt();
     var schemaPkcs12 = require_schema_pkcs12();
     var pkix = require_schema_pkix();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
     var frameworkError = require_framework_error();
     var C = require_constants();
     var b = asn1.build;
@@ -30978,6 +31390,36 @@ var require_pkcs12_build = __commonJS({
     var DIGEST_NAME = { sha1: "sha1", sha256: "sha256", sha384: "sha384", sha512: "sha512" };
     var _MISSING_PASSWORD = 'a password must be a string, Buffer, or Uint8Array -- an omitted password is not the empty password; pass "" to use the empty one deliberately';
     var _INTEGRITY_OPTS = { mode: 1, signer: 1, signers: 1, certificates: 1, sid: 1, signingTime: 1 };
+    var _BUILD_SPEC_FULL_KEYS = { safeContents: 1 };
+    var _BUILD_SPEC_SHORTHAND_KEYS = { key: 1, cert: 1, ca: 1, friendlyName: 1, localKeyId: 1 };
+    var _BUILD_OPTS_FULL = { integrity: 1, mac: 1, password: 1, pem: 1 };
+    var _BUILD_OPTS_SHORTHAND = { integrity: 1, mac: 1, password: 1, pem: 1, recipientCerts: 1 };
+    var _SAFE_RECIPIENTS_KEYS = { bags: 1, recipients: 1, contentEncryptionAlgorithm: 1 };
+    var _SAFE_PASSWORD_KEYS = { bags: 1, encrypt: 1 };
+    var _SAFE_PLAINTEXT_KEYS = { bags: 1 };
+    var _BAG_KEYS_BY_TYPE = {
+      key: { type: 1, friendlyName: 1, localKeyId: 1, key: 1 },
+      shroudedKey: { type: 1, friendlyName: 1, localKeyId: 1, key: 1, encrypt: 1 },
+      cert: { type: 1, friendlyName: 1, localKeyId: 1, cert: 1 },
+      crl: { type: 1, friendlyName: 1, localKeyId: 1, crl: 1 },
+      secret: { type: 1, friendlyName: 1, localKeyId: 1, secretTypeId: 1, secretValue: 1 },
+      safeContents: { type: 1, friendlyName: 1, localKeyId: 1, nested: 1 }
+    };
+    var _ENCRYPT_KEYS = { password: 1, cipher: 1, salt: 1, iterations: 1, prf: 1 };
+    var _MAC_KEYS = { algorithm: 1, hash: 1, salt: 1, iterations: 1, keyLength: 1, password: 1 };
+    var _MAC_KEYS_HMAC = { algorithm: 1, hash: 1, salt: 1, iterations: 1, password: 1 };
+    var _MAC_KEYS_PBMAC1 = { algorithm: 1, hash: 1, salt: 1, iterations: 1, keyLength: 1, password: 1 };
+    var _OPEN_OPTS = {
+      allowUnauthenticated: 1,
+      importAlgorithm: 1,
+      keys: 1,
+      maxIterations: 1,
+      signerCerts: 1,
+      recipientKey: 1,
+      recipientCert: 1,
+      recipientIndex: 1
+    };
+    var _VERIFY_MAC_OPTS = { maxIterations: 1 };
     function _p12PasswordOwned(pw) {
       if (Buffer.isBuffer(pw)) return { bytes: guard.bytes.view(pw, Pkcs12Error, "pkcs12/bad-input", "the password"), owned: false };
       return { bytes: _p12Encode(pw), owned: true };
@@ -31085,6 +31527,11 @@ var require_pkcs12_build = __commonJS({
     }
     function _buildBag(bag, opts, depth) {
       if (!bag || typeof bag !== "object") throw _err("pkcs12/bad-input", "each bag must be an object with a type");
+      if (intrinsic.hasOwn(_BAG_KEYS_BY_TYPE, bag.type)) {
+        guard.identifier.assertKnownKeys(bag, _BAG_KEYS_BY_TYPE[bag.type], _err, "pkcs12/bad-input", function(k) {
+          return "unknown field " + JSON.stringify(k) + " on a " + JSON.stringify(bag.type) + " bag; that field is not read for this bag type";
+        });
+      }
       switch (bag.type) {
         case "key": {
           var keyDer = _coerceDer(bag.key, "keyBag key");
@@ -31103,10 +31550,11 @@ var require_pkcs12_build = __commonJS({
             throw _err("pkcs12/bad-input", "shroudedKey key is not a well-formed PKCS#8 PrivateKeyInfo", e2);
           }
           var enc = bag.encrypt || {};
+          var bagPbe = _pbeOpts(enc);
           var pw = _pbePasswordOwned(enc.password != null ? enc.password : opts.password);
           var r;
           try {
-            r = pbes2.pbes2Encrypt(pw.bytes, kDer, _pbeOpts(enc), _err, "pkcs12");
+            r = pbes2.pbes2Encrypt(pw.bytes, kDer, bagPbe, _err, "pkcs12");
           } finally {
             _wipePw(pw);
           }
@@ -31170,6 +31618,9 @@ var require_pkcs12_build = __commonJS({
       return der;
     }
     function _pbeOpts(enc) {
+      guard.identifier.assertKnownKeys(enc, _ENCRYPT_KEYS, _err, "pkcs12/bad-input", function(k) {
+        return "unknown encrypt field " + JSON.stringify(k) + "; the PBE descriptor is { password?, cipher?, salt?, iterations?, prf? }";
+      });
       var cipher = CIPHER_NAME[enc.cipher || "aes-256-cbc"];
       if (!cipher) throw _err("pkcs12/bad-input", "unsupported PBES2 cipher " + JSON.stringify(enc.cipher) + " (aes-128-cbc / aes-192-cbc / aes-256-cbc)");
       return {
@@ -31191,6 +31642,15 @@ var require_pkcs12_build = __commonJS({
       var hasRecipients = sc.recipients !== void 0;
       var hasEncrypt = sc.encrypt !== void 0;
       if (hasEncrypt && hasRecipients) throw _err("pkcs12/bad-input", "a safeContents cannot combine encrypt (password) and recipients (public-key) -- one ContentInfo is one privacy type (RFC 7292 sec. 4.1)");
+      guard.identifier.assertKnownKeys(
+        sc,
+        hasRecipients ? _SAFE_RECIPIENTS_KEYS : hasEncrypt ? _SAFE_PASSWORD_KEYS : _SAFE_PLAINTEXT_KEYS,
+        _err,
+        "pkcs12/bad-input",
+        function(k) {
+          return "unknown safeContents field " + JSON.stringify(k) + " for a " + (hasRecipients ? "public-key safe; it takes { bags, recipients, contentEncryptionAlgorithm? }" : hasEncrypt ? "password safe; it takes { bags, encrypt } and its cipher comes from encrypt.cipher" : "plaintext safe; it takes { bags }, and a privacy directive must be encrypt or recipients");
+        }
+      );
       var safeContentsDer = _buildSafeContents(sc.bags || [], opts, 0);
       if (hasRecipients) {
         if (!Array.isArray(sc.recipients) || !sc.recipients.length) throw _err("pkcs12/bad-input", "safeContents.recipients must be a non-empty array of recipient descriptors (RFC 5652 sec. 6.1)");
@@ -31206,10 +31666,11 @@ var require_pkcs12_build = __commonJS({
         return b.sequence([b.oid(O("data")), b.explicit(0, b.octetString(safeContentsDer))]);
       }
       if (!sc.encrypt || typeof sc.encrypt !== "object") throw _err("pkcs12/bad-input", "safeContents.encrypt must be an object { password? } (RFC 7292 sec. 5.1) -- omit it entirely for a plaintext safe");
+      var safePbe = _pbeOpts(sc.encrypt);
       var pw = _pbePasswordOwned(sc.encrypt.password != null ? sc.encrypt.password : opts.password);
       var r;
       try {
-        r = pbes2.pbes2Encrypt(pw.bytes, safeContentsDer, _pbeOpts(sc.encrypt), _err, "pkcs12");
+        r = pbes2.pbes2Encrypt(pw.bytes, safeContentsDer, safePbe, _err, "pkcs12");
       } finally {
         _wipePw(pw);
       }
@@ -31258,11 +31719,18 @@ var require_pkcs12_build = __commonJS({
       }
       throw _err("pkcs12/bad-input", "opts.mac.algorithm must be 'hmac' or 'pbmac1', got " + JSON.stringify(algorithm));
     }
-    function _normalizeSpec(spec, opts) {
-      if (spec && Array.isArray(spec.safeContents)) return spec.safeContents;
+    function _specForm(spec) {
+      var isObject = !!spec && typeof spec === "object" && !Buffer.isBuffer(spec);
+      var safeContents = isObject ? spec.safeContents : null;
+      var full = intrinsic.isArray(safeContents);
+      return { isObject, full, safeContents: full ? safeContents : null };
+    }
+    function _normalizeSpec(spec, opts, form) {
+      if (form.full) return form.safeContents;
       if (spec && (spec.key != null || spec.cert != null)) {
-        var enveloped = opts.recipientCerts != null;
-        if (enveloped && (!Array.isArray(opts.recipientCerts) || !opts.recipientCerts.length)) throw _err("pkcs12/bad-input", "opts.recipientCerts must be a non-empty array of recipient certificates");
+        var recipientCerts = opts.recipientCerts;
+        var enveloped = recipientCerts != null;
+        if (enveloped && (!intrinsic.isArray(recipientCerts) || !recipientCerts.length)) throw _err("pkcs12/bad-input", "opts.recipientCerts must be a non-empty array of recipient certificates");
         var certBags = [];
         if (spec.cert != null) certBags.push({ type: "cert", cert: spec.cert, friendlyName: spec.friendlyName, localKeyId: spec.localKeyId });
         if (spec.ca != null && !Array.isArray(spec.ca)) throw _err("pkcs12/bad-input", "spec.ca must be an array of certificates");
@@ -31273,7 +31741,7 @@ var require_pkcs12_build = __commonJS({
         if (enveloped) {
           var bags = certBags.slice();
           if (spec.key != null) bags.push({ type: "key", key: spec.key, friendlyName: spec.friendlyName, localKeyId: spec.localKeyId });
-          sc.push({ recipients: opts.recipientCerts.map(function(c) {
+          sc.push({ recipients: recipientCerts.map(function(c) {
             return { cert: c };
           }), bags });
           return sc;
@@ -31292,6 +31760,27 @@ var require_pkcs12_build = __commonJS({
     }
     async function _build(spec, opts) {
       opts = opts || {};
+      var form = _specForm(spec);
+      if (form.isObject) {
+        guard.identifier.assertKnownKeys(
+          spec,
+          form.full ? _BUILD_SPEC_FULL_KEYS : _BUILD_SPEC_SHORTHAND_KEYS,
+          _err,
+          "pkcs12/bad-input",
+          function(k) {
+            return "unknown PKCS#12 spec field " + JSON.stringify(k) + " for the " + (form.full ? "safeContents form; the shorthand fields belong to { key, cert, ca } and are not read here" : "shorthand form; pass safeContents instead to build the safes yourself");
+          }
+        );
+      }
+      guard.identifier.assertKnownKeys(
+        opts,
+        form.full ? _BUILD_OPTS_FULL : _BUILD_OPTS_SHORTHAND,
+        _err,
+        "pkcs12/bad-input",
+        function(k) {
+          return "pki.pkcs12.build has an unknown option " + JSON.stringify(k) + (form.full && k === "recipientCerts" ? " for the safeContents form; the full form carries privacy per entry, as safeContents[i].recipients" : "");
+        }
+      );
       if (opts.integrity != null) {
         if (typeof opts.integrity !== "object" || Array.isArray(opts.integrity)) throw _err("pkcs12/bad-input", "opts.integrity must be an object { mode, signer|signers, ... }");
         guard.identifier.assertKnownKeys(opts.integrity, _INTEGRITY_OPTS, _err, "pkcs12/bad-input", "opts.integrity has an unknown option ");
@@ -31301,7 +31790,7 @@ var require_pkcs12_build = __commonJS({
       }
       var pubKey = opts.integrity != null;
       if (pubKey && opts.mac != null && opts.mac !== false) throw _err("pkcs12/bad-integrity-mode", "public-key integrity has no MacData -- do not combine opts.mac with opts.integrity.mode 'public-key' (RFC 7292 sec. 4)");
-      var safeContentsSpecs = _normalizeSpec(spec, opts);
+      var safeContentsSpecs = _normalizeSpec(spec, opts, form);
       if (!Array.isArray(safeContentsSpecs) || !safeContentsSpecs.length) throw _err("pkcs12/bad-input", "the store has no safe contents");
       var elements = [];
       for (var i = 0; i < safeContentsSpecs.length; i++) elements.push(await _buildAuthSafeElement(safeContentsSpecs[i], opts));
@@ -31309,13 +31798,35 @@ var require_pkcs12_build = __commonJS({
       var pfx;
       if (pubKey) {
         var ig = opts.integrity;
+        if (ig.signers != null && ig.signer != null) throw _err("pkcs12/bad-input", "supply exactly one of opts.integrity.signer or opts.integrity.signers, not both");
         var signers = ig.signers != null ? ig.signers : ig.signer != null ? [ig.signer] : null;
         if (!Array.isArray(signers) || !signers.length) throw _err("pkcs12/bad-input", "public-key integrity requires opts.integrity.signer or opts.integrity.signers (a cms.sign signer descriptor)");
+        for (var sx = 0; sx < signers.length; sx++) {
+          var sd = signers[sx];
+          if (sd == null || typeof sd !== "object" || Buffer.isBuffer(sd)) throw _err("pkcs12/bad-input", "each opts.integrity signer must be a descriptor object");
+          var keyOnly = sd.cert == null && sd.spki != null;
+          guard.identifier.assertKnownKeys(
+            sd,
+            keyOnly ? cmsSign.KNOWN_SIGNER_KEY_ONLY_KEYS : cmsSign.KNOWN_SIGNER_CERT_KEYS,
+            _err,
+            "pkcs12/bad-input",
+            function(k) {
+              return "unknown opts.integrity signer field " + JSON.stringify(k) + " for the " + (keyOnly ? "key-only form; it takes { key, spki, keyIdentifier } plus the signature parameters" : "certificate form; it takes { key, cert } plus the signature parameters");
+            }
+          );
+        }
         var authSafeCi = await cms.sign(authSafeDer, signers, { eContentType: "data", detached: false, certificates: ig.certificates !== false, sid: ig.sid, signingTime: ig.signingTime });
         pfx = b.sequence([b.integer(3n), b.raw(authSafeCi)]);
       } else {
         var pfxChildren = [b.integer(3n), b.sequence([b.oid(O("data")), b.explicit(0, b.octetString(authSafeDer))])];
-        if (opts.mac != null && opts.mac !== false && typeof opts.mac !== "object") throw _err("pkcs12/bad-input", "opts.mac must be false or a { algorithm, hash, salt, iterations, keyLength } object");
+        if (opts.mac != null && opts.mac !== false && (typeof opts.mac !== "object" || intrinsic.isArray(opts.mac))) throw _err("pkcs12/bad-input", "opts.mac must be false or a { algorithm, hash, salt, iterations, keyLength } object");
+        if (opts.mac != null && opts.mac !== false) {
+          var macAlg = opts.mac.algorithm == null ? "hmac" : opts.mac.algorithm;
+          var macKeys = macAlg === "hmac" ? _MAC_KEYS_HMAC : macAlg === "pbmac1" ? _MAC_KEYS_PBMAC1 : _MAC_KEYS;
+          guard.identifier.assertKnownKeys(opts.mac, macKeys, _err, "pkcs12/bad-input", function(k) {
+            return "opts.mac has an unknown option " + JSON.stringify(k) + (macAlg === "hmac" && k === "keyLength" ? " for the classic HMAC algorithm; its key is derived at the hash's own output length, and only pbmac1 takes a keyLength" : "");
+          });
+        }
         if (opts.mac !== false) pfxChildren.push(await _buildMacData(opts.mac || {}, opts.password, authSafeDer));
         pfx = b.sequence(pfxChildren);
       }
@@ -31327,6 +31838,9 @@ var require_pkcs12_build = __commonJS({
       return opts.pem ? schemaPkcs12.pemEncode(pfx, "PKCS12") : pfx;
     }
     async function verifyMac(pfx, password, opts) {
+      if (opts != null && typeof opts === "object" && !Buffer.isBuffer(opts)) {
+        guard.identifier.assertKnownKeys(opts, _VERIFY_MAC_OPTS, _err, "pkcs12/bad-input", "pki.pkcs12.verifyMac has an unknown option ");
+      }
       return _verifyMacOfStore(_storeFromBytes(pfx), password, opts);
     }
     async function _verifyMacOfStore(m, password, opts) {
@@ -31375,6 +31889,7 @@ var require_pkcs12_build = __commonJS({
     }
     async function open(pfx, password, opts) {
       opts = opts || {};
+      guard.identifier.assertKnownKeys(opts, _OPEN_OPTS, _err, "pkcs12/bad-input", "pki.pkcs12.open has an unknown option ");
       if (opts.maxIterations != null && (typeof opts.maxIterations !== "number" || !isFinite(opts.maxIterations) || opts.maxIterations < 1 || Math.floor(opts.maxIterations) !== opts.maxIterations)) {
         throw _err("pkcs12/bad-input", "maxIterations must be a positive integer");
       }
@@ -31939,6 +32454,8 @@ var require_hpke = __commonJS({
     var nodeCrypto = require("crypto");
     var frameworkError = require_framework_error();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var HpkeError = frameworkError.HpkeError;
     function _err(code, message, cause) {
       return new HpkeError(code, message, cause);
@@ -32296,7 +32813,7 @@ var require_hpke = __commonJS({
     function _mode(opts, keys, who) {
       guard.identifier.assertKnownKeys(opts, keys, _err, "hpke/bad-input", function(k) {
         var other = keys === _SETUP_S_KEYS ? _SETUP_R_KEYS : _SETUP_S_KEYS;
-        return "unknown HPKE " + who + " option " + JSON.stringify(k) + (Object.prototype.hasOwnProperty.call(other, k) ? " -- that option belongs to the other end of the exchange, where it would authenticate or seed; here it would do nothing" : "") + " -- accepted: " + Object.keys(keys).sort().join(", ");
+        return "unknown HPKE " + who + " option " + JSON.stringify(k) + (_hasOwn(other, k) ? " -- that option belongs to the other end of the exchange, where it would authenticate or seed; here it would do nothing" : "") + " -- accepted: " + Object.keys(keys).sort().join(", ");
       });
       var mode = opts.mode == null ? MODE_BASE : opts.mode;
       if (mode !== MODE_BASE && mode !== MODE_PSK && mode !== MODE_AUTH && mode !== MODE_AUTH_PSK) {
@@ -32868,14 +33385,16 @@ var require_http_digest = __commonJS({
     "use strict";
     var crypto = require("crypto");
     var constants = require_constants();
-    var ALGS = {
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
+    var ALGS = intrinsic.assign(intrinsic.create(null), {
       "SHA-512-256": { hash: "sha512-256", rank: 3, sess: false },
       "SHA-512-256-SESS": { hash: "sha512-256", rank: 3, sess: true },
       "SHA-256": { hash: "sha256", rank: 2, sess: false },
       "SHA-256-SESS": { hash: "sha256", rank: 2, sess: true },
       "MD5": { hash: "md5", rank: 1, sess: false },
       "MD5-SESS": { hash: "md5", rank: 1, sess: true }
-    };
+    });
     var DEFAULT_CODES = {
       unsupportedAlgorithm: "digest/unsupported-algorithm",
       weakAlgorithm: "digest/weak-algorithm",
@@ -32999,7 +33518,7 @@ var require_http_digest = __commonJS({
         var rawVal = seg.slice(eq + 1).replace(/^\s+|\s+$/g, "");
         var quoted = rawVal.charAt(0) === '"';
         if (quoted && !_closedQuote(rawVal)) throw E(code, "an unterminated or trailing-garbage Digest quoted-string (RFC 7230 sec. 3.2.6)");
-        if (Object.prototype.hasOwnProperty.call(map, key)) throw E(code, "repeated Digest auth-param " + JSON.stringify(key));
+        if (_hasOwn(map, key)) throw E(code, "repeated Digest auth-param " + JSON.stringify(key));
         var value = quoted ? _unq(rawVal) : rawVal;
         if (_hasCtl(value)) throw E(code, "a Digest auth-param value contains a control character (RFC 7230 sec. 3.2.6)");
         map[key] = { value, quoted };
@@ -33208,6 +33727,8 @@ var require_est = __commonJS({
     var crmfFmt = require_schema_crmf();
     var frameworkError = require_framework_error();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var httpTransport = require_http_transport();
     var httpDigest = require_http_digest();
     var retryAfter = require_http_retry_after();
@@ -34111,19 +34632,19 @@ var require_est = __commonJS({
       if (!r || typeof r !== "object") return r;
       var out = {}, k;
       for (k in r) {
-        if (Object.prototype.hasOwnProperty.call(r, k)) out[k] = _copyBytes(r[k]);
+        if (_hasOwn(r, k)) out[k] = _copyBytes(r[k]);
       }
       return out;
     }
     function _shallowCopy(o) {
       var out = {}, k;
       for (k in o) {
-        if (Object.prototype.hasOwnProperty.call(o, k)) out[k] = o[k];
+        if (_hasOwn(o, k)) out[k] = o[k];
       }
       if (out.auth && typeof out.auth === "object") {
         var a = {}, ak;
         for (ak in out.auth) {
-          if (Object.prototype.hasOwnProperty.call(out.auth, ak)) a[ak] = out.auth[ak];
+          if (_hasOwn(out.auth, ak)) a[ak] = out.auth[ak];
         }
         out.auth = a;
       }
@@ -34433,15 +34954,27 @@ var require_jose = __commonJS({
     var frameworkError = require_framework_error();
     var guard = require_guard_all();
     var edwardsPoint = require_edwards_point();
+    var intrinsic = require_guard_intrinsic();
+    var _isArray = intrinsic.isArray;
+    var _hasOwn = intrinsic.hasOwn;
+    var _keys = intrinsic.keys;
+    var _isBuffer = intrinsic.isBuffer;
+    var _bufferFrom = intrinsic.bufferFrom;
+    var _stringify = intrinsic.stringify;
+    var _ObjectProto = intrinsic.ObjectProto;
+    var _push = intrinsic.uncurry(Array.prototype.push);
+    var _join = intrinsic.join;
+    var _map = intrinsic.map;
+    var _bufToString = intrinsic.uncurry(Buffer.prototype.toString);
     var JoseError = frameworkError.JoseError;
     function E(code, message, cause) {
       return new JoseError(code, message, cause);
     }
     var LIMITS = constants.LIMITS;
     function b64uEncode(bytes) {
-      if (!Buffer.isBuffer(bytes)) throw E("jose/bad-input", "base64url.encode requires a Buffer");
+      if (!_isBuffer(bytes)) throw E("jose/bad-input", "base64url.encode requires a Buffer");
       bytes = guard.bytes.view(bytes, JoseError, "jose/bad-input", "base64url.encode input");
-      return bytes.toString("base64url");
+      return _bufToString(bytes, "base64url");
     }
     function b64uDecode(text) {
       return guard.encoding.base64url(text, null, E, "jose/bad-base64url", "base64url value");
@@ -34486,16 +35019,16 @@ var require_jose = __commonJS({
     };
     function _checkHeader(header, profileName) {
       var profile = PROFILES[profileName];
-      if (!profile) throw E("jose/bad-input", "unknown JWS profile " + JSON.stringify(profileName));
-      if (!header || typeof header !== "object" || Array.isArray(header)) throw E("jose/bad-header", "the protected header must be a JSON object");
+      if (!profile) throw E("jose/bad-input", "unknown JWS profile " + _stringify(profileName));
+      if (!header || typeof header !== "object" || _isArray(header)) throw E("jose/bad-header", "the protected header must be a JSON object");
       var own = function(k) {
-        return Object.prototype.hasOwnProperty.call(header, k);
+        return _hasOwn(header, k);
       };
       if (own("b64")) throw E("jose/bad-jws", "the RFC 7797 b64 header parameter is forbidden");
       var alg = header.alg;
       if (!own("alg") || typeof alg !== "string") throw E("jose/bad-header", "the protected header must carry a string alg");
       var algRow = profile.algs[alg];
-      if (!algRow) throw E("jose/bad-alg", "unsupported or forbidden algorithm " + JSON.stringify(alg) + " for this JWS profile");
+      if (!algRow) throw E("jose/bad-alg", "unsupported or forbidden algorithm " + _stringify(alg) + " for this JWS profile");
       if (profile.requireUrl && (!own("url") || typeof header.url !== "string" || header.url.length === 0)) throw E("jose/bad-header", "the protected header must carry a non-empty string url");
       var hasNonce = own("nonce");
       if (profile.nonce === "required") {
@@ -34518,18 +35051,18 @@ var require_jose = __commonJS({
       } else if (profile.keyId === "jwk") {
         if (!hasJwk || hasKid) throw E("jose/bad-header", "this JWS must carry an embedded jwk, not kid");
       }
-      if (hasJwk && (!header.jwk || typeof header.jwk !== "object" || Array.isArray(header.jwk))) throw E("jose/bad-header", "jwk must be a JSON object");
-      if (Object.prototype.hasOwnProperty.call(header, "crit")) {
+      if (hasJwk && (!header.jwk || typeof header.jwk !== "object" || _isArray(header.jwk))) throw E("jose/bad-header", "jwk must be a JSON object");
+      if (_hasOwn(header, "crit")) {
         var crit = header.crit;
-        if (!Array.isArray(crit) || crit.length === 0) throw E("jose/bad-crit", "crit must be a non-empty array");
+        if (!_isArray(crit) || crit.length === 0) throw E("jose/bad-crit", "crit must be a non-empty array");
         var seen = {};
         for (var c = 0; c < crit.length; c++) {
           var name = crit[c];
           if (typeof name !== "string") throw E("jose/bad-crit", "crit entries must be strings");
-          if (Object.prototype.hasOwnProperty.call(seen, name)) throw E("jose/bad-crit", "duplicate crit entry " + JSON.stringify(name));
+          if (_hasOwn(seen, name)) throw E("jose/bad-crit", "duplicate crit entry " + _stringify(name));
           seen[name] = 1;
-          if (UNDERSTOOD_HEADER[name]) throw E("jose/bad-crit", "crit must not name a standard header parameter " + JSON.stringify(name));
-          throw E("jose/bad-crit", "unprocessed critical header parameter " + JSON.stringify(name));
+          if (UNDERSTOOD_HEADER[name]) throw E("jose/bad-crit", "crit must not name a standard header parameter " + _stringify(name));
+          throw E("jose/bad-crit", "unprocessed critical header parameter " + _stringify(name));
         }
       }
       return { alg, algRow, header };
@@ -34552,13 +35085,13 @@ var require_jose = __commonJS({
     }
     function _assertKeyType(algRow, jwk) {
       if (!jwk || typeof jwk !== "object" || typeof jwk.kty !== "string") throw E("jose/bad-key", "a JWK object with a kty is required");
-      if (jwk.kty !== algRow.kty) throw E("jose/bad-alg", "the key type " + JSON.stringify(jwk.kty) + " does not match the algorithm");
+      if (jwk.kty !== algRow.kty) throw E("jose/bad-alg", "the key type " + _stringify(jwk.kty) + " does not match the algorithm");
       if (algRow.kty === "EC" && jwk.crv !== algRow.crv) throw E("jose/bad-alg", "the EC curve does not match the algorithm");
-      if (algRow.kty === "OKP" && jwk.crv !== "Ed25519" && jwk.crv !== "Ed448") throw E("jose/bad-alg", "unsupported OKP curve " + JSON.stringify(jwk.crv));
+      if (algRow.kty === "OKP" && jwk.crv !== "Ed25519" && jwk.crv !== "Ed448") throw E("jose/bad-alg", "unsupported OKP curve " + _stringify(jwk.crv));
       if (algRow.kty === "OKP" && typeof jwk.x === "string" && !edwardsPoint.validate(b64uDecode(jwk.x), jwk.crv === "Ed25519" ? 6 : 7)) {
         throw E("jose/bad-key", "the OKP public key is not a valid, full-order Edwards point");
       }
-      if (algRow.kty === "AKP" && jwk.alg !== algRow.subtle) throw E("jose/bad-alg", "the AKP parameter set " + JSON.stringify(jwk.alg) + " does not match the algorithm " + algRow.subtle);
+      if (algRow.kty === "AKP" && jwk.alg !== algRow.subtle) throw E("jose/bad-alg", "the AKP parameter set " + _stringify(jwk.alg) + " does not match the algorithm " + algRow.subtle);
     }
     function _expectedSigBytes(algRow, jwk, key) {
       if (algRow.sigBytes != null) return algRow.sigBytes;
@@ -34572,10 +35105,10 @@ var require_jose = __commonJS({
     }
     var PRIVATE_JWK_MEMBERS = ["d", "p", "q", "dp", "dq", "qi", "k", "priv"];
     function assertPublicJwk(jwk) {
-      if (!jwk || typeof jwk !== "object" || Array.isArray(jwk)) throw E("jose/bad-key", "a JWK object is required");
+      if (!jwk || typeof jwk !== "object" || _isArray(jwk)) throw E("jose/bad-key", "a JWK object is required");
       for (var i = 0; i < PRIVATE_JWK_MEMBERS.length; i++) {
-        if (Object.prototype.hasOwnProperty.call(jwk, PRIVATE_JWK_MEMBERS[i])) {
-          throw E("jose/private-key-material", "a published JWK must be public-only; it carries the private member " + JSON.stringify(PRIVATE_JWK_MEMBERS[i]));
+        if (_hasOwn(jwk, PRIVATE_JWK_MEMBERS[i])) {
+          throw E("jose/private-key-material", "a published JWK must be public-only; it carries the private member " + _stringify(PRIVATE_JWK_MEMBERS[i]));
         }
       }
       return jwk;
@@ -34584,15 +35117,15 @@ var require_jose = __commonJS({
     async function verify(jws, opts) {
       opts = opts || {};
       guard.identifier.assertKnownKeys(opts, _VERIFY_KEYS, E, "jose/bad-input", "unknown pki.jose.verify option ");
-      if (!jws || typeof jws !== "object" || Array.isArray(jws)) throw E("jose/bad-jws", "a flattened JWS object is required");
-      if (Object.prototype.hasOwnProperty.call(jws, "signatures")) throw E("jose/bad-jws", "the multi-signature signatures member is forbidden");
-      if (Object.prototype.hasOwnProperty.call(jws, "header")) throw E("jose/bad-jws", "the unprotected header member is forbidden");
+      if (!jws || typeof jws !== "object" || _isArray(jws)) throw E("jose/bad-jws", "a flattened JWS object is required");
+      if (_hasOwn(jws, "signatures")) throw E("jose/bad-jws", "the multi-signature signatures member is forbidden");
+      if (_hasOwn(jws, "header")) throw E("jose/bad-jws", "the unprotected header member is forbidden");
       if (typeof jws.protected !== "string" || typeof jws.signature !== "string") throw E("jose/bad-jws", "protected and signature must be base64url strings");
       if (typeof jws.payload !== "string") throw E("jose/bad-jws", "payload must be a base64url string (never detached)");
       var header = parseJson(b64uDecode(jws.protected));
       var profileName = opts.profile || "acme-outer";
       var checked = _checkHeader(header, profileName);
-      if (opts.key !== void 0 && (typeof opts.key !== "object" || opts.key === null || Array.isArray(opts.key))) {
+      if (opts.key !== void 0 && (typeof opts.key !== "object" || opts.key === null || _isArray(opts.key))) {
         throw E("jose/bad-key", "opts.key was supplied but is not a JWK object, so the key this message must be signed under cannot be established");
       }
       var jwk = header.jwk || opts.key;
@@ -34621,7 +35154,7 @@ var require_jose = __commonJS({
       var sig = b64uDecode(jws.signature);
       var want = _expectedSigBytes(checked.algRow, jwk);
       if (want != null && sig.length !== want) throw E("jose/bad-signature", "the signature length " + sig.length + " is not the " + want + " bytes " + checked.alg + " requires");
-      var signingInput = Buffer.from(jws.protected + "." + jws.payload, "ascii");
+      var signingInput = _bufferFrom(jws.protected + "." + jws.payload, "ascii");
       var key;
       try {
         key = await webcrypto.subtle.importKey("jwk", jwk, _importParams(checked.algRow, jwk), false, ["verify"]);
@@ -34633,12 +35166,26 @@ var require_jose = __commonJS({
       return { header, payload: b64uDecode(jws.payload), keySource };
     }
     var _SIGN_KEYS = { protected: 1, payload: 1, key: 1, jwk: 1, profile: 1 };
+    var _SIGN_KEYS_EMBEDDED_JWK = { protected: 1, payload: 1, key: 1, profile: 1 };
     async function sign(opts) {
       opts = opts || {};
       guard.identifier.assertKnownKeys(opts, _SIGN_KEYS, E, "jose/bad-input", "unknown pki.jose.sign option ");
-      var header = opts.protected;
+      var headerJson;
+      try {
+        headerJson = _stringify(opts.protected);
+      } catch (e) {
+        throw E("jose/bad-header", "the protected header must be JSON-serializable", e);
+      }
+      var headerBytes = headerJson === void 0 ? null : _bufferFrom(headerJson, "utf8");
+      var header = headerBytes === null ? opts.protected : parseJson(headerBytes);
+      var embedsJwk = !!(header && typeof header === "object" && header.jwk);
+      if (embedsJwk) {
+        guard.identifier.assertKnownKeys(opts, _SIGN_KEYS_EMBEDDED_JWK, E, "jose/bad-input", function(k) {
+          return "unknown pki.jose.sign option " + _stringify(k) + (k === "jwk" ? "; the protected header already embeds the public JWK" : "");
+        });
+      }
       var payload = opts.payload;
-      if (!Buffer.isBuffer(payload)) throw E("jose/bad-input", "payload must be a Buffer (empty Buffer for POST-as-GET)");
+      if (!_isBuffer(payload)) throw E("jose/bad-input", "payload must be a Buffer (empty Buffer for POST-as-GET)");
       payload = guard.bytes.view(payload, JoseError, "jose/bad-input", "payload");
       if (!wcEngine.isCryptoKeyLike(opts.key)) throw E("jose/bad-input", "a private or secret CryptoKey (opts.key) is required");
       var checked = _checkHeader(header, opts.profile || "acme-outer");
@@ -34649,12 +35196,12 @@ var require_jose = __commonJS({
         _assertKeyType(checked.algRow, header.jwk);
         assertPublicJwk(header.jwk);
       }
-      var protectedB64 = b64uEncode(Buffer.from(JSON.stringify(header), "utf8"));
+      var protectedB64 = b64uEncode(headerBytes);
       var payloadB64 = payload.length === 0 ? "" : b64uEncode(payload);
-      var signingInput = Buffer.from(protectedB64 + "." + payloadB64, "ascii");
+      var signingInput = _bufferFrom(protectedB64 + "." + payloadB64, "ascii");
       var jwk = header.jwk || opts.jwk || {};
       var signKey = await wcEngine.adoptKey(opts.key, null, ["sign"], E, "jose/bad-input");
-      var sigBuf = Buffer.from(await webcrypto.subtle.sign(_cryptoAlg(checked.algRow, jwk, signKey), signKey, signingInput));
+      var sigBuf = _bufferFrom(await webcrypto.subtle.sign(_cryptoAlg(checked.algRow, jwk, signKey), signKey, signingInput));
       var want = _expectedSigBytes(checked.algRow, jwk, opts.key);
       if (want != null && sigBuf.length !== want) throw E("jose/bad-key", "the signing key produced a " + sigBuf.length + "-byte signature but " + checked.alg + " requires " + want + " (the key does not match the algorithm)");
       if (header.jwk) {
@@ -34681,19 +35228,19 @@ var require_jose = __commonJS({
     async function thumbprint(jwk) {
       if (!jwk || typeof jwk !== "object" || typeof jwk.kty !== "string") throw E("jose/bad-key", "a JWK object with a kty is required");
       var members = THUMBPRINT_MEMBERS[jwk.kty];
-      if (!members) throw E("jose/bad-key", "unsupported JWK key type " + JSON.stringify(jwk.kty));
+      if (!members) throw E("jose/bad-key", "unsupported JWK key type " + _stringify(jwk.kty));
       var parts = [];
       for (var i = 0; i < members.length; i++) {
         var m = members[i];
-        if (typeof jwk[m] !== "string") throw E("jose/bad-key", "the JWK is missing the required member " + JSON.stringify(m));
-        parts.push(JSON.stringify(m) + ":" + JSON.stringify(jwk[m]));
+        if (typeof jwk[m] !== "string") throw E("jose/bad-key", "the JWK is missing the required member " + _stringify(m));
+        _push(parts, _stringify(m) + ":" + _stringify(jwk[m]));
       }
-      var canonical = "{" + parts.join(",") + "}";
-      var digest = Buffer.from(await webcrypto.subtle.digest("SHA-256", Buffer.from(canonical, "utf8")));
+      var canonical = "{" + _join(parts, ",") + "}";
+      var digest = _bufferFrom(await webcrypto.subtle.digest("SHA-256", _bufferFrom(canonical, "utf8")));
       return b64uEncode(digest);
     }
     function sigAlgs() {
-      return Object.keys(SIG_ALGS).map(function(alg) {
+      return _map(_keys(SIG_ALGS), function(alg) {
         var row = SIG_ALGS[alg];
         var out = { alg, kty: row.kty };
         if (row.crv) out.crv = row.crv;
@@ -34732,6 +35279,8 @@ var require_acme = __commonJS({
     var httpTransport = require_http_transport();
     var retryAfter = require_http_retry_after();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var pkgVersion = require_package().version;
     var AcmeError = frameworkError.AcmeError;
     function E(code, message, cause) {
@@ -34888,7 +35437,7 @@ var require_acme = __commonJS({
       var spec = SPECS[kind];
       for (var f = 0; f < spec.length; f++) {
         var field = spec[f];
-        var present = Object.prototype.hasOwnProperty.call(obj, field.name);
+        var present = _hasOwn(obj, field.name);
         var required = field.required || field.requiredWhen && field.requiredWhen(obj);
         if (!present) {
           if (required) throw E("acme/missing-field", "an ACME " + kind + " is missing the required field " + JSON.stringify(field.name));
@@ -34998,14 +35547,14 @@ var require_acme = __commonJS({
     var ERROR_NAMESPACE = "urn:ietf:params:acme:error:";
     function validateProblem(obj) {
       if (!_isObject(obj)) throw E("acme/bad-problem", "a problem document must be a JSON object");
-      if (Object.prototype.hasOwnProperty.call(obj, "identifier")) throw E("acme/bad-problem", "a top-level problem document must not carry an identifier (RFC 8555 sec. 6.7.1)");
+      if (_hasOwn(obj, "identifier")) throw E("acme/bad-problem", "a top-level problem document must not carry an identifier (RFC 8555 sec. 6.7.1)");
       if (!_isString(obj.type) || obj.type.indexOf(ERROR_NAMESPACE) !== 0) throw E("acme/bad-problem", "an ACME problem type must be in the " + ERROR_NAMESPACE + " namespace (RFC 8555 sec. 6.7)");
-      if (Object.prototype.hasOwnProperty.call(obj, "subproblems")) {
+      if (_hasOwn(obj, "subproblems")) {
         if (!Array.isArray(obj.subproblems)) throw E("acme/bad-problem", "subproblems must be an array");
         for (var i = 0; i < obj.subproblems.length; i++) {
           var sub = obj.subproblems[i];
           if (!_isObject(sub) || !_isString(sub.type) || sub.type.indexOf(ERROR_NAMESPACE) !== 0) throw E("acme/bad-problem", "each subproblem must be an ACME problem document in the error namespace");
-          if (Object.prototype.hasOwnProperty.call(sub, "identifier")) _validateOrderIdentifier(sub.identifier);
+          if (_hasOwn(sub, "identifier")) _validateOrderIdentifier(sub.identifier);
         }
       }
       return obj;
@@ -35019,7 +35568,7 @@ var require_acme = __commonJS({
     function identify(obj) {
       if (!_isObject(obj)) return "unknown";
       var has = function(k) {
-        return Object.prototype.hasOwnProperty.call(obj, k);
+        return _hasOwn(obj, k);
       };
       if (has("protected") && has("signature") && _isString(obj.protected) && _isString(obj.signature)) return "jws";
       if (_isString(obj.type) && obj.type.indexOf(ERROR_NAMESPACE) === 0) return "problem";
@@ -35115,8 +35664,8 @@ var require_acme = __commonJS({
     }
     function _outerHeader(o) {
       var h = { alg: o.alg, nonce: o.nonce, url: o.url };
-      if (Object.prototype.hasOwnProperty.call(o, "kid")) h.kid = o.kid;
-      if (Object.prototype.hasOwnProperty.call(o, "jwk")) h.jwk = o.jwk;
+      if (_hasOwn(o, "kid")) h.kid = o.kid;
+      if (_hasOwn(o, "jwk")) h.jwk = o.jwk;
       return h;
     }
     function _payloadBuf(obj) {
@@ -35127,7 +35676,7 @@ var require_acme = __commonJS({
     function _signOuter(o, payloadObj) {
       if (!_isObject(o)) throw E("acme/bad-input", "a request options object is required");
       if (!o.key) throw E("acme/bad-input", "a signing key (opts.key) is required");
-      return jose.sign({ protected: _outerHeader(o), payload: _payloadBuf(payloadObj), key: o.key, jwk: o.jwk, profile: "acme-outer" });
+      return jose.sign({ protected: _outerHeader(o), payload: _payloadBuf(payloadObj), key: o.key, profile: "acme-outer" });
     }
     function postAsGet(o) {
       return _promised(function() {
@@ -35167,7 +35716,7 @@ var require_acme = __commonJS({
           if (!_isObject(o.externalAccountBinding)) throw E("acme/bad-input", "externalAccountBinding must be an EAB inner JWS object");
           payload.externalAccountBinding = o.externalAccountBinding;
         }
-        return jose.sign({ protected: { alg: o.alg, nonce: o.nonce, url: o.url, jwk: o.jwk }, payload: _payloadBuf(payload), key: o.key, jwk: o.jwk, profile: "acme-outer" });
+        return jose.sign({ protected: { alg: o.alg, nonce: o.nonce, url: o.url, jwk: o.jwk }, payload: _payloadBuf(payload), key: o.key, profile: "acme-outer" });
       });
     }
     var _HMAC_HASH = { HS256: "SHA-256", HS384: "SHA-384", HS512: "SHA-512" };
@@ -35343,8 +35892,8 @@ var require_acme = __commonJS({
       return _promised(function() {
         if (!_isObject(o) || !Buffer.isBuffer(o.certificate)) throw E("acme/bad-input", "revokeCert requires a DER certificate Buffer (opts.certificate)");
         x509.parse(o.certificate);
-        var hasKid = Object.prototype.hasOwnProperty.call(o, "kid");
-        var hasJwk = Object.prototype.hasOwnProperty.call(o, "jwk");
+        var hasKid = _hasOwn(o, "kid");
+        var hasJwk = _hasOwn(o, "jwk");
         if (hasKid === hasJwk) throw E("acme/bad-input", "revokeCert must be signed with EXACTLY ONE of the account kid or the certificate jwk (RFC 8555 sec. 7.6)");
         var payload = { certificate: jose.base64url.encode(o.certificate) };
         if (o.reason !== void 0) {
@@ -35356,7 +35905,7 @@ var require_acme = __commonJS({
         var header = { alg: o.alg, nonce: o.nonce, url: o.url };
         if (hasKid) header.kid = o.kid;
         else header.jwk = o.jwk;
-        return jose.sign({ protected: header, payload: _payloadBuf(payload), key: o.key, jwk: o.jwk, profile: "acme-outer" });
+        return jose.sign({ protected: header, payload: _payloadBuf(payload), key: o.key, profile: "acme-outer" });
       });
     }
     async function keyChange(o) {
@@ -35370,7 +35919,6 @@ var require_acme = __commonJS({
         protected: { alg: o.newAlg, url: o.url, jwk: o.newJwk },
         payload: _payloadBuf({ account: o.account, oldKey: o.oldKey }),
         key: o.newKey,
-        jwk: o.newJwk,
         profile: "keychange-inner"
       });
       return jose.sign({ protected: { alg: o.alg, nonce: o.nonce, url: o.url, kid: o.kid }, payload: _payloadBuf(inner), key: o.key, profile: "acme-outer" });
@@ -35676,7 +36224,7 @@ var require_acme = __commonJS({
     function _parseLinkAlternates(headers, base) {
       var raw = null;
       for (var k in headers) {
-        if (Object.prototype.hasOwnProperty.call(headers, k) && k.toLowerCase() === "link") {
+        if (_hasOwn(headers, k) && k.toLowerCase() === "link") {
           raw = headers[k];
           break;
         }
@@ -36288,6 +36836,8 @@ var require_trust = __commonJS({
     var errors = require_framework_error();
     var asn1 = require_asn1_der();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var x509 = require_schema_x509();
     var TrustError = errors.TrustError;
     var LIMITS = constants.LIMITS;
@@ -36737,7 +37287,7 @@ var require_trust = __commonJS({
         var t = tok.trim();
         if (t === "") return;
         var l = t.toLowerCase();
-        if (!Object.prototype.hasOwnProperty.call(_TRUST_BIT_TOKENS, l)) {
+        if (!_hasOwn(_TRUST_BIT_TOKENS, l)) {
           throw E("trust/bad-csv", "unrecognized Trust Bits token " + JSON.stringify(t));
         }
         var p = _TRUST_BIT_TOKENS[l];
@@ -38417,6 +38967,8 @@ var require_webauthn_mds = __commonJS({
     var frameworkError = require_framework_error();
     var x509 = require_schema_x509();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var jose = require_jose();
     var rfc3339 = require_rfc3339();
     var constants = require_constants();
@@ -38634,7 +39186,7 @@ var require_webauthn_mds = __commonJS({
       if (header.x5u !== void 0) {
         throw _err("webauthn/bad-metadata-blob", "the metadata BLOB header carries x5u, which names a chain to fetch; supply a BLOB with an inline x5c instead");
       }
-      if (Object.prototype.hasOwnProperty.call(header, "crit")) {
+      if (_hasOwn(header, "crit")) {
         var crit = header.crit;
         if (!Array.isArray(crit) || crit.length === 0) {
           throw _err("webauthn/bad-metadata-blob", "the metadata BLOB header crit must be a non-empty array (RFC 7515 sec. 4.1.11)");
@@ -39072,6 +39624,8 @@ var require_webauthn = __commonJS({
     var validator = require_validator_all();
     var edwardsPoint = require_edwards_point();
     var guard = require_guard_all();
+    var intrinsic = require_guard_intrinsic();
+    var _hasOwn = intrinsic.hasOwn;
     var jose = require_jose();
     var mds = require_webauthn_mds();
     var nodeCrypto = require("crypto");
@@ -40284,7 +40838,7 @@ var require_webauthn = __commonJS({
       guard.identifier.assertKnownKeys(input, _ASSERT_OPTS, _err, "webauthn/bad-input", "verifyAssertion input has an unknown key ");
       var out = {}, k;
       for (k in input) {
-        if (Object.prototype.hasOwnProperty.call(input, k)) out[k] = input[k];
+        if (_hasOwn(input, k)) out[k] = input[k];
       }
       ["authenticatorData", "clientDataJSON", "clientDataHash", "signature", "expectedChallenge"].forEach(function(f) {
         if (_isBufferSource(out[f])) out[f] = guard.bytes.snapshotSource(out[f], WebauthnError, "webauthn/bad-input", f);
@@ -40299,7 +40853,7 @@ var require_webauthn = __commonJS({
       } else if (_isPlainObject(out.credentialPublicKey)) {
         var key = {}, kk;
         for (kk in out.credentialPublicKey) {
-          if (!Object.prototype.hasOwnProperty.call(out.credentialPublicKey, kk)) continue;
+          if (!_hasOwn(out.credentialPublicKey, kk)) continue;
           var v;
           try {
             v = out.credentialPublicKey[kk];