@blamejs/core 0.18.50 → 0.18.53

package/lib/vendor/blamejs-pki.cjs

@@ -1,4 +1,4 @@
-// @blamejs/pki v0.5.25 — vendored (Apache-2.0). Zero-dep pure CJS.
+// @blamejs/pki v0.5.28 — 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.25",
+      version: "0.5.28",
       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",
@@ -1114,13 +1114,10 @@ var require_guard_identifier = __commonJS({
       pair(DataView, _DATAVIEW_PROTO_MEMBERS);
       pair(Buffer, _BUFFER_PROTO_MEMBERS);
       _forEach(_getOwnPropertyNames(globalThis), function(n) {
-        var C;
-        try {
-          C = globalThis[n];
-        } catch (_e) {
-          return;
-        }
-        if (typeof C !== "function" || typeof C.BYTES_PER_ELEMENT !== "number") return;
+        var d = _getOwnPropertyDescriptor(globalThis, n);
+        if (!d || typeof d.value !== "function") return;
+        var C = d.value;
+        if (typeof C.BYTES_PER_ELEMENT !== "number") return;
         if (!C.prototype || _getPrototypeOf(C.prototype) !== _TYPED_ARRAY_PROTO) return;
         _mapSet(m, C.prototype, _CONCRETE_TYPED_MEMBERS);
       });
@@ -1236,6 +1233,16 @@ var require_guard_identifier = __commonJS({
       if (util.types.isArgumentsObject(v)) return "an arguments object";
       return null;
     }
+    function _isBuiltinExotic(v) {
+      var t = util.types;
+      return t.isDate(v) || t.isMap(v) || t.isSet(v) || t.isWeakMap(v) || t.isWeakSet(v) || t.isRegExp(v) || t.isPromise(v) || t.isArrayBuffer(v) || t.isSharedArrayBuffer(v) || t.isArrayBufferView(v) || t.isBoxedPrimitive(v) || t.isNativeError(v) || t.isArgumentsObject(v) || t.isGeneratorObject(v);
+    }
+    function assertPlainRecord(v, E, code, label) {
+      _requireFactory(E);
+      if (v === null || typeof v !== "object" || _isNodeBuffer(v) || _isArray(v)) throw E(code, label + " must be a plain object");
+      _refuseUnenumerable(v, E, code, label);
+      if (_isBuiltinExotic(v)) throw E(code, label + " must be a plain object (a built-in exotic such as a Date or Map is refused)");
+    }
     function optionsObject(opts, E, code, label) {
       if (opts === null || opts === void 0) return _create(null);
       if (typeof opts !== "object") throw E(code, label + " must be an object");
@@ -1286,6 +1293,7 @@ var require_guard_identifier = __commonJS({
     module2.exports = intrinsic.freeze({
       assertCanonicalOid,
       assertKnownKeys,
+      assertPlainRecord,
       optionsObject,
       refuseAccessorFields,
       // Exported so a caller that forwards an options bag copies the same surface this module
@@ -1614,13 +1622,18 @@ var require_oid = __commonJS({
       // id-pkip arc (id-pkix 5). id-regCtrl (id-pkip 1) names the control types a
       // CertRequest carries; id-regInfo (id-pkip 2) names the registration-info types.
       // The parser surfaces each control/info value raw, keyed by these names.
+      // altCertTemplate (7) and the two keySpec controls algId (11) / rsaKeyLen (12) are the RFC 9480
+      // sec. 2.16 additions; a CertReqTemplate response states its key requirements with the latter two.
       regCtrl: { base: [1, 3, 6, 1, 5, 5, 7, 5, 1], of: {
         regToken: 1,
         authenticator: 2,
         pkiPublicationInfo: 3,
         pkiArchiveOptions: 4,
         oldCertID: 5,
-        protocolEncrKey: 6
+        protocolEncrKey: 6,
+        altCertTemplate: 7,
+        algId: 11,
+        rsaKeyLen: 12
       } },
       regInfo: { base: [1, 3, 6, 1, 5, 5, 7, 5, 2], of: { utf8Pairs: 1, certReq: 2 } },
       // PKIX extended key purposes (id-kp, RFC 5280 sec. 4.2.1.12). timeStamping is required,
@@ -1840,6 +1853,10 @@ var require_oid = __commonJS({
         // SignerInfo carries a MAC-based proof instead. Registered so a decoder can
         // name it and refuse it deliberately.
         "id-alg-noSignature": 2,
+        // RSASSA-PSS with SHAKE (RFC 8692): RSA signature algorithms on the PKIX arc.
+        // Registered so a consumer can name them -- e.g. the CMP keySpec RSA exclusion.
+        "id-RSASSA-PSS-SHAKE128": 30,
+        "id-RSASSA-PSS-SHAKE256": 31,
         "id-alg-xmss-hashsig": 34,
         "id-alg-xmssmt-hashsig": 35,
         // Composite ML-DSA signature algorithms (draft-ietf-lamps-pq-composite-sigs
@@ -1916,7 +1933,57 @@ var require_oid = __commonJS({
       edwards: { base: [1, 3, 101], of: { X25519: 110, X448: 111, Ed25519: 112, Ed448: 113 } },
       // OIW Secsig SHA-1 (1.3.14.3.2.26) -- the most common OCSP CertID hashAlgorithm;
       // nistHash covers only SHA-256 and above.
-      oiwSecsig: { base: [1, 3, 14, 3, 2], of: { sha1: 26 } },
+      // OIW Secsig arc (1.3.14.3.2). id-SHA1 (.26) plus every RSA identifier the OIW SIG assigned under the
+      // arc: md4WithRSA (.2), md5WithRSA (.3), md4WithRSAEncryption (.4), rsaSignature (.11, the ISO 9796 RSA
+      // scheme), mdc2WithRSASignature (.14), shaWithRSAEncryption (.15), rsaKeyTransport (.22), and the
+      // md2/md5/sha1-WithRSASignature set (.24/.25/.29) -- pre-PKCS#1 RSA algorithms still seen in old certs.
+      // This is the arc's complete RSA membership per the OIW SIG assignments. Registered so a consumer can
+      // name them -- e.g. the CMP keySpec RSA exclusion, which recognizes RSA wherever it is standardized.
+      // The arc is shared with DES, DSA, DH, and the hashes, so no prefix isolates RSA; each is named.
+      oiwSecsig: { base: [1, 3, 14, 3, 2], of: {
+        sha1: 26,
+        "md4WithRSA": 2,
+        "md5WithRSA": 3,
+        "md4WithRSAEncryption": 4,
+        "rsaSignature": 11,
+        "mdc2WithRSASignature": 14,
+        "shaWithRSAEncryption": 15,
+        "rsaKeyTransport": 22,
+        "md2WithRSASignature": 24,
+        "md5WithRSASignature": 25,
+        "sha1WithRSASignature": 29
+      } },
+      // TeleTrusT (BSI) RSA signature arc (1.3.36.3.3.1) -- RSA signatures with SHA-1 and the RIPEMD family.
+      // The arc is RSA-dedicated, so a consumer can classify the whole family by its prefix; one member is
+      // registered here so that prefix can be derived from the registry rather than a dotted-decimal literal.
+      teletrustRsaSig: { base: [1, 3, 36, 3, 3, 1], of: { "rsaSignatureWithripemd160": 2 } },
+      // X.509 directory encryptionAlgorithm arc (2.5.8.1). id-ea-rsa (.1) is the X.509 `rsa` public-key
+      // identifier, distinct from PKCS#1 rsaEncryption. Registered so a consumer can name it -- e.g. the
+      // CMP keySpec RSA exclusion, which must recognize RSA wherever it is standardized.
+      x509EncAlg: { base: [2, 5, 8, 1], of: { "rsa": 1 } },
+      // X.500 directory signatureAlgorithm arc (2.5.8.3). Its RSA members are sqMod-nWithRSA (.1, the
+      // ITU-T X.509 / ISO 9594-8 square-mod-n-with-RSA signature) and mdc2WithRSA (.100, MDC-2-with-RSA).
+      // Registered so the CMP keySpec RSA exclusion can name them; the arc is not RSA-dedicated, so each
+      // member is named individually rather than prefix-matched.
+      x509SigAlg: { base: [2, 5, 8, 3], of: { "sqMod-nWithRSA": 1, "mdc2WithRSA": 100 } },
+      // Chinese GM/T (SCA) SM algorithm arc (1.2.156.10197.1). Its one RSA member is sm3WithRSAEncryption
+      // (.504, a PKCS#1 v1.5 RSA signature over an SM3 digest); sm2 (.301), sm3 (.401), and SM2-with-SM3
+      // (.501) on the arc are not RSA. Registered so the CMP keySpec RSA exclusion can name it -- the arc is
+      // mixed, so the RSA member is named individually rather than prefix-matched.
+      smAlg: { base: [1, 2, 156, 10197, 1], of: { "sm3WithRSAEncryption": 504 } },
+      // BSI TR-03110 EAC Terminal Authentication RSA arc (0.4.0.127.0.7.2.2.2.1, id-TA-RSA). Every child is an
+      // RSA signature scheme -- PKCS#1 v1.5 or PSS over SHA-1/256/512 -- and the sibling id-TA-ECDSA arc
+      // (0.4.0.127.0.7.2.2.2.2) is EC, so this arc is RSA-dedicated. The members are registered so a consumer
+      // can derive the arc prefix from the registry rather than a dotted-decimal literal and classify the
+      // whole family, including a variant BSI adds later, by that prefix.
+      bsiTaRsa: { base: [0, 4, 0, 127, 0, 7, 2, 2, 2, 1], of: {
+        "id-TA-RSA-v1-5-SHA-1": 1,
+        "id-TA-RSA-v1-5-SHA-256": 2,
+        "id-TA-RSA-PSS-SHA-1": 3,
+        "id-TA-RSA-PSS-SHA-256": 4,
+        "id-TA-RSA-v1-5-SHA-512": 5,
+        "id-TA-RSA-PSS-SHA-512": 6
+      } },
       // NIST AES content-encryption algorithms (arc 2.16.840.1.101.3.4.1) -- the
       // modern PBES2 / CMS content ciphers a PKCS#12 or EnvelopedData names.
       nistAes: { base: [2, 16, 840, 1, 101, 3, 4, 1], of: {
@@ -1949,6 +2016,13 @@ var require_oid = __commonJS({
       // sets .35-.46, each pairing a parameter set with its message-digest hash. The
       // parameters MUST be absent for every one of them (enforced via paramsMustBeAbsent).
       nistSig: { base: [2, 16, 840, 1, 101, 3, 4, 3], of: {
+        // RSASSA-PKCS1-v1_5 with SHA-3 (NIST CSOR): RSA signature algorithms on the NIST
+        // signature arc, alongside the ML-DSA / SLH-DSA sets. Registered so a consumer can
+        // name them -- e.g. the CMP keySpec check that must recognize RSA to exclude it.
+        "id-rsassa-pkcs1-v1_5-with-sha3-224": 13,
+        "id-rsassa-pkcs1-v1_5-with-sha3-256": 14,
+        "id-rsassa-pkcs1-v1_5-with-sha3-384": 15,
+        "id-rsassa-pkcs1-v1_5-with-sha3-512": 16,
         "id-ml-dsa-44": 17,
         "id-ml-dsa-65": 18,
         "id-ml-dsa-87": 19,
@@ -2363,7 +2437,13 @@ var require_webcrypto = __commonJS({
     function CryptoKey(type, extractable, algorithm, usages, handle) {
       this.type = type;
       this.extractable = !!extractable;
-      this.algorithm = algorithm;
+      var frozenAlg = algorithm;
+      if (frozenAlg && typeof frozenAlg === "object") {
+        frozenAlg = _assign({}, algorithm);
+        if (frozenAlg.hash && typeof frozenAlg.hash === "object") frozenAlg.hash = intrinsic.freeze(_assign({}, frozenAlg.hash));
+        frozenAlg = intrinsic.freeze(frozenAlg);
+      }
+      _defineProperty(this, "algorithm", { value: frozenAlg, enumerable: true });
       if (usages != null && !_isArray(usages)) {
         throw new WebCryptoError("webcrypto/syntax", "usages must be an array of key-usage strings");
       }
@@ -4196,6 +4276,9 @@ var require_guard_name = __commonJS({
     var _fromCharCode = String.fromCharCode;
     var _String = String;
     var _isArray = Array.isArray;
+    var _isBuffer = intrinsic.isBuffer;
+    var _bufferEquals = intrinsic.bufferEquals;
+    var _getOwnPropertyDescriptor = intrinsic.getOwnPropertyDescriptor;
     function assertNoControlBytes(str, E, code, label) {
       for (var i = 0; i < str.length; i++) {
         var c = _charCodeAt(str, i);
@@ -4272,6 +4355,47 @@ var require_guard_name = __commonJS({
       }
       return true;
     }
+    function dpnCorresponds(a, b, E, code, label) {
+      var x = _reduceDpn(a, E, code, label), y = _reduceDpn(b, E, code, label);
+      if (x.kind !== y.kind) return false;
+      if (x.kind === "rdn") return _bufferEquals(x.bytes, y.bytes);
+      for (var i = 0; i < x.names.length; i++) {
+        for (var j = 0; j < y.names.length; j++) {
+          if (_bufferEquals(x.names[i], y.names[j])) return true;
+        }
+      }
+      return false;
+    }
+    function _reduceDpn(d, E, code, label) {
+      function refuse(why) {
+        return E(code, "cannot compare " + label + ": " + why);
+      }
+      function ownValue(o, k) {
+        var desc = _getOwnPropertyDescriptor(o, k);
+        if (!desc || !_hasOwn(desc, "value")) throw refuse("a distribution-point comparison requires " + k + " to be the comparand's own value (RFC 5280 sec. 6.3.3 compares decoded names)");
+        return desc.value;
+      }
+      if (!d || typeof d !== "object") {
+        throw refuse("a distribution-point comparison requires the decoded DistributionPointName on both sides (kind fullName or rdn)");
+      }
+      var kind = ownValue(d, "kind");
+      if (kind !== "fullName" && kind !== "rdn") throw refuse("a DistributionPointName is fullName or nameRelativeToCRLIssuer, and this is neither");
+      if (kind === "rdn") {
+        var bytes = ownValue(d, "bytes");
+        if (!_isBuffer(bytes)) throw refuse("a nameRelativeToCRLIssuer distribution point must carry its encoded bytes");
+        return { kind, bytes };
+      }
+      var names = ownValue(d, "names");
+      if (!_isArray(names)) throw refuse("a fullName distribution point must carry a sequence of encoded GeneralNames");
+      var len = names.length;
+      var taken = [];
+      for (var i = 0; i < len; i++) {
+        var n = ownValue(names, i);
+        if (!_isBuffer(n)) throw refuse("every fullName GeneralName must be its encoded bytes");
+        taken[i] = n;
+      }
+      return { kind, names: taken };
+    }
     function escapeControlBytes(str) {
       var s = _String(str), out = "";
       for (var i = 0; i < s.length; i++) {
@@ -4322,6 +4446,7 @@ var require_guard_name = __commonJS({
       dnEqual,
       rdnEqual,
       emailEqual,
+      dpnCorresponds,
       escapeControlBytes,
       escapeDnValue,
       lowerAscii
@@ -15631,6 +15756,88 @@ var require_schema_cmp = __commonJS({
         };
       }
     });
+    var CA_CERTS_VALUE = schema.seqOf(rawSequence("cmp/bad-info-value"), {
+      min: 1,
+      code: "cmp/bad-info-value",
+      what: "CACertsValue",
+      build: function(m) {
+        return m.items.map(function(it) {
+          return it.value;
+        });
+      }
+    });
+    var ROOT_CA_KEY_UPDATE = schema.seq([
+      schema.field("newWithNew", rawSequence("cmp/bad-info-value")),
+      schema.trailing([
+        { tag: 0, name: "newWithOld", schema: rawSequence("cmp/bad-info-value"), explicit: true, emptyCode: "cmp/bad-info-value" },
+        { tag: 1, name: "oldWithNew", schema: rawSequence("cmp/bad-info-value"), explicit: true, emptyCode: "cmp/bad-info-value" }
+      ], { minTag: 0, maxTag: 1, unexpectedCode: "cmp/bad-info-value", orderCode: "cmp/bad-info-value" })
+    ], {
+      assert: "sequence",
+      code: "cmp/bad-info-value",
+      what: "RootCaKeyUpdateContent",
+      build: function(m) {
+        return {
+          newWithNew: m.fields.newWithNew.value,
+          newWithOld: m.fields.newWithOld.present ? m.fields.newWithOld.value : null,
+          oldWithNew: m.fields.oldWithNew.present ? m.fields.oldWithNew.value : null
+        };
+      }
+    });
+    var ATTR_TYPE_AND_VALUE = schema.seq([
+      schema.field("type", schema.oidLeaf()),
+      schema.field("value", schema.any())
+    ], {
+      assert: "sequence",
+      code: "cmp/bad-info-value",
+      what: "AttributeTypeAndValue",
+      build: function(m, ctx) {
+        var t = m.fields.type.value;
+        return { type: t, name: ctx.oid.name(t) || null, value: m.fields.value.value.bytes };
+      }
+    });
+    var CERT_REQ_TEMPLATE_VALUE = schema.seq([
+      schema.field("certTemplate", CERT_TEMPLATE_LEAF),
+      schema.optional("keySpec", schema.seqOf(ATTR_TYPE_AND_VALUE, {
+        min: 1,
+        code: "cmp/bad-info-value",
+        what: "CertReqTemplate keySpec",
+        build: function(m) {
+          return m.items.map(function(it) {
+            return it.value.result;
+          });
+        }
+      }), { whenUniversal: [TAGS.SEQUENCE] })
+    ], {
+      assert: "sequence",
+      code: "cmp/bad-info-value",
+      what: "CertReqTemplateValue",
+      build: function(m) {
+        return {
+          certTemplate: m.fields.certTemplate.value,
+          keySpec: m.fields.keySpec.present ? m.fields.keySpec.value.result : null
+        };
+      }
+    });
+    var CRLS_VALUE = schema.seqOf(rawSequence("cmp/bad-info-value"), {
+      min: 1,
+      code: "cmp/bad-info-value",
+      what: "CRLsValue",
+      build: function(m) {
+        return m.items.map(function(it) {
+          return it.value;
+        });
+      }
+    });
+    function _valueParser(what, topSchema) {
+      return pkix.makeParser({ pemLabel: "CMP", PemError, ErrorClass: CmpError, prefix: "cmp", what, topSchema, ns: NS });
+    }
+    var readCaCerts = _valueParser("CACertsValue", CA_CERTS_VALUE);
+    var readRootCaKeyUpdate = _valueParser("RootCaKeyUpdateContent", ROOT_CA_KEY_UPDATE);
+    var readCertReqTemplate = _valueParser("CertReqTemplateValue", CERT_REQ_TEMPLATE_VALUE);
+    var readCrls = _valueParser("CRLsValue", CRLS_VALUE);
+    var readAlgorithmIdentifier = _valueParser("AlgorithmIdentifier", ALG_ID);
+    var readName = _valueParser("Name", pkix.name(NS));
     var parse = pkix.makeParser({
       pemLabel: "CMP",
       PemError,
@@ -15660,7 +15867,14 @@ var require_schema_cmp = __commonJS({
       parse,
       pemDecode,
       pemEncode,
-      matches
+      matches,
+      // @internal -- the RFC 9483 sec. 4.3 support-message values, read strictly from a genp.
+      readCaCerts,
+      readRootCaKeyUpdate,
+      readCertReqTemplate,
+      readCrls,
+      readAlgorithmIdentifier,
+      readName
     };
   }
 });
@@ -20332,12 +20546,23 @@ var require_cmp_build = __commonJS({
   "node_modules/@blamejs/pki/lib/cmp-build.js"(exports2, module2) {
     "use strict";
     var asn1 = require_asn1_der();
+    var schema = require_schema_engine();
     var oid = require_oid();
     var cmp = require_schema_cmp();
     var crmf = require_crmf_sign();
     var schemaCrmf = require_schema_crmf();
     var intrinsic = require_guard_intrinsic();
     var _hasOwn = intrinsic.hasOwn;
+    var _isArray = intrinsic.isArray;
+    var _isBuffer = intrinsic.isBuffer;
+    var _bufferConcat = intrinsic.bufferConcat;
+    var _map = intrinsic.map;
+    var _keys = intrinsic.keys;
+    var _forEach = intrinsic.forEach;
+    var _push = intrinsic.push;
+    var _stringify = intrinsic.stringify;
+    var _bigInt = intrinsic.BigInt;
+    var _Date = intrinsic.Date;
     var csr = require_schema_csr();
     var crl = require_schema_crl();
     var x509 = require_schema_x509();
@@ -20597,18 +20822,91 @@ var require_cmp_build = __commonJS({
     }
     function _encodeRevDetails(rd) {
       if (!rd || typeof rd !== "object" || Buffer.isBuffer(rd)) throw _err("cmp/bad-rev-req", "each RevDetails must be an object { certDetails, crlEntryDetails? }");
+      guard.identifier.assertKnownKeys(rd, KNOWN_REV_DETAILS_KEYS, _err, "cmp/bad-rev-req", "unknown RevDetails field ");
       if (rd.certDetails == null) throw _err("cmp/bad-rev-req", "RevDetails.certDetails (a CertTemplate) is required");
       var certDetails;
-      if (Buffer.isBuffer(rd.certDetails) || rd.certDetails instanceof Uint8Array) {
-        certDetails = b.raw(_b.reqDer(rd.certDetails, "RevDetails.certDetails (a pre-encoded CertTemplate DER)"));
+      if (guard.bytes.isByteSource(rd.certDetails)) {
+        certDetails = b.raw(guard.bytes.snapshotSource(rd.certDetails, CmpError, "cmp/bad-rev-req", "RevDetails.certDetails (a pre-encoded CertTemplate DER)"));
       } else {
         if (rd.certDetails.issuer == null || rd.certDetails.serialNumber == null) throw _err("cmp/bad-rev-req", "a revocation certDetails must identify the certificate by issuer and serialNumber");
         certDetails = b.raw(crmf.buildCertTemplate(rd.certDetails));
       }
       var children = [certDetails];
-      if (rd.crlEntryDetails != null) children.push(b.raw(_b.reqDer(rd.crlEntryDetails, "RevDetails.crlEntryDetails (a pre-encoded Extensions DER)")));
+      if (rd.crlEntryDetails != null) children.push(b.raw(_encodeCrlEntryDetails(rd.crlEntryDetails)));
       return b.sequence(children);
     }
+    var KNOWN_REV_DETAILS_KEYS = { certDetails: 1, crlEntryDetails: 1 };
+    var KNOWN_CRL_ENTRY_DETAIL_KEYS = { reason: 1 };
+    var CRL_REASON_BY_NAME = intrinsic.create(null);
+    _forEach(_keys(constants.NAMES.CRL_REASON), function(v) {
+      CRL_REASON_BY_NAME[constants.NAMES.CRL_REASON[v]] = intrinsic.Number(v);
+    });
+    function _encodeCrlEntryDetails(spec) {
+      if (guard.bytes.isByteSource(spec)) return guard.bytes.snapshotSource(spec, CmpError, "cmp/bad-rev-req", "RevDetails.crlEntryDetails (a pre-encoded Extensions DER)");
+      guard.identifier.assertPlainRecord(spec, _err, "cmp/bad-rev-req", "RevDetails.crlEntryDetails ({ reason } or a pre-encoded Extensions DER)");
+      guard.identifier.assertKnownKeys(spec, KNOWN_CRL_ENTRY_DETAIL_KEYS, _err, "cmp/bad-rev-req", "unknown crlEntryDetails field ");
+      var reason = spec.reason;
+      if (reason != null && (typeof reason !== "string" || !_hasOwn(CRL_REASON_BY_NAME, reason))) {
+        throw _err("cmp/bad-rev-req", "unknown CRLReason " + _stringify(reason) + " (RFC 5280 sec. 5.3.1)");
+      }
+      var code = reason == null ? 0 : CRL_REASON_BY_NAME[reason];
+      return b.sequence([_b.ext(O("reasonCode"), false, b.enumerated(_bigInt(code)))]);
+    }
+    var KNOWN_CRL_STATUS_KEYS = { dpn: 1, issuer: 1, thisUpdate: 1 };
+    var KNOWN_DPN_KEYS = { fullName: 1 };
+    function buildCrlStatusList(spec) {
+      if (!spec || typeof spec !== "object" || _isBuffer(spec)) throw _err("cmp/bad-input", "a crlUpdate request must be an object { dpn | issuer, thisUpdate? }");
+      guard.identifier.assertKnownKeys(spec, KNOWN_CRL_STATUS_KEYS, _err, "cmp/bad-input", "unknown crlUpdate field ");
+      var dpnSpec = spec.dpn, issuerSpec = spec.issuer;
+      if (dpnSpec == null && issuerSpec == null) {
+        throw _err("cmp/bad-input", "a crlUpdate identifies the requested CRL by a dpn (a distribution point name), an issuer (the CA that issues it), or both (RFC 9483 sec. 4.3.4)");
+      }
+      if (dpnSpec != null && issuerSpec == null) {
+        throw _err("cmp/bad-input", "a crlUpdate naming a dpn must also name the issuer whose CRL is acceptable: a distribution point name alone leaves the response unbound, since a complete CRL states no scope to compare it against (RFC 9483 sec. 4.3.4, RFC 5280 sec. 5.2.5). Drive an unbound request with pki.cmp.build + pki.cmp.transfer.");
+      }
+      var source, issuerNameDer = null, dpnNames = null;
+      if (issuerSpec != null) issuerNameDer = _b.encodeName(issuerSpec);
+      if (dpnSpec != null) {
+        if (typeof dpnSpec !== "object" || _isBuffer(dpnSpec)) throw _err("cmp/bad-input", "crlUpdate.dpn must be { fullName: [<GeneralName>...] }");
+        guard.identifier.assertKnownKeys(dpnSpec, KNOWN_DPN_KEYS, _err, "cmp/bad-input", "unknown crlUpdate.dpn field ");
+        var fullName = dpnSpec.fullName;
+        if (fullName == null) throw _err("cmp/bad-input", "crlUpdate.dpn requires fullName (the nameRelativeToCRLIssuer arm is not built; pki.crl.sign draws the same line for issuingDistributionPoint)");
+        var entries = _isArray(fullName) ? fullName : [fullName];
+        if (!entries.length) throw _err("cmp/bad-input", "crlUpdate.dpn.fullName must carry at least one GeneralName");
+        dpnNames = _map(entries, function(e) {
+          return _b.encodeGeneralName(e);
+        });
+        source = b.explicit(0, b.contextConstructed(0, _bufferConcat(dpnNames)));
+      } else {
+        source = b.explicit(1, b.sequence([b.explicit(4, b.raw(issuerNameDer))]));
+      }
+      var status = [source], askedInstant = null, asked = spec.thisUpdate;
+      if (asked != null) {
+        askedInstant = guard.time.instantOf(asked, _err, "cmp/bad-input", "crlUpdate.thisUpdate");
+        _push(status, b.raw(_b.timeDer(new _Date(askedInstant), "crlUpdate.thisUpdate")));
+      }
+      return {
+        der: b.sequence([b.sequence(status)]),
+        issuerName: issuerNameDer,
+        thisUpdate: askedInstant,
+        dpn: dpnNames === null ? null : { kind: "fullName", names: dpnNames }
+      };
+    }
+    var IDP_SCHEMA = pkix.issuingDistributionPoint("cmp/bad-info-value");
+    function decodeIdpDistributionPoint(valueBytes) {
+      var m;
+      try {
+        m = schema.walk(IDP_SCHEMA, asn1.decode(valueBytes), NS);
+      } catch (e) {
+        throw _err("cmp/bad-info-value", "the returned CRL carries a malformed issuingDistributionPoint extension (RFC 5280 sec. 5.2.5)", e);
+      }
+      if (!m.fields.distributionPoint.present) return null;
+      var wrap = m.fields.distributionPoint.node;
+      if (!wrap.children || wrap.children.length !== 1) {
+        throw _err("cmp/bad-info-value", "an issuingDistributionPoint distributionPoint [0] must wrap exactly one DistributionPointName (RFC 5280 sec. 5.2.5)");
+      }
+      return pkix.distributionPointName(NS, wrap.children[0], "cmp/bad-info-value");
+    }
     function _encodeRevReqContent(list) {
       if (!Array.isArray(list) || !list.length) throw _err("cmp/bad-rev-req", "rr must be a non-empty array of RevDetails");
       return b.sequence(list.map(_encodeRevDetails));
@@ -20864,7 +21162,7 @@ var require_cmp_build = __commonJS({
         if (!Buffer.isBuffer(secret) || !secret.length) throw _err("cmp/bad-input", "opts.mac.secret must be a non-empty string or Buffer");
       }
       var secretBuf = Buffer.isBuffer(secret) ? secret : Buffer.from(secret, "utf8");
-      var prf = m.prf || "SHA-256";
+      var prf = m.prf != null ? m.prf : "SHA-256";
       if (!PBMAC1_PRF[prf]) throw _err("cmp/bad-input", "opts.mac.prf must be SHA-256 / SHA-384 / SHA-512");
       var iterationCount = m.iterationCount != null ? m.iterationCount : PBMAC1_DEFAULT_ITER;
       if (typeof iterationCount !== "number" || !Number.isInteger(iterationCount) || iterationCount < PBMAC1_MIN_ITER) throw _err("cmp/bad-input", "opts.mac.iterationCount must be at least " + PBMAC1_MIN_ITER + " (RFC 8018 sec. 4.2)");
@@ -21087,7 +21385,27 @@ var require_cmp_build = __commonJS({
       if (opts.operation != null) segs.push(_wellKnownSeg(opts.operation, "operation"));
       return u.origin + "/" + segs.join("/");
     }
-    module2.exports = { build, transfer, wellKnownUrl };
+    module2.exports = {
+      build,
+      transfer,
+      wellKnownUrl,
+      buildCrlStatusList,
+      // @internal -- pki.cmp.session composes it for a crlUpdate support message
+      // @internal -- one key, several legal SPKI encodings (a compressed EC point among them), so the
+      // session compares root-rollover keys through the same definition the builders already use.
+      samePublicKey: function(a, b2) {
+        return _b.samePublicKey(a, b2);
+      },
+      // @internal -- the shared certificate-extension decoders, so a consumer reads basicConstraints or
+      // keyUsage through the same definition every format uses instead of walking the bytes again.
+      decodeCertExtension: function(dottedOid, valueBytes) {
+        var dec = EXT_DECODERS[dottedOid];
+        return dec ? dec(valueBytes) : null;
+      },
+      // @internal -- the CRL-side companion: schema-crl leaves issuingDistributionPoint raw, and the
+      // session needs the point it names to bind a crlUpdate answer to the point that was requested.
+      decodeIdpDistributionPoint
+    };
   }
 });
 
@@ -23734,6 +24052,10 @@ var require_cmp_session = __commonJS({
     var oid = require_oid();
     var x509 = require_schema_x509();
     var schemaCmp = require_schema_cmp();
+    var schemaCrmf = require_schema_crmf();
+    var schemaCrl = require_schema_crl();
+    var crmfSign = require_crmf_sign();
+    var cmpBuild = require_cmp_build();
     var csr = require_schema_csr();
     var guard = require_guard_all();
     var compositeSig = require_composite_sig();
@@ -23778,6 +24100,9 @@ var require_cmp_session = __commonJS({
     });
     var OID_RSASSA_PSS = oid.byName("rsassaPss");
     var OID_RSA_ENCRYPTION = oid.byName("rsaEncryption");
+    var OID_IDP = oid.byName("issuingDistributionPoint");
+    var OID_BASIC_CONSTRAINTS = oid.byName("basicConstraints");
+    var OID_KEY_USAGE = oid.byName("keyUsage");
     var HASH_OID_TO_DIGEST = {};
     [["sha256", "SHA-256"], ["sha384", "SHA-384"], ["sha512", "SHA-512"]].forEach(function(row) {
       var o = oid.byName(row[0]);
@@ -23817,7 +24142,58 @@ var require_cmp_session = __commonJS({
     var DEFAULT_CERT_REQ_ID = 0;
     var P10CR_CERT_REQ_ID = -1;
     var ENROLL_ARMS = { ir: 1, cr: 1, kur: 1, p10cr: 1 };
-    var RESPONSE_ARM = { ir: "ip", cr: "cp", kur: "kup", p10cr: "cp" };
+    var RESPONSE_ARM = { ir: "ip", cr: "cp", kur: "kup", p10cr: "cp", rr: "rp", genm: "genp" };
+    var WHOLE_MESSAGE_CERT_REQ_ID = -1;
+    var INFO_OPS = Object.assign(/* @__PURE__ */ Object.create(null), {
+      caCerts: { name: "caCerts", requestOid: "caCerts", responseOid: "caCerts", value: false, read: "readCaCerts" },
+      rootCaCert: { name: "rootCaCert", requestOid: "rootCaCert", responseOid: "rootCaKeyUpdate", value: "cert", read: "readRootCaKeyUpdate" },
+      certReqTemplate: { name: "certReqTemplate", requestOid: "certReqTemplate", responseOid: "certReqTemplate", value: false, read: "readCertReqTemplate" },
+      crlUpdate: { name: "crlUpdate", requestOid: "crlStatusList", responseOid: "crls", value: "crlStatus", read: "readCrls" }
+    });
+    var KNOWN_REVOKE_KEYS = { certificate: 1, certDetails: 1, reason: 1 };
+    var RSA_ARCS = ["rsaEncryption", "rsaSignatureWithripemd160", "id-TA-RSA-v1-5-SHA-256"].map(function(n) {
+      return oid.toArcs(oid.byName(n)).slice(0, -1);
+    });
+    var RSA_OFF_ARC = /* @__PURE__ */ Object.create(null);
+    [
+      "id-rsa-kem",
+      "id-kem-rsa",
+      "id-rsassa-pkcs1-v1_5-with-sha3-224",
+      "id-rsassa-pkcs1-v1_5-with-sha3-256",
+      "id-rsassa-pkcs1-v1_5-with-sha3-384",
+      "id-rsassa-pkcs1-v1_5-with-sha3-512",
+      "id-RSASSA-PSS-SHAKE128",
+      "id-RSASSA-PSS-SHAKE256",
+      "md4WithRSA",
+      "md5WithRSA",
+      "md4WithRSAEncryption",
+      "rsaSignature",
+      "mdc2WithRSASignature",
+      "shaWithRSAEncryption",
+      "rsaKeyTransport",
+      "md2WithRSASignature",
+      "md5WithRSASignature",
+      "sha1WithRSASignature",
+      "rsa",
+      // the X.509 directory rsa public-key OID (2.5.8.1.1), distinct from PKCS#1 rsaEncryption
+      "sqMod-nWithRSA",
+      "mdc2WithRSA",
+      // the X.500 directory signatureAlgorithm RSA OIDs (2.5.8.3.1, 2.5.8.3.100)
+      "sm3WithRSAEncryption"
+      // the Chinese GM/T RSA-with-SM3 signature (1.2.156.10197.1.504)
+    ].forEach(function(n) {
+      var d = oid.byName(n);
+      if (d) RSA_OFF_ARC[d] = 1;
+    });
+    var RSA_ARC_EXCLUDE = /* @__PURE__ */ Object.create(null);
+    ["mgf1", "pSpecified"].forEach(function(n) {
+      var d = oid.byName(n);
+      if (d) RSA_ARC_EXCLUDE[d] = 1;
+    });
+    var CRL_REASON_NAMES = /* @__PURE__ */ Object.create(null);
+    Object.keys(constants.NAMES.CRL_REASON).forEach(function(v) {
+      CRL_REASON_NAMES[constants.NAMES.CRL_REASON[v]] = 1;
+    });
     function _isGranted(code) {
       return code === 0 || code === 1;
     }
@@ -23958,7 +24334,7 @@ var require_cmp_session = __commonJS({
     }
     function session(opts) {
       if (opts == null) opts = {};
-      if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("cmp/bad-input", "opts must be an object");
+      guard.identifier.assertPlainRecord(opts, _err, "cmp/bad-input", "opts");
       guard.identifier.assertKnownKeys(opts, KNOWN_SESSION_OPTS, _err, "cmp/bad-input", "unknown session opts field ");
       opts = Object.assign({}, opts);
       if (typeof opts.url !== "string" || !opts.url) throw _err("cmp/bad-input", "opts.url (the CMP endpoint) is required");
@@ -24043,6 +24419,9 @@ var require_cmp_session = __commonJS({
       var caPubsWaitingCount = 0;
       var activeCertReqId = DEFAULT_CERT_REQ_ID;
       var expectedRespArm = "ip";
+      var txnKind = "enroll";
+      var expectedInfoOp = null;
+      var crlQuery = null;
       var requestedSpki = null;
       var inFlight = false, completed = false, started = false;
       var transcript = [];
@@ -24162,6 +24541,8 @@ var require_cmp_session = __commonJS({
       function _classify(verdict) {
         var body = verdict.body || {};
         var arm = body.arm;
+        if (arm === expectedRespArm && txnKind === "revoke") return _classifyRevRep(body);
+        if (arm === expectedRespArm && txnKind === "info") return _classifyGenRep(body);
         if (arm === expectedRespArm) {
           var responses = body.decoded && body.decoded.response || [];
           var resp = null;
@@ -24213,10 +24594,50 @@ var require_cmp_session = __commonJS({
           if (code === 2) return { state: "rejected", resp };
           return { state: "unexpected", reason: "a " + arm + " CertResponse status code " + code + " has no transition" };
         }
-        if (arm === "error") return { state: "rejected", status: body.decoded && body.decoded.pKIStatusInfo };
+        if (arm === "error") return _classifyError(body);
         if (arm === "pollRep") return { state: "pollRep", entries: body.decoded };
         if (arm === "pkiconf") return { state: "pkiconf" };
-        return { state: "unexpected", reason: "response arm " + JSON.stringify(arm) + " has no transition in an enrollment transaction" };
+        return { state: "unexpected", reason: "response arm " + JSON.stringify(arm) + " has no transition in a " + txnKind + " transaction" };
+      }
+      function _classifyError(body) {
+        var si = body.decoded && body.decoded.pKIStatusInfo;
+        var code = si && si.status ? si.status.code : null;
+        if (code === 3) {
+          if (txnKind === "enroll") throw _err("cmp/bad-error", "an error message answering an enrollment must not carry status waiting -- the profile places enrollment waiting in an ip/cp/kup (RFC 9483 sec. 4.4)");
+          if (si.failInfo != null) throw _err("cmp/bad-error", "an error message with status waiting must not carry failInfo (RFC 9483 sec. 4.4)");
+          return { state: "waiting", resp: { status: si } };
+        }
+        if (code !== 2) throw _err("cmp/bad-error", "an error message carries status rejection(2), or waiting(3) for a revoke/info delayed delivery (RFC 9483 sec. 4.2); got " + (code == null ? "no status" : code));
+        return { state: "rejected", status: si };
+      }
+      function _classifyRevRep(body) {
+        var d = body.decoded || {};
+        var list = d.status || [];
+        if (list.length !== 1) {
+          return { state: "unexpected", reason: "an rp answering a revocation must carry exactly one status (RFC 9483 sec. 4.2); got " + list.length };
+        }
+        var si = list[0];
+        var code = si && si.status ? si.status.code : null;
+        if (code === 0) {
+          if (si.failInfo != null) {
+            return { state: "unexpected", reason: "an accepted rp must not carry failInfo (RFC 9483 sec. 4.2)" };
+          }
+          return { state: "granted", status: si, revCerts: d.revCerts, crls: d.crls };
+        }
+        if (code === 2) return { state: "rejected", status: si };
+        return { state: "unexpected", reason: "an rp status code " + code + " has no transition in a revocation (RFC 9483 sec. 4.2 allows accepted or rejection)" };
+      }
+      function _classifyGenRep(body) {
+        var items = body.decoded || [];
+        if (items.length !== 1) {
+          return { state: "unexpected", reason: "a genp must carry exactly one InfoTypeAndValue (RFC 9483 sec. 4.3); got " + items.length };
+        }
+        var itav = items[0];
+        var want = oid.byName(expectedInfoOp.responseOid);
+        if (itav.type !== want) {
+          return { state: "unexpected", reason: "a genp answering " + expectedInfoOp.name + " must carry infoType " + expectedInfoOp.responseOid + " (" + want + "); got " + itav.type };
+        }
+        return { state: "granted", itav };
       }
       function _statusOf(resp) {
         return resp && resp.status ? resp.status : null;
@@ -24294,10 +24715,10 @@ var require_cmp_session = __commonJS({
           return { done: t, polls, header: verdict.header };
         }
       }
-      async function _confirm(certDer, header, info) {
+      async function _confirm(certDer, header, info2) {
         if (opts.implicitConfirm && _implicitConfirmGranted(header)) return { confirmed: true, implicit: true };
         var accept = true;
-        if (typeof opts.acceptCert === "function") accept = await opts.acceptCert(Buffer.from(certDer), info) === true;
+        if (typeof opts.acceptCert === "function") accept = await opts.acceptCert(Buffer.from(certDer), info2) === true;
         var h = _certConfHash(certDer);
         var certHash = Buffer.from(await webcrypto.webcrypto.subtle.digest(h.digest, certDer));
         var cs = { certHash, certReqId: activeCertReqId };
@@ -24373,8 +24794,8 @@ var require_cmp_session = __commonJS({
           chain.push(c);
         });
         await _validateLeaf(leaf, caPubsAccum);
-        var info = { status: PKI_STATUS_NAMES[granted.code] || granted.code, grantedWithMods: granted.code === 1 };
-        var conf = await _confirm(leaf, header, info);
+        var info2 = { status: PKI_STATUS_NAMES[granted.code] || granted.code, grantedWithMods: granted.code === 1 };
+        var conf = await _confirm(leaf, header, info2);
         var certOut = Buffer.from(leaf), chainOut = chain.map(function(c) {
           return Buffer.from(c);
         });
@@ -24390,9 +24811,29 @@ var require_cmp_session = __commonJS({
           polls: granted.polls || 0
         });
       }
+      function _assertFresh(what) {
+        if (completed || inFlight) {
+          throw _err("cmp/bad-input", "this pki.cmp.session transaction is already " + (completed ? "completed" : "in flight") + "; create a new session per " + what + " (RFC 9810 sec. 5.1.1: one transactionID per transaction)");
+        }
+      }
+      async function _runOneShot(bodySpec, arm, kind) {
+        txnKind = kind;
+        expectedRespArm = RESPONSE_ARM[arm];
+        activeCertReqId = WHOLE_MESSAGE_CERT_REQ_ID;
+        var verdict = await _send(bodySpec, arm);
+        var t = _classify(verdict);
+        var polls = 0;
+        if (t.state === "waiting") {
+          var polled = await _pollLoop(t.resp);
+          polls = polled.polls;
+          if (polled.timeout) return { timeout: true, polls, status: polled.status };
+          t = polled.done;
+        }
+        return { done: t, polls };
+      }
       async function enroll(request) {
-        if (completed || inFlight) throw _err("cmp/bad-input", "this pki.cmp.session transaction is already " + (completed ? "completed" : "in flight") + "; create a new session per enrollment (RFC 9810 sec. 5.1.1: one transactionID per transaction)");
-        if (!request || typeof request !== "object" || Buffer.isBuffer(request)) throw _err("cmp/bad-input", "enroll(request) requires a body spec object { ir | cr | kur | p10cr }");
+        _assertFresh("enrollment");
+        guard.identifier.assertPlainRecord(request, _err, "cmp/bad-input", "enroll(request), a body spec { ir | cr | kur | p10cr },");
         var arms = Object.keys(request).filter(function(k) {
           return request[k] != null;
         });
@@ -24415,6 +24856,7 @@ var require_cmp_session = __commonJS({
         }
         inFlight = true;
         try {
+          txnKind = "enroll";
           expectedRespArm = RESPONSE_ARM[arms[0]];
           var cid = typeof armSpec === "object" && !Buffer.isBuffer(armSpec) ? armSpec.certReqId : void 0;
           activeCertReqId = _normalizeCertReqId(cid, arms[0] === "p10cr" ? P10CR_CERT_REQ_ID : DEFAULT_CERT_REQ_ID);
@@ -24443,8 +24885,351 @@ var require_cmp_session = __commonJS({
           completed = started;
         }
       }
+      function _assertRevokingOwnCertificate(certTemplateDer) {
+        var own;
+        try {
+          own = guard.parsed.acceptDerived(opts.cert, "certificate", x509.parse, _err, "cmp/bad-input", "opts.cert");
+        } catch (e) {
+          if (e && e.isCmpError) throw e;
+          throw _err("cmp/bad-input", "opts.cert must be a certificate to revoke one (RFC 9483 sec. 4.2)", e);
+        }
+        var tmpl = schemaCrmf.walkCertTemplate(asn1.decode(certTemplateDer));
+        var sameSerial = tmpl.serialNumber != null && own.serialNumber != null && BigInt(tmpl.serialNumber) === BigInt(own.serialNumber);
+        var sameIssuer = tmpl.issuer != null && guard.name.dnEqual(tmpl.issuer.rdns, own.issuer.rdns, _err, "cmp/bad-input", "the revoked certificate issuer");
+        if (!sameSerial || !sameIssuer) {
+          throw _err("cmp/bad-input", "a session revokes ITS OWN certificate: the issuer and serialNumber in certDetails must name opts.cert, because the signature over the request is the proof of authorization to revoke (RFC 9483 sec. 4.2). Revocation on behalf of another entity is an RA operation -- drive it with pki.cmp.build + pki.cmp.transfer.");
+        }
+        return own;
+      }
+      function _bindRevCerts(revCerts, own) {
+        if (revCerts == null) return null;
+        if (revCerts.length !== 1) {
+          throw _err("cmp/bad-rev-rep", "an rp for a single revocation must name exactly one certificate in revCerts (RFC 9483 sec. 4.2); got " + revCerts.length);
+        }
+        var cid = revCerts[0];
+        var dn = cid.issuer && cid.issuer.tagClass === "context" && cid.issuer.tagNumber === 4 ? cid.issuer.value : null;
+        var sameSerial = cid.serialNumber != null && own.serialNumber != null && BigInt(cid.serialNumber) === BigInt(own.serialNumber);
+        var sameIssuer = dn != null && guard.name.dnEqual(dn.rdns, own.issuer.rdns, _err, "cmp/bad-rev-rep", "the revCerts issuer");
+        if (!sameSerial || !sameIssuer) {
+          throw _err("cmp/bad-rev-rep", "the rp revCerts names a certificate other than the one this session revoked (RFC 9483 sec. 4.2), so a verified verdict must not report it as revoked");
+        }
+        return revCerts;
+      }
+      async function revoke(request) {
+        _assertFresh("revocation");
+        guard.identifier.assertPlainRecord(request, _err, "cmp/bad-input", "revoke(request), an object { certificate | certDetails, reason? },");
+        guard.identifier.assertKnownKeys(request, KNOWN_REVOKE_KEYS, _err, "cmp/bad-input", "unknown revoke request field ");
+        if (isMac) throw _err("cmp/bad-input", "a PBMAC1 session cannot revoke: the request must be signature-protected with the certificate being revoked (RFC 9483 sec. 4.2). Use a signature session ({ key, cert }).");
+        var certificateArg = request.certificate, reasonArg = request.reason;
+        var certDetails = request.certDetails;
+        if (certificateArg == null === (certDetails == null)) {
+          throw _err("cmp/bad-input", "revoke(request) names the certificate by EXACTLY ONE of certificate (the certificate itself) or certDetails ({ issuer, serialNumber })");
+        }
+        if (reasonArg != null && (typeof reasonArg !== "string" || !CRL_REASON_NAMES[reasonArg])) {
+          throw _err("cmp/bad-input", "revoke request.reason must be a CRLReason name (RFC 5280 sec. 5.3.1); got " + JSON.stringify(reasonArg));
+        }
+        if (certificateArg != null) {
+          var target;
+          try {
+            target = guard.parsed.acceptDerived(certificateArg, "certificate", x509.parse, _err, "cmp/bad-input", "revoke request.certificate");
+          } catch (e) {
+            if (e && e.isCmpError) throw e;
+            throw _err("cmp/bad-input", "revoke request.certificate must be a certificate (DER / PEM / parsed)", e);
+          }
+          certDetails = { issuer: target.issuer.bytes, serialNumber: target.serialNumber };
+        }
+        var certTemplateDer;
+        try {
+          certTemplateDer = crmfSign.buildCertTemplate(certDetails);
+        } catch (e) {
+          if (e && e.isCmpError) throw e;
+          throw _err("cmp/bad-rev-req", "revoke request.certDetails must be a CertTemplate naming issuer and serialNumber -- " + (e && e.message || e), e);
+        }
+        var own = _assertRevokingOwnCertificate(certTemplateDer);
+        var body = { rr: [{ certDetails: certTemplateDer, crlEntryDetails: { reason: reasonArg == null ? void 0 : reasonArg } }] };
+        inFlight = true;
+        try {
+          var out = await _runOneShot(body, "rr", "revoke");
+          if (out.timeout) return _terminal("poll-timeout", { status: out.status, polls: out.polls });
+          var t = out.done;
+          if (t.state === "granted") {
+            return _terminal("revoked", {
+              status: t.status,
+              polls: out.polls,
+              revokedCerts: _bindRevCerts(t.revCerts, own),
+              // the CertIds the responder confirms it revoked, bound to the certificate this session revoked
+              // An rp MAY deliver CRLs, and the schema reads those slots as raw SEQUENCEs for the same
+              // reason it does in a genp. They are surfaced on a verdict an operator acts on, so they
+              // are held to being CertificateLists here, exactly as the support-message values are.
+              crls: (t.crls || []).map(_asCrl)
+            });
+          }
+          if (t.state === "rejected") return _terminal("rejected", { status: t.status || null, polls: out.polls });
+          throw _err("cmp/unexpected-arm", t.reason || "the revocation transaction reached an unexpected state");
+        } finally {
+          inFlight = false;
+          completed = started;
+        }
+      }
+      async function info(request) {
+        _assertFresh("support message");
+        guard.identifier.assertPlainRecord(request, _err, "cmp/bad-input", "info(request), an object naming one support operation (caCerts / rootCaCert / certReqTemplate / crlUpdate),");
+        guard.identifier.assertKnownKeys(request, INFO_OPS, _err, "cmp/bad-input", "unknown info request field ");
+        var keys = Object.keys(request), names = [], values = [];
+        for (var ki = 0; ki < keys.length; ki++) {
+          var kv = request[keys[ki]];
+          if (kv == null) continue;
+          names[names.length] = keys[ki];
+          values[values.length] = kv;
+        }
+        if (names.length !== 1) {
+          throw _err("cmp/bad-input", "info(request) must name EXACTLY ONE support operation (caCerts / rootCaCert / certReqTemplate / crlUpdate); a genm carries a sequence of one InfoTypeAndValue (RFC 9483 sec. 4.3)");
+        }
+        var op = INFO_OPS[names[0]], asked = values[0];
+        var itav = { infoType: op.requestOid };
+        if (op.value === false) {
+          if (asked !== true) throw _err("cmp/bad-input", "info request." + op.name + " takes `true`: this operation's genm carries no infoValue (RFC 9483 sec. 4.3.1 and sec. 4.3.3)");
+        } else if (op.value === "cert") {
+          var rootCaCertDer = _certificateArgument(asked, "info request rootCaCert");
+          _assertCaCapable(x509.parse(rootCaCertDer), "info request rootCaCert", "cmp/bad-input");
+          itav.infoValue = rootCaCertDer;
+        } else if (op.value === "crlStatus") {
+          var built = cmpBuild.buildCrlStatusList(asked);
+          itav.infoValue = built.der;
+          crlQuery = { issuerName: built.issuerName, thisUpdate: built.thisUpdate, dpn: built.dpn };
+        }
+        expectedInfoOp = op;
+        inFlight = true;
+        try {
+          var out = await _runOneShot({ genm: [itav] }, "genm", "info");
+          if (out.timeout) return _terminal("poll-timeout", { operation: op.name, status: out.status, polls: out.polls });
+          var t = out.done;
+          if (t.state === "granted") {
+            var raw = t.itav.value;
+            var value = null;
+            if (raw != null) {
+              try {
+                value = schemaCmp[op.read](raw);
+              } catch (e) {
+                if (e && e.isCmpError) throw e;
+                throw _err("cmp/bad-info-value", "the " + op.name + " response value is malformed -- " + (e && e.message || e), e);
+              }
+              value = await _checkInfoValue(op, value, itav.infoValue);
+            }
+            return _terminal("answered", { operation: op.name, present: raw != null, value, status: null, polls: out.polls });
+          }
+          if (t.state === "rejected") return _terminal("rejected", { operation: op.name, status: t.status || null, polls: out.polls });
+          throw _err("cmp/unexpected-arm", t.reason || "the support-message transaction reached an unexpected state");
+        } finally {
+          inFlight = false;
+          completed = started;
+        }
+      }
+      function _checkInfoValue(op, value, requestValue) {
+        if (op.name === "rootCaCert") {
+          if (value.newWithOld == null) throw _err("cmp/bad-info-value", "a rootCaKeyUpdate response must carry newWithOld -- the certificate that lets an entity trusting the OLD root gain trust in the new one (RFC 9483 sec. 4.3.2)");
+          return _checkRootCaKeyUpdate(value, requestValue);
+        }
+        if (op.name === "certReqTemplate") {
+          var t = value.certTemplate;
+          ["publicKey", "serialNumber", "signingAlg", "issuerUID", "subjectUID"].forEach(function(f) {
+            if (t[f] != null) throw _err("cmp/bad-info-value", "a certReqTemplate certTemplate must omit " + f + " (RFC 9483 sec. 4.3.3)");
+          });
+          if (value.keySpec != null) value.keySpec.forEach(_checkKeySpec);
+          return value;
+        }
+        if (op.name === "caCerts") return value.map(function(d) {
+          var der = _asCertificate(d, "a caCerts entry");
+          _assertCaCapable(x509.parse(der), "caCerts entry");
+          return der;
+        });
+        if (op.name === "crlUpdate") {
+          if (value.length !== 1) throw _err("cmp/bad-info-value", "a crlUpdate response answers a single-source query with exactly one CRL -- the latest from the named source (RFC 9483 sec. 4.3.4); got " + value.length);
+          return value.map(_bindCrlToQuery);
+        }
+        throw _err("cmp/bad-info-value", "no response rules are defined for the " + op.name + " support message");
+      }
+      async function _checkRootCaKeyUpdate(value, oldRootDer) {
+        var newWithNew = _asCertificate(value.newWithNew, "the rootCaKeyUpdate newWithNew");
+        var newWithOld = _asCertificate(value.newWithOld, "the rootCaKeyUpdate newWithOld");
+        var oldWithNew = value.oldWithNew == null ? null : _asCertificate(value.oldWithNew, "the rootCaKeyUpdate oldWithNew");
+        var pNewNew = x509.parse(newWithNew), pNewOld = x509.parse(newWithOld), pOldRoot = x509.parse(oldRootDer);
+        _assertCaCapable(pNewNew, "rootCaKeyUpdate newWithNew");
+        _assertCaCapable(pNewOld, "rootCaKeyUpdate newWithOld");
+        if (!cmpBuild.samePublicKey(pNewOld.subjectPublicKeyInfo.bytes, pNewNew.subjectPublicKeyInfo.bytes)) {
+          throw _err("cmp/bad-info-value", "the rootCaKeyUpdate newWithOld must certify the NEW root key, the one newWithNew carries (RFC 9483 sec. 4.3.2)");
+        }
+        _assertSameName(pNewOld.issuer, pOldRoot.subject, "newWithOld", "be issued by the OLD root named in the request");
+        _assertSameName(pNewOld.subject, pNewNew.subject, "newWithOld", "name the same subject as newWithNew, the certificate it vouches for");
+        if (guard.name.dnEqual(pNewNew.issuer.rdns, pNewNew.subject.rdns, _err, "cmp/bad-info-value", "the rootCaKeyUpdate newWithNew name")) {
+          await _assertSignedBy(pNewNew, pNewNew, "newWithNew", "its own key, which a self-issued root certificate must be");
+        }
+        await _assertSignedBy(pNewOld, pOldRoot, "newWithOld", "the OLD root CA key");
+        if (oldWithNew !== null) {
+          var pOldNew = x509.parse(oldWithNew);
+          _assertCaCapable(pOldNew, "rootCaKeyUpdate oldWithNew");
+          if (!cmpBuild.samePublicKey(pOldNew.subjectPublicKeyInfo.bytes, pOldRoot.subjectPublicKeyInfo.bytes)) {
+            throw _err("cmp/bad-info-value", "the rootCaKeyUpdate oldWithNew must certify the OLD root key (RFC 9483 sec. 4.3.2)");
+          }
+          _assertSameName(pOldNew.issuer, pNewNew.subject, "oldWithNew", "be issued by the NEW root");
+          _assertSameName(pOldNew.subject, pOldRoot.subject, "oldWithNew", "name the OLD root it vouches for");
+          await _assertSignedBy(pOldNew, pNewNew, "oldWithNew", "the NEW root CA key");
+        }
+        return { newWithNew, newWithOld, oldWithNew };
+      }
+      function _assertCaCapable(cert, which, code) {
+        code = code || "cmp/bad-info-value";
+        var bc = null, ku = null, bcCritical = false;
+        cert.extensions.forEach(function(e) {
+          if (e.oid === OID_BASIC_CONSTRAINTS) {
+            bc = cmpBuild.decodeCertExtension(e.oid, e.value);
+            bcCritical = e.critical === true;
+          }
+          if (e.oid === OID_KEY_USAGE) ku = cmpBuild.decodeCertExtension(e.oid, e.value);
+        });
+        if (!bc || bc.cA !== true) {
+          throw _err(code, "the " + which + " must be a CA certificate (basicConstraints cA TRUE): an end-entity certificate certifies nothing and cannot serve as an issuer for chain construction (RFC 5280 sec. 6.1.4)");
+        }
+        if (!bcCritical) {
+          throw _err(code, "the " + which + " marks basicConstraints non-critical, so a relying party that skips unrecognized extensions would not see the cA bit it must act on (RFC 5280 sec. 4.2.1.9)");
+        }
+        if (ku && ku.keyCertSign !== true) {
+          throw _err(code, "the " + which + " carries a keyUsage that withholds keyCertSign, so it cannot sign certificates as a CA must (RFC 5280 sec. 6.1.4)");
+        }
+      }
+      function _assertSameName(a, b, which, must) {
+        if (!guard.name.dnEqual(a.rdns, b.rdns, _err, "cmp/bad-info-value", "a rootCaKeyUpdate name")) {
+          throw _err("cmp/bad-info-value", "the rootCaKeyUpdate " + which + " must " + must + " (RFC 9483 sec. 4.3.2); got " + JSON.stringify(a.dn));
+        }
+      }
+      async function _assertSignedBy(cert, signer, which, whose) {
+        if (!_engine || !_engine.verifyWithSpki) {
+          throw _err("cmp/bad-info-value", "the signature engine is unavailable, so a rootCaKeyUpdate cannot be checked; require pki.path to install it");
+        }
+        if (!guard.crypto.isOctetAligned(cert.signatureValue)) {
+          throw _err("cmp/bad-info-value", "the rootCaKeyUpdate " + which + " signature is not octet-aligned (a BIT STRING with unused bits), which no valid signature is (RFC 9483 sec. 4.3.2)");
+        }
+        var ok = await _engine.verifyWithSpki(cert.signatureAlgorithm, cert.signatureValue.bytes, signer.subjectPublicKeyInfo.bytes, cert.tbsBytes);
+        if (ok !== true) {
+          throw _err("cmp/bad-info-value", "the rootCaKeyUpdate " + which + " is not signed by " + whose + ", so it cannot carry the trust transition it exists for (RFC 9483 sec. 4.3.2)");
+        }
+      }
+      function _certificateArgument(value, what) {
+        var der;
+        if (typeof value === "string") {
+          try {
+            der = x509.pemDecode(value);
+          } catch (e) {
+            throw _err("cmp/bad-input", what + " is a string but not a PEM certificate", e);
+          }
+        } else if (value != null && Buffer.isBuffer(value.tbsBytes)) {
+          throw _err("cmp/bad-input", what + " must carry the certificate's own bytes (DER or PEM): a parsed certificate keeps no source DER, and this request has to send the bytes the issuer signed");
+        } else {
+          der = guard.bytes.snapshot(value, CmpError, "cmp/bad-input", what);
+        }
+        return _asCertificate(der, what, "cmp/bad-input");
+      }
+      function _asCertificate(der, what, code) {
+        try {
+          x509.parse(der);
+        } catch (e) {
+          throw _err(code || "cmp/bad-info-value", what + " is not a valid X.509 certificate (RFC 9483 sec. 4.3)", e);
+        }
+        return Buffer.from(der);
+      }
+      function _asCrl(der) {
+        try {
+          schemaCrl.parse(der);
+        } catch (e) {
+          throw _err("cmp/bad-info-value", "a crlUpdate entry is not a valid CertificateList (RFC 9483 sec. 4.3.4)", e);
+        }
+        return Buffer.from(der);
+      }
+      function _bindCrlToQuery(der) {
+        var parsed;
+        try {
+          parsed = schemaCrl.parse(der);
+        } catch (e) {
+          throw _err("cmp/bad-info-value", "a crlUpdate entry is not a valid CertificateList (RFC 9483 sec. 4.3.4)", e);
+        }
+        if (crlQuery && crlQuery.issuerName != null) {
+          var want = schemaCmp.readName(crlQuery.issuerName);
+          if (!guard.name.dnEqual(parsed.issuer.rdns, want.rdns, _err, "cmp/bad-info-value", "the crlUpdate issuer")) {
+            throw _err("cmp/bad-info-value", "the returned CRL was issued by " + JSON.stringify(parsed.issuer.dn) + ", not by the source this request named (RFC 9483 sec. 4.3.4)");
+          }
+        }
+        if (crlQuery && crlQuery.dpn != null) {
+          var idpDpn = null, idpCritical = false, crlExts = parsed.crlExtensions || [];
+          for (var xi = 0; xi < crlExts.length; xi++) {
+            if (crlExts[xi].oid !== OID_IDP) continue;
+            idpDpn = cmpBuild.decodeIdpDistributionPoint(crlExts[xi].value);
+            idpCritical = crlExts[xi].critical === true;
+            break;
+          }
+          if (idpDpn !== null && (!idpCritical || !guard.name.dpnCorresponds(crlQuery.dpn, idpDpn, _err, "cmp/bad-info-value", "the crlUpdate distribution point"))) {
+            throw _err("cmp/bad-info-value", "the returned CRL is scoped to a distribution point other than the one this request named, or marks that scope non-critical where a relying party may ignore it (RFC 9483 sec. 4.3.4, RFC 5280 sec. 5.2.5)");
+          }
+        }
+        if (crlQuery && crlQuery.thisUpdate != null) {
+          var asked = crlQuery.thisUpdate;
+          var got = guard.time.instantOf(parsed.thisUpdate, _err, "cmp/bad-info-value", "the returned CRL's thisUpdate");
+          if (got <= asked) {
+            throw _err("cmp/bad-info-value", "the returned CRL is no more recent than the thisUpdate this request supplied, so sec. 4.3.4 requires the response to carry no value at all");
+          }
+        }
+        return Buffer.from(der);
+      }
+      var OID_REG_CTRL_ALG_ID = oid.byName("algId");
+      var OID_REG_CTRL_RSA_KEY_LEN = oid.byName("rsaKeyLen");
+      function _isRsaAlgorithm(dotted) {
+        if (RSA_ARC_EXCLUDE[dotted] === 1) return false;
+        var arcs = oid.toArcs(dotted);
+        var underAny = false;
+        for (var a = 0; !underAny && a < RSA_ARCS.length; a++) {
+          var arc = RSA_ARCS[a];
+          if (arcs.length > arc.length) {
+            underAny = true;
+            for (var i = 0; underAny && i < arc.length; i++) {
+              underAny = arcs[i] === arc[i];
+            }
+          }
+        }
+        return underAny || RSA_OFF_ARC[dotted] === 1;
+      }
+      function _checkKeySpec(ctrl) {
+        if (ctrl.type === OID_REG_CTRL_RSA_KEY_LEN) {
+          var len;
+          try {
+            len = asn1.read.integer(asn1.decode(ctrl.value));
+          } catch (e) {
+            throw _err("cmp/bad-info-value", "a keySpec rsaKeyLen must be an INTEGER (RFC 9483 sec. 4.3.3)", e);
+          }
+          if (len <= 0n) throw _err("cmp/bad-info-value", "a keySpec rsaKeyLen must be a positive integer (RFC 9483 sec. 4.3.3); got " + len);
+          ctrl.rsaKeyLen = len;
+          return;
+        }
+        if (ctrl.type === OID_REG_CTRL_ALG_ID) {
+          var alg;
+          try {
+            alg = schemaCmp.readAlgorithmIdentifier(ctrl.value);
+          } catch (e) {
+            if (e && e.isCmpError) throw e;
+            throw _err("cmp/bad-info-value", "a keySpec algId must be an AlgorithmIdentifier (RFC 9483 sec. 4.3.3)", e);
+          }
+          if (_isRsaAlgorithm(alg.oid)) {
+            throw _err("cmp/bad-info-value", "a keySpec algId must give an algorithm other than RSA, whose requirement is stated with rsaKeyLen instead (RFC 9483 sec. 4.3.3); got " + (alg.name || alg.oid));
+          }
+          ctrl.algorithm = alg.oid;
+          ctrl.algorithmName = alg.name;
+          ctrl.algorithmParameters = alg.parameters;
+          return;
+        }
+        throw _err("cmp/bad-info-value", "a keySpec control must be id-regCtrl-algId or id-regCtrl-rsaKeyLen (RFC 9483 sec. 4.3.3); got " + ctrl.type);
+      }
       return {
         enroll,
+        revoke,
+        info,
         get transactionID() {
           return Buffer.from(transactionID);
         },
@@ -25669,16 +26454,7 @@ var require_path_validate = __commonJS({
         var dp = certDPs[i];
         if (!dp.distributionPoint) continue;
         if (dp.cRLIssuer && !crlIssuerNamesIssuer(dp.cRLIssuer, issuerRdns)) continue;
-        var cdpn = dp.distributionPoint;
-        if (idpDpn.kind === "fullName" && cdpn.kind === "fullName") {
-          for (var a = 0; a < idpDpn.names.length; a++) {
-            for (var c = 0; c < cdpn.names.length; c++) {
-              if (idpDpn.names[a].equals(cdpn.names[c])) return dp;
-            }
-          }
-        } else if (idpDpn.kind === "rdn" && cdpn.kind === "rdn") {
-          if (idpDpn.bytes.equals(cdpn.bytes)) return dp;
-        }
+        if (guard.name.dpnCorresponds(idpDpn, dp.distributionPoint, E, "path/bad-idp", "a CRL distribution point")) return dp;
       }
       return null;
     }
@@ -26014,7 +26790,7 @@ var require_path_validate = __commonJS({
       dnEqual
     });
     cmpVerify.setEngine({ verifyWithSpki: _verifyWithSpki, build, validate });
-    cmpSession.setEngine({ build, validate, toAnchor, coerceCert });
+    cmpSession.setEngine({ build, validate, toAnchor, coerceCert, verifyWithSpki: _verifyWithSpki });
     cmsVerify.setEngine({
       build,
       validate,
@@ -36593,8 +37369,24 @@ var require_acme = __commonJS({
       }
       return out;
     }
+    var _CLIENT_OPTS = {
+      accountKey: 1,
+      accountJwk: 1,
+      alg: 1,
+      transport: 1,
+      tls: 1,
+      timeout: 1,
+      maxResponseBytes: 1,
+      maxRedirects: 1,
+      maxNonceRetries: 1,
+      maxPolls: 1,
+      maxTotalWait: 1,
+      sleep: 1,
+      clock: 1
+    };
     function client(directoryUrl, opts) {
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, E, "acme/bad-input", "pki.acme.client options");
+      guard.identifier.assertKnownKeys(opts, _CLIENT_OPTS, E, "acme/bad-input", "unknown pki.acme.client option ");
       if (!opts.accountKey) throw E("acme/bad-input", "client requires opts.accountKey (the account private key)");
       if (!_isObject(opts.accountJwk)) throw E("acme/bad-input", "client requires opts.accountJwk (the account public JWK)");
       if (!_isString(opts.alg)) throw E("acme/bad-input", "client requires opts.alg (the account-key JWS alg)");
@@ -37747,11 +38539,13 @@ var require_trust = __commonJS({
       }
       return { anchors: _dedupAnchors(anchors) };
     }
+    var _ANCHOR_OPTS = { purpose: 1 };
     function anchor(entry, opts) {
       if (!entry || typeof entry !== "object") {
         throw E("trust/bad-input", "anchor expects a trust-store entry ({ name, publicKey, algorithm, ... })");
       }
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, E, "trust/bad-input", "pki.trust.anchor options");
+      guard.identifier.assertKnownKeys(opts, _ANCHOR_OPTS, E, "trust/bad-input", "unknown pki.trust.anchor option ");
       var derived = _DERIVED_FROM.get(entry);
       var meta = derived || entry;
       if (!derived && (!Buffer.isBuffer(entry.publicKey) || typeof entry.algorithm !== "string" || !entry.name || !Array.isArray(entry.name.rdns))) {