@blamejs/core 0.18.38 → 0.18.40

package/lib/vendor/blamejs-pki.cjs

@@ -1,4 +1,4 @@
-// @blamejs/pki v0.5.10 — vendored (Apache-2.0). Zero-dep pure CJS.
+// @blamejs/pki v0.5.16 — 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.10",
+      version: "0.5.16",
       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",
@@ -698,21 +698,623 @@ var require_constants = __commonJS({
   }
 });
 
+// node_modules/@blamejs/pki/lib/guard-intrinsic.js
+var require_guard_intrinsic = __commonJS({
+  "node_modules/@blamejs/pki/lib/guard-intrinsic.js"(exports2, module2) {
+    "use strict";
+    var _utilTypes = require("util").types;
+    var _call = Function.prototype.call;
+    var _bind = Function.prototype.bind;
+    var _reflectApply = Reflect.apply;
+    var _isArray = Array.isArray;
+    var _bufferFrom = Buffer.from;
+    var _bufferAlloc = Buffer.alloc;
+    var _bufferConcat = Buffer.concat;
+    var _bufferIsBuffer = Buffer.isBuffer;
+    var _bufferByteLength = Buffer.byteLength;
+    var _bufferCompare = Buffer.compare;
+    var _isView = ArrayBuffer.isView;
+    var _isInteger = Number.isInteger;
+    var _isSafeInteger = Number.isSafeInteger;
+    var _fromCharCode = String.fromCharCode;
+    var _objectCreate = Object.create;
+    var _getPrototypeOf = Object.getPrototypeOf;
+    var _setPrototypeOf = Object.setPrototypeOf;
+    var _getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+    var _getOwnPropertyNames = Object.getOwnPropertyNames;
+    var _defineProperty = Object.defineProperty;
+    var _objectKeys = Object.keys;
+    var _objectAssign = Object.assign;
+    var _objectFreeze = Object.freeze;
+    var _isExtensible = Object.isExtensible;
+    var _ownKeys = Reflect.ownKeys;
+    var _jsonStringify = JSON.stringify;
+    var _mathFloor = Math.floor;
+    var _mathCeil = Math.ceil;
+    var _mathMin = Math.min;
+    var _promiseResolve = Promise.resolve;
+    var _promiseReject = Promise.reject;
+    var _arrForEach = uncurry(Array.prototype.forEach);
+    var _arrMap = uncurry(Array.prototype.map);
+    var _arrFilter = uncurry(Array.prototype.filter);
+    var _arrEvery = uncurry(Array.prototype.every);
+    var _arrSome = uncurry(Array.prototype.some);
+    var _arrIndexOf = uncurry(Array.prototype.indexOf);
+    var _arrSort = uncurry(Array.prototype.sort);
+    var _arrConcat = uncurry(Array.prototype.concat);
+    var _arrSlice = uncurry(Array.prototype.slice);
+    var _arrJoin = uncurry(Array.prototype.join);
+    var _setAdd = uncurry(Set.prototype.add);
+    var _setHas = uncurry(Set.prototype.has);
+    var _mapGet = uncurry(Map.prototype.get);
+    var _mapSet = uncurry(Map.prototype.set);
+    var _mapHas = uncurry(Map.prototype.has);
+    var _weakGet = uncurry(WeakMap.prototype.get);
+    var _weakSet = uncurry(WeakMap.prototype.set);
+    var _weakHas = uncurry(WeakMap.prototype.has);
+    var _taSet = uncurry(Uint8Array.prototype.set);
+    var _hasOwn = uncurry(Object.prototype.hasOwnProperty);
+    var _String = String;
+    var _Number = Number;
+    var _Boolean = Boolean;
+    var _BigInt = BigInt;
+    var _Date = Date;
+    var _isFinite = globalThis.isFinite;
+    var _ArrayBuffer = ArrayBuffer;
+    var _Uint8Array = Uint8Array;
+    var _DataView = DataView;
+    var _ObjectFn = Object;
+    var _ObjectProto = Object.prototype;
+    var _BufferProto = Buffer.prototype;
+    var _ArrayProto = Array.prototype;
+    var _Set = Set;
+    var _Map = Map;
+    var _WeakMap = WeakMap;
+    var _types = /* @__PURE__ */ Object.create(null);
+    var _typeNames = Object.getOwnPropertyNames(_utilTypes);
+    for (_i = 0; _i < _typeNames.length; _i++) {
+      if (typeof _utilTypes[_typeNames[_i]] === "function") {
+        _types[_typeNames[_i]] = _utilTypes[_typeNames[_i]];
+      }
+    }
+    var _i;
+    Object.freeze(_types);
+    function uncurry(fn) {
+      if (typeof fn !== "function") {
+        throw new TypeError("guard.intrinsic.uncurry: expects the captured function, got " + typeof fn);
+      }
+      return _reflectApply(_bind, _call, [fn]);
+    }
+    function getter(proto, name, who) {
+      var d = _getOwnPropertyDescriptor(proto, name);
+      if (!d || typeof d.get !== "function") {
+        throw new TypeError("guard.intrinsic.getter: this runtime has no intrinsic " + who + "." + name + " accessor, so the value's own would have to be invoked instead");
+      }
+      return uncurry(d.get);
+    }
+    var _taByteLength = getter(_getPrototypeOf(Uint8Array.prototype), "byteLength", "%TypedArray%.prototype");
+    var _dvByteLength = getter(DataView.prototype, "byteLength", "DataView.prototype");
+    function sizeOf(value) {
+      if (typeof value === "string") return value.length;
+      if (_types.isDataView(value)) return _dvByteLength(value);
+      if (_types.isTypedArray(value)) return _taByteLength(value);
+      throw new TypeError("guard.intrinsic.sizeOf: expects a string or a byte view, got " + (value === null ? "null" : typeof value));
+    }
+    module2.exports = {
+      uncurry,
+      getter,
+      sizeOf,
+      types: _types,
+      isArray: _isArray,
+      bufferFrom: _bufferFrom,
+      bufferAlloc: _bufferAlloc,
+      bufferConcat: _bufferConcat,
+      isBuffer: _bufferIsBuffer,
+      byteLength: _bufferByteLength,
+      compare: _bufferCompare,
+      isView: _isView,
+      isInteger: _isInteger,
+      isSafeInteger: _isSafeInteger,
+      fromCharCode: _fromCharCode,
+      create: _objectCreate,
+      getPrototypeOf: _getPrototypeOf,
+      setPrototypeOf: _setPrototypeOf,
+      getOwnPropertyDescriptor: _getOwnPropertyDescriptor,
+      getOwnPropertyNames: _getOwnPropertyNames,
+      defineProperty: _defineProperty,
+      keys: _objectKeys,
+      assign: _objectAssign,
+      freeze: _objectFreeze,
+      isExtensible: _isExtensible,
+      ownKeys: _ownKeys,
+      stringify: _jsonStringify,
+      floor: _mathFloor,
+      ceil: _mathCeil,
+      min: _mathMin,
+      promiseResolve: _promiseResolve,
+      promiseReject: _promiseReject,
+      forEach: _arrForEach,
+      map: _arrMap,
+      filter: _arrFilter,
+      every: _arrEvery,
+      some: _arrSome,
+      indexOf: _arrIndexOf,
+      sort: _arrSort,
+      concat: _arrConcat,
+      arraySlice: _arrSlice,
+      join: _arrJoin,
+      hasOwn: _hasOwn,
+      // Invocation itself. `fn.apply(...)` reads `apply` off Function.prototype, so a replacement
+      // decides whether a verb's body runs at all and what it appears to return; `Reflect.apply` is
+      // invoked directly and consults no property of the function.
+      apply: _reflectApply,
+      // And the cleanup half of a promise chain: `.finally` is where a copied secret is released, so a
+      // replacement that drops its callback leaves the plaintext copy alive for the process's lifetime.
+      promiseFinally: uncurry(Promise.prototype["finally"]),
+      String: _String,
+      Number: _Number,
+      Boolean: _Boolean,
+      BigInt: _BigInt,
+      Date: _Date,
+      isFinite: _isFinite,
+      ArrayBuffer: _ArrayBuffer,
+      Uint8Array: _Uint8Array,
+      DataView: _DataView,
+      Object: _ObjectFn,
+      ObjectProto: _ObjectProto,
+      BufferProto: _BufferProto,
+      ArrayProto: _ArrayProto,
+      setAdd: _setAdd,
+      setHas: _setHas,
+      mapGet: _mapGet,
+      mapSet: _mapSet,
+      mapHas: _mapHas,
+      weakGet: _weakGet,
+      weakSet: _weakSet,
+      weakHas: _weakHas,
+      typedArraySet: _taSet,
+      Set: _Set,
+      Map: _Map,
+      WeakMap: _WeakMap
+    };
+  }
+});
+
 // node_modules/@blamejs/pki/lib/guard-async.js
 var require_guard_async = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-async.js"(exports2, module2) {
     "use strict";
+    var _intrinsic = require_guard_intrinsic();
+    var _resolve = _intrinsic.uncurry(_intrinsic.promiseResolve);
+    var _reject = _intrinsic.uncurry(_intrinsic.promiseReject);
+    var _Promise = Promise;
     function deferred(body) {
       try {
-        return Promise.resolve(body());
+        return _resolve(_Promise, body());
       } catch (e) {
-        return Promise.reject(e);
+        return _reject(_Promise, e);
       }
     }
     module2.exports = { deferred };
   }
 });
 
+// node_modules/@blamejs/pki/lib/guard-identifier.js
+var require_guard_identifier = __commonJS({
+  "node_modules/@blamejs/pki/lib/guard-identifier.js"(exports2, module2) {
+    "use strict";
+    var intrinsic = require_guard_intrinsic();
+    var util = { types: intrinsic.types };
+    var _isArray = intrinsic.isArray;
+    var _create = intrinsic.create;
+    var _getPrototypeOf = intrinsic.getPrototypeOf;
+    var _setPrototypeOf = intrinsic.setPrototypeOf;
+    var _getOwnPropertyDescriptor = intrinsic.getOwnPropertyDescriptor;
+    var _getOwnPropertyNames = intrinsic.getOwnPropertyNames;
+    var _defineProperty = intrinsic.defineProperty;
+    var _ownKeys = intrinsic.ownKeys;
+    var _isView = intrinsic.isView;
+    var _isInteger = intrinsic.isInteger;
+    var _stringify = intrinsic.stringify;
+    var _forEach = intrinsic.forEach;
+    var _map = intrinsic.map;
+    var _filter = intrinsic.filter;
+    var _every = intrinsic.every;
+    var _some = intrinsic.some;
+    var _indexOf = intrinsic.indexOf;
+    var _sort = intrinsic.sort;
+    var _setAdd = intrinsic.setAdd;
+    var _setHas = intrinsic.setHas;
+    var _mapGet = intrinsic.mapGet;
+    var _mapSet = intrinsic.mapSet;
+    var _mapHas = intrinsic.mapHas;
+    var _Set = intrinsic.Set;
+    var _Map = intrinsic.Map;
+    var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+    var _strSplit = intrinsic.uncurry(String.prototype.split);
+    var _hasOwn = intrinsic.hasOwn;
+    var _String = intrinsic.String;
+    var _Number = intrinsic.Number;
+    var _BigInt = intrinsic.BigInt;
+    var _Object = intrinsic.Object;
+    var _BufferProto = intrinsic.BufferProto;
+    function _append(arr, v) {
+      _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true });
+    }
+    function _isDottedDecimal(str) {
+      if (str.length === 0) return false;
+      var arcs = 0, digits = 0, leadingZero = false;
+      for (var i = 0; i < str.length; i++) {
+        var c = _charCodeAt(str, i);
+        if (c === 46) {
+          if (digits === 0 || leadingZero) return false;
+          arcs++;
+          digits = 0;
+          leadingZero = false;
+          continue;
+        }
+        if (c < 48 || c > 57) return false;
+        if (digits === 1 && _charCodeAt(str, i - 1) === 48) leadingZero = true;
+        digits++;
+      }
+      if (digits === 0 || leadingZero) return false;
+      return arcs >= 1;
+    }
+    function assertCanonicalOid(str, E, code, label, boundsCode) {
+      var who = label || "OID";
+      if (typeof str !== "string" || !_isDottedDecimal(str)) {
+        throw E(code, who + " must be a canonical dotted-decimal OID string of two or more arcs with no leading-zero component");
+      }
+      if (boundsCode === null) return str;
+      var bcode = boundsCode === void 0 ? code : boundsCode;
+      var parts = _strSplit(str, ".");
+      var root = _BigInt(parts[0]);
+      var second = _BigInt(parts[1]);
+      if (root > 2n) throw E(bcode, who + " root arc must be 0, 1, or 2 (X.660)");
+      if (root < 2n && second > 39n) throw E(bcode, who + " second arc must be 0..39 under roots 0 and 1 (X.660)");
+      return str;
+    }
+    function assertKnownKeys(obj, known, E, code, message) {
+      _refuseUnenumerable(obj, E, code, "the options");
+      var describe = typeof message === "function" ? message : function(k) {
+        return message + _stringify(k);
+      };
+      _forEach(_readableNames(obj), function(k) {
+        if (_hasOwn(known, k)) return;
+        throw E(code, describe(typeof k === "symbol" ? _String(k) : k));
+      });
+    }
+    var _PRISTINE_OBJECT_PROTO = (function() {
+      var s = _create(null);
+      _forEach([
+        "constructor",
+        "hasOwnProperty",
+        "isPrototypeOf",
+        "propertyIsEnumerable",
+        "toLocaleString",
+        "toString",
+        "valueOf",
+        "__defineGetter__",
+        "__defineSetter__",
+        "__lookupGetter__",
+        "__lookupSetter__",
+        "__proto__"
+      ], function(k) {
+        s[k] = 1;
+      });
+      return s;
+    })();
+    function _looksBuiltIn(d) {
+      return !!d && (!!d.get || !!d.set || typeof d.value === "function");
+    }
+    function _requireFactory(E) {
+      if (typeof E !== "function") {
+        throw new TypeError("guard.identifier needs an error factory called as E(code, message); a class is not one, so adapt it at the call site");
+      }
+    }
+    function _refuseUnenumerable(v, E, code, label) {
+      _requireFactory(E);
+      if (v === null || typeof v !== "object") return;
+      var visited = new _Set();
+      for (var o = v; o && !_setHas(visited, o); o = _getPrototypeOf(o)) {
+        _setAdd(visited, o);
+        if (!util.types.isProxy(o)) continue;
+        throw E(code, label + (o === v ? " is" : " inherits from") + " a Proxy, whose reported keys need not match what it answers, so an option it holds cannot be found; pass a plain object");
+      }
+    }
+    function _isMethodOf(from, k, fn) {
+      var visited = new _Set();
+      for (var o = from; o && !_setHas(visited, o); o = _getPrototypeOf(o)) {
+        _setAdd(visited, o);
+        var d = _getOwnPropertyDescriptor(o, k);
+        if (!d) continue;
+        return !d.get && !d.set && d.value === fn;
+      }
+      return false;
+    }
+    function _isArrayIndex(k) {
+      var n = _Number(k);
+      return _isInteger(n) && n >= 0 && n < 4294967295 && _String(n) === k;
+    }
+    function _isIndexedKind(v) {
+      return _isArray(v) || _isView(v) && !util.types.isDataView(v);
+    }
+    var _ARRAY_PROTO_MEMBERS = ["length", Symbol.unscopables];
+    var _REGEXP_PROTO_MEMBERS = [
+      "source",
+      "flags",
+      "global",
+      "ignoreCase",
+      "multiline",
+      "dotAll",
+      "unicode",
+      "unicodeSets",
+      "sticky",
+      "hasIndices"
+    ];
+    var _SIZED_PROTO_MEMBERS = ["size", Symbol.toStringTag];
+    var _WEAK_PROTO_MEMBERS = [Symbol.toStringTag];
+    var _ARRAYBUFFER_PROTO_MEMBERS = [
+      "byteLength",
+      "maxByteLength",
+      "resizable",
+      "detached",
+      Symbol.toStringTag
+    ];
+    var _SHARED_PROTO_MEMBERS = ["byteLength", "maxByteLength", "growable", Symbol.toStringTag];
+    var _DATAVIEW_PROTO_MEMBERS = ["buffer", "byteLength", "byteOffset", Symbol.toStringTag];
+    var _TYPED_PROTO_MEMBERS = ["buffer", "byteLength", "byteOffset", "length", Symbol.toStringTag];
+    var _CONCRETE_TYPED_MEMBERS = ["BYTES_PER_ELEMENT"];
+    var _BUFFER_PROTO_MEMBERS = ["parent", "offset"];
+    var _ARRAY_MEMBERS = _ARRAY_PROTO_MEMBERS;
+    var _REGEXP_MEMBERS = ["lastIndex"].concat(_REGEXP_PROTO_MEMBERS);
+    var _VIEW_MEMBERS = _TYPED_PROTO_MEMBERS.concat(_CONCRETE_TYPED_MEMBERS);
+    var _BUFFER_KIND_MEMBERS = _VIEW_MEMBERS.concat(_BUFFER_PROTO_MEMBERS);
+    var _DATAVIEW_MEMBERS = _DATAVIEW_PROTO_MEMBERS;
+    var _ARRAYBUFFER_MEMBERS = _ARRAYBUFFER_PROTO_MEMBERS;
+    var _SHARED_MEMBERS = _SHARED_PROTO_MEMBERS;
+    var _TYPED_ARRAY_PROTO = _getPrototypeOf(Uint8Array.prototype);
+    var _INTRINSIC_HOLDERS = (function() {
+      var m = new _Map([[_TYPED_ARRAY_PROTO, _TYPED_PROTO_MEMBERS]]);
+      function pair(ctor, members) {
+        if (ctor && ctor.prototype) _mapSet(m, ctor.prototype, members);
+      }
+      pair(Array, _ARRAY_PROTO_MEMBERS);
+      pair(RegExp, _REGEXP_PROTO_MEMBERS);
+      _forEach([Map, Set], function(c) {
+        pair(c, _SIZED_PROTO_MEMBERS);
+      });
+      _forEach([WeakMap, WeakSet], function(c) {
+        pair(c, _WEAK_PROTO_MEMBERS);
+      });
+      pair(ArrayBuffer, _ARRAYBUFFER_PROTO_MEMBERS);
+      pair(typeof SharedArrayBuffer === "function" ? SharedArrayBuffer : null, _SHARED_PROTO_MEMBERS);
+      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;
+        if (!C.prototype || _getPrototypeOf(C.prototype) !== _TYPED_ARRAY_PROTO) return;
+        _mapSet(m, C.prototype, _CONCRETE_TYPED_MEMBERS);
+      });
+      return m;
+    })();
+    function _holderMembers(o) {
+      return _mapHas(_INTRINSIC_HOLDERS, o) ? _mapGet(_INTRINSIC_HOLDERS, o) : null;
+    }
+    function _isNodeBuffer(v) {
+      if (!util.types.isUint8Array(v)) return false;
+      var visited = new _Set();
+      for (var o = v; o && !_setHas(visited, o); o = _getPrototypeOf(o)) {
+        _setAdd(visited, o);
+        if (o === _BufferProto) return true;
+      }
+      return false;
+    }
+    function _kindMembers(v) {
+      if (v === null || v === void 0) return [];
+      if (_isArray(v)) return _ARRAY_MEMBERS;
+      if (_isNodeBuffer(v)) return _BUFFER_KIND_MEMBERS;
+      if (util.types.isDataView(v)) return _DATAVIEW_MEMBERS;
+      if (_isView(v)) return _VIEW_MEMBERS;
+      if (util.types.isArrayBuffer(v)) return _ARRAYBUFFER_MEMBERS;
+      if (util.types.isSharedArrayBuffer(v)) return _SHARED_MEMBERS;
+      if (util.types.isRegExp(v)) return _REGEXP_MEMBERS;
+      if (util.types.isWeakMap(v) || util.types.isWeakSet(v)) return _WEAK_PROTO_MEMBERS;
+      if (util.types.isMap(v) || util.types.isSet(v)) return _SIZED_PROTO_MEMBERS;
+      return [];
+    }
+    function _isOwnStructuralName(v, k) {
+      return util.types.isRegExp(v) && k === "lastIndex";
+    }
+    function _looksIntrinsic(d) {
+      return !!d && (!!d.get || !!d.set || typeof d.value === "function" || d.writable === false || d.configurable === false);
+    }
+    function _shadowsAnother(v, k, holder) {
+      var visited = new _Set();
+      var past = false;
+      for (var o = v; o !== null && o !== void 0 && !_setHas(visited, o); o = _getPrototypeOf(o)) {
+        _setAdd(visited, o);
+        if (o === holder) {
+          past = true;
+          continue;
+        }
+        if (past && _getOwnPropertyDescriptor(o, k)) return true;
+      }
+      return false;
+    }
+    function _readableNames(obj) {
+      var seen = _create(null);
+      var out = [];
+      var o = obj === null || obj === void 0 ? null : _Object(obj);
+      var indexedSelf = _isIndexedKind(o);
+      var members = _kindMembers(o);
+      var visited = new _Set();
+      while (o && !_setHas(visited, o)) {
+        _setAdd(visited, o);
+        var inherited = o !== obj;
+        var above = _getPrototypeOf(o);
+        var atObjectProto = inherited && above === null;
+        _forEach(_ownKeys(o), function(k) {
+          if (seen[k]) return;
+          if (indexedSelf && typeof k === "string" && _isArrayIndex(k)) return;
+          if (indexedSelf && k === "length" && !inherited) return;
+          if (_isOwnStructuralName(obj, k)) return;
+          var d = _getOwnPropertyDescriptor(o, k);
+          var here = _holderMembers(o);
+          if (inherited && _looksIntrinsic(d) && !_shadowsAnother(obj, k, o) && (here === null ? _indexOf(members, k) !== -1 : _indexOf(here, k) !== -1)) return;
+          if (atObjectProto) {
+            if (_PRISTINE_OBJECT_PROTO[k] && _looksBuiltIn(d)) return;
+            seen[k] = 1;
+            _append(out, k);
+            return;
+          }
+          if (d && !d.get && !d.set && typeof d.value === "function" && (inherited || _isMethodOf(above, k, d.value))) return;
+          seen[k] = 1;
+          _append(out, k);
+        });
+        o = above;
+      }
+      return out;
+    }
+    function readableNames(obj, E, code, label) {
+      _refuseUnenumerable(obj, E, code, label);
+      return _readableNames(obj);
+    }
+    function readableIndices(obj, E, code, label) {
+      _refuseUnenumerable(obj, E, code, label);
+      if (!_isArray(obj)) return [];
+      var own = _getOwnPropertyDescriptor(obj, "length");
+      var limit = own ? own.value : 0;
+      var seen = _create(null);
+      var out = [];
+      var visited = new _Set();
+      for (var o = obj; o && !_setHas(visited, o); o = _getPrototypeOf(o)) {
+        _setAdd(visited, o);
+        _forEach(_ownKeys(o), function(k) {
+          if (typeof k !== "string" || !_isArrayIndex(k) || seen[k]) return;
+          if (_Number(k) >= limit) return;
+          seen[k] = 1;
+          _append(out, k);
+        });
+      }
+      return _sort(out, function(a, b) {
+        return _Number(a) - _Number(b);
+      });
+    }
+    function _notAnOptionsBag(v) {
+      if (util.types.isBoxedPrimitive(v)) return "a boxed primitive";
+      if (util.types.isNativeError(v)) return "an Error";
+      if (util.types.isPromise(v)) return "a Promise";
+      if (util.types.isArgumentsObject(v)) return "an arguments object";
+      return null;
+    }
+    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");
+      _refuseUnenumerable(opts, E, code, label);
+      if (_isNodeBuffer(opts)) throw E(code, label + " must be an object");
+      var wrong = _notAnOptionsBag(opts);
+      if (wrong) throw E(code, label + ": " + wrong + " is not an options bag; pass a plain object");
+      return _settle(opts, E, code, label);
+    }
+    function _descriptorHolder(v, k) {
+      var visited = new _Set();
+      for (var o = v; o !== null && o !== void 0 && !_setHas(visited, o); o = _getPrototypeOf(o)) {
+        _setAdd(visited, o);
+        var d = _getOwnPropertyDescriptor(o, k);
+        if (d) return d;
+      }
+      return null;
+    }
+    function refuseAccessorFields(obj, names, E, code, label) {
+      for (var i = 0; i < names.length; i++) {
+        var holder = _descriptorHolder(obj, names[i]);
+        if (holder && (holder.get || holder.set)) {
+          throw E(code, label + " supplies " + _stringify(typeof names[i] === "symbol" ? _String(names[i]) : names[i]) + " through an accessor, whose value can differ between the check and the read; pass an object whose fields are plain values");
+        }
+      }
+    }
+    function _settle(opts, E, code, label) {
+      function readAll(names) {
+        for (var i = 0; i < names.length; i++) {
+          try {
+            void opts[names[i]];
+          } catch (_e) {
+            throw E(code, label + ": reading " + _stringify(typeof names[i] === "symbol" ? _String(names[i]) : names[i]) + " threw");
+          }
+        }
+      }
+      var before = _readableNames(opts);
+      refuseAccessorFields(opts, before, E, code, label);
+      readAll(before);
+      var after = _readableNames(opts);
+      var same = after.length === before.length;
+      for (var j = 0; same && j < after.length; j++) same = _indexOf(before, after[j]) !== -1;
+      if (!same) {
+        throw E(code, label + " changes which options it carries while they are read, so no set of them can be checked; pass an object whose properties are plain values");
+      }
+      return opts;
+    }
+    module2.exports = {
+      assertCanonicalOid,
+      assertKnownKeys,
+      optionsObject,
+      refuseAccessorFields,
+      // Exported so a caller that forwards an options bag copies the same surface this module
+      // accepts. A narrower enumeration such as `Object.keys` admits a name here and then drops
+      // it on the way, which is worse than refusing it. The option is reported valid and then
+      // does nothing at the place it was meant to act.
+      readableNames,
+      // Exported for the same reason as its sibling: a caller copying an array has to reach the
+      // elements a read reaches, and the own keys are not that set.
+      readableIndices
+    };
+  }
+});
+
+// node_modules/@blamejs/pki/lib/guard-time.js
+var require_guard_time = __commonJS({
+  "node_modules/@blamejs/pki/lib/guard-time.js"(exports2, module2) {
+    "use strict";
+    var util = { types: require_guard_intrinsic().types };
+    var _isNaN = Number.isNaN;
+    var _dateGetTime = require_guard_intrinsic().uncurry(Date.prototype.getTime);
+    function instantOf(value) {
+      return _dateGetTime(value);
+    }
+    function assertValid(value, E, code, label) {
+      if (!util.types.isDate(value) || _isNaN(instantOf(value))) {
+        throw E(code, (label || "value") + " must be a valid Date");
+      }
+      return value;
+    }
+    function within(instant, lower, upper, E, code, label, opts) {
+      assertValid(instant, E, code, label);
+      assertValid(lower, E, code, (label || "window") + " lower bound");
+      assertValid(upper, E, code, (label || "window") + " upper bound");
+      var t = instantOf(instant);
+      var lo = instantOf(lower);
+      var hi = instantOf(upper);
+      return t >= lo && (opts && opts.upperInclusive ? t <= hi : t < hi);
+    }
+    function isDate(value) {
+      return util.types.isDate(value);
+    }
+    module2.exports = {
+      assertValid,
+      instantOf,
+      isDate,
+      within
+    };
+  }
+});
+
 // node_modules/@blamejs/pki/lib/oid.js
 var require_oid = __commonJS({
   "node_modules/@blamejs/pki/lib/oid.js"(exports2, module2) {
@@ -2482,10 +3084,11 @@ var require_webcrypto = __commonJS({
       if (!ArrayBuffer.isView(typedArray) || typedArray instanceof Float32Array || typedArray instanceof Float64Array || typedArray instanceof DataView) {
         throw new WebCryptoError("webcrypto/data", "getRandomValues: expected an integer TypedArray");
       }
-      if (typedArray.byteLength > MAX_RANDOM_BYTES) {
+      var out = guard.bytes.outputView(typedArray, WebCryptoError, "webcrypto/data", "getRandomValues");
+      if (out.length > MAX_RANDOM_BYTES) {
         throw new WebCryptoError("webcrypto/data", "getRandomValues: byteLength exceeds " + MAX_RANDOM_BYTES);
       }
-      nodeCrypto.randomFillSync(guard.bytes.source(typedArray, WebCryptoError, "webcrypto/data", "getRandomValues"));
+      nodeCrypto.randomFillSync(out);
       return typedArray;
     };
     Crypto.prototype.randomUUID = function randomUUID() {
@@ -2569,44 +3172,62 @@ var require_guard_parsed = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-parsed.js"(exports2, module2) {
     "use strict";
     var bytes = require_guard_bytes();
+    var time = require_guard_time();
+    var _isArray = require_guard_intrinsic().isArray;
+    var _bufferFrom = require_guard_intrinsic().bufferFrom;
+    var _ObjectProto = require_guard_intrinsic().ObjectProto;
+    var _isBuffer = require_guard_intrinsic().isBuffer;
+    var _create = require_guard_intrinsic().create;
+    var _assign = require_guard_intrinsic().assign;
+    var _getPrototypeOf = require_guard_intrinsic().getPrototypeOf;
+    var _getOwnPropertyNames = require_guard_intrinsic().getOwnPropertyNames;
+    var _every = require_guard_intrinsic().every;
+    var _weakGet = require_guard_intrinsic().weakGet;
+    var _weakSet = require_guard_intrinsic().weakSet;
+    var _weakHas = require_guard_intrinsic().weakHas;
+    var _WeakMap = require_guard_intrinsic().WeakMap;
+    var _defineProperty = require_guard_intrinsic().defineProperty;
+    function _append(arr, v) {
+      _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true });
+    }
     function _isBytes(x) {
-      return Buffer.isBuffer(x) || ArrayBuffer.isView(x) || x instanceof ArrayBuffer;
+      return bytes.isByteSource(x);
     }
     function _isAttributeTypeAndValue(a) {
       return !!a && typeof a.type === "string" && _isOptName(a.name) && typeof a.value === "string";
     }
     function _isRdnSequence(rdns) {
-      if (!Array.isArray(rdns)) return false;
+      if (!_isArray(rdns)) return false;
       for (var i = 0; i < rdns.length; i++) {
-        if (!Array.isArray(rdns[i]) || rdns[i].length === 0) return false;
-        if (!rdns[i].every(_isAttributeTypeAndValue)) return false;
+        if (!_isArray(rdns[i]) || rdns[i].length === 0) return false;
+        if (!_every(rdns[i], _isAttributeTypeAndValue)) return false;
       }
       return true;
     }
     function _isName(n) {
-      return !!n && _isRdnSequence(n.rdns) && Buffer.isBuffer(n.bytes) && typeof n.dn === "string";
+      return !!n && _isRdnSequence(n.rdns) && _isBuffer(n.bytes) && typeof n.dn === "string";
     }
     function _isOptName(v) {
       return typeof v === "string" || v === null;
     }
     function _isAlgorithmIdentifier(a) {
-      return !!a && typeof a.oid === "string" && _isOptName(a.name) && (Buffer.isBuffer(a.parameters) || a.parameters === null);
+      return !!a && typeof a.oid === "string" && _isOptName(a.name) && (_isBuffer(a.parameters) || a.parameters === null);
     }
     function _isBitString(b) {
-      return !!b && Buffer.isBuffer(b.bytes) && typeof b.unusedBits === "number";
+      return !!b && _isBuffer(b.bytes) && typeof b.unusedBits === "number";
     }
     function _isExtensionEntry(e) {
-      return !!e && typeof e.oid === "string" && _isOptName(e.name) && typeof e.critical === "boolean" && Buffer.isBuffer(e.value);
+      return !!e && typeof e.oid === "string" && _isOptName(e.name) && typeof e.critical === "boolean" && _isBuffer(e.value);
     }
     function _isCrlExtensionEntry(e) {
       return !!e && typeof e.oid === "string" && _isOptName(e.name) && typeof e.critical === "boolean" && e.value !== void 0;
     }
     function isCert(o) {
-      return !!o && typeof o === "object" && Buffer.isBuffer(o.tbsBytes) && typeof o.version === "number" && typeof o.serialNumber === "bigint" && typeof o.serialNumberHex === "string" && _isAlgorithmIdentifier(o.signatureAlgorithm) && _isAlgorithmIdentifier(o.tbsSignatureAlgorithm) && _isBitString(o.signatureValue) && !!o.validity && o.validity.notBefore instanceof Date && o.validity.notAfter instanceof Date && _isName(o.issuer) && _isName(o.subject) && !!o.subjectPublicKeyInfo && Buffer.isBuffer(o.subjectPublicKeyInfo.bytes) && _isAlgorithmIdentifier(o.subjectPublicKeyInfo.algorithm) && _isBitString(o.subjectPublicKeyInfo.publicKey) && Array.isArray(o.extensions) && o.extensions.every(_isExtensionEntry);
+      return !!o && typeof o === "object" && _isBuffer(o.tbsBytes) && typeof o.version === "number" && typeof o.serialNumber === "bigint" && typeof o.serialNumberHex === "string" && _isAlgorithmIdentifier(o.signatureAlgorithm) && _isAlgorithmIdentifier(o.tbsSignatureAlgorithm) && _isBitString(o.signatureValue) && !!o.validity && time.isDate(o.validity.notBefore) && time.isDate(o.validity.notAfter) && _isName(o.issuer) && _isName(o.subject) && !!o.subjectPublicKeyInfo && _isBuffer(o.subjectPublicKeyInfo.bytes) && _isAlgorithmIdentifier(o.subjectPublicKeyInfo.algorithm) && _isBitString(o.subjectPublicKeyInfo.publicKey) && _isArray(o.extensions) && _every(o.extensions, _isExtensionEntry);
     }
     function isCrl(o) {
-      return !!o && typeof o === "object" && Buffer.isBuffer(o.tbsBytes) && typeof o.version === "number" && _isAlgorithmIdentifier(o.signatureAlgorithm) && _isBitString(o.signatureValue) && _isName(o.issuer) && o.thisUpdate instanceof Date && (o.nextUpdate === null || o.nextUpdate instanceof Date) && Array.isArray(o.crlExtensions) && o.crlExtensions.every(_isCrlExtensionEntry) && Array.isArray(o.revokedCertificates) && o.revokedCertificates.every(function(e) {
-        return !!e && typeof e.serialNumber === "bigint" && typeof e.serialNumberHex === "string" && e.revocationDate instanceof Date && Array.isArray(e.crlEntryExtensions) && e.crlEntryExtensions.every(_isCrlExtensionEntry);
+      return !!o && typeof o === "object" && _isBuffer(o.tbsBytes) && typeof o.version === "number" && _isAlgorithmIdentifier(o.signatureAlgorithm) && _isBitString(o.signatureValue) && _isName(o.issuer) && time.isDate(o.thisUpdate) && (o.nextUpdate === null || time.isDate(o.nextUpdate)) && _isArray(o.crlExtensions) && _every(o.crlExtensions, _isCrlExtensionEntry) && _isArray(o.revokedCertificates) && _every(o.revokedCertificates, function(e) {
+        return !!e && typeof e.serialNumber === "bigint" && typeof e.serialNumberHex === "string" && time.isDate(e.revocationDate) && _isArray(e.crlEntryExtensions) && _every(e.crlEntryExtensions, _isCrlExtensionEntry);
       });
     }
     function _safe(shape) {
@@ -2620,7 +3241,7 @@ var require_guard_parsed = __commonJS({
     }
     var certShape = _safe(isCert);
     var crlShape = _safe(isCrl);
-    var _SHAPES = { certificate: certShape, crl: crlShape };
+    var _SHAPES = _assign(_create(null), { certificate: certShape, crl: crlShape });
     function accept(input, kind, parse, E, code, label) {
       var who = label || "the argument";
       var shape = _SHAPES[kind];
@@ -2642,16 +3263,16 @@ var require_guard_parsed = __commonJS({
       }
       throw E(code, who + " must be a " + kind + " DER Buffer, a PEM string, or a parsed " + kind);
     }
-    var PROVENANCE = /* @__PURE__ */ new WeakMap();
+    var PROVENANCE = new _WeakMap();
     function recordingParser(kind, parse, ErrorClass, code, label) {
       return function(input) {
         var isText = typeof input === "string";
         var snap = isText ? input : bytes.snapshotSource(input, ErrorClass, code, label);
         var out = parse(snap);
         if (out && typeof out === "object") {
-          PROVENANCE.set(out, {
+          _weakSet(PROVENANCE, out, {
             kind,
-            source: isText ? snap : Buffer.from(snap),
+            source: isText ? snap : _bufferFrom(snap),
             shape: _shapeOf(out)
           });
         }
@@ -2662,9 +3283,9 @@ var require_guard_parsed = __commonJS({
       return function(node) {
         var out = walkNode(node);
         if (out && typeof out === "object" && node && _isBytes(node.bytes)) {
-          PROVENANCE.set(out, {
+          _weakSet(PROVENANCE, out, {
             kind,
-            source: Buffer.from(node.bytes),
+            source: _bufferFrom(node.bytes),
             shape: _shapeOf(out),
             derive: function(src) {
               return walkNode(decodeBytes(src));
@@ -2676,15 +3297,15 @@ var require_guard_parsed = __commonJS({
     }
     function _recordOf(obj, kind) {
       if (!obj || typeof obj !== "object") return void 0;
-      var rec = PROVENANCE.get(obj);
+      var rec = _weakGet(PROVENANCE, obj);
       return rec && rec.kind === kind ? rec : void 0;
     }
     function isRecorded(obj) {
-      return !!obj && typeof obj === "object" && PROVENANCE.has(obj);
+      return !!obj && typeof obj === "object" && _weakHas(PROVENANCE, obj);
     }
     function isRecordedAsProduced(obj) {
       if (!isRecorded(obj)) return false;
-      var shape = PROVENANCE.get(obj).shape;
+      var shape = _weakGet(PROVENANCE, obj).shape;
       var keys = _allNames(obj);
       for (var i = 0; i < keys.length; i++) {
         if (!shape[keys[i]]) return false;
@@ -2692,20 +3313,20 @@ var require_guard_parsed = __commonJS({
       return true;
     }
     function _shapeOf(obj) {
-      var shape = /* @__PURE__ */ Object.create(null);
+      var shape = _create(null);
       var keys = _allNames(obj);
       for (var i = 0; i < keys.length; i++) shape[keys[i]] = true;
       return shape;
     }
     function _allNames(obj) {
       var names = [];
-      var seen = /* @__PURE__ */ Object.create(null);
-      for (var o = obj; o && o !== Object.prototype; o = Object.getPrototypeOf(o)) {
-        var own = Object.getOwnPropertyNames(o);
+      var seen = _create(null);
+      for (var o = obj; o && o !== _ObjectProto; o = _getPrototypeOf(o)) {
+        var own = _getOwnPropertyNames(o);
         for (var i = 0; i < own.length; i++) {
           if (seen[own[i]]) continue;
           seen[own[i]] = true;
-          names.push(own[i]);
+          _append(names, own[i]);
         }
       }
       return names;
@@ -2726,16 +3347,22 @@ var require_guard_parsed = __commonJS({
       }
       return parse(input);
     }
-    var _CLAIMS = {
+    var _CLAIMS = _assign(_create(null), {
       certificate: ["tbsBytes", "subjectPublicKeyInfo", "serialNumberHex"],
       crl: ["tbsBytes", "revokedCertificates", "crlExtensions"],
-      cms: ["signerInfos", "encapContentInfo"]
-    };
-    var _WHY = {
+      cms: ["signerInfos", "encapContentInfo"],
+      csr: ["certificationRequestInfoBytes", "subjectPublicKeyInfo", "attributes"],
+      crmf: ["messages"],
+      attributeCertificate: ["tbsBytes", "holder", "attributes"]
+    });
+    var _WHY = _assign(_create(null), {
       certificate: "the signed byte range, the signature and the fields that range encodes are separate properties of a parsed object, so a rebuilt certificate (Object.assign, spread, a JSON round-trip) could have them describe different certificates: keep a real CA certificate's signed bytes and signature, replace only its public key, and every field is still well-formed",
       crl: "the signed byte range, the revocation list and the scope extensions are separate properties of a parsed object, so a rebuilt CRL could have them describe different CRLs: empty the revocation list and a correctly signed CRL reports a revoked certificate as good",
-      cms: "the signed attribute bytes, the signature, the encapsulated content and the certificates that verify it are separate properties of a parsed object, so a rebuilt SignedData could have them describe different messages: keep a genuine signer's signature and signed attributes, put other content beside them, and every part of the check passes for content that signer never signed"
-    };
+      cms: "the signed attribute bytes, the signature, the encapsulated content and the certificates that verify it are separate properties of a parsed object, so a rebuilt SignedData could have them describe different messages: keep a genuine signer's signature and signed attributes, put other content beside them, and every part of the check passes for content that signer never signed",
+      csr: "the signed byte range, the key it proves possession of and the subject and requested extensions that range encodes are separate properties of a parsed object, so a rebuilt request could have them describe different requests: keep a genuine requester's signed bytes and signature, replace only the subject or the extensionRequest, and the proof of possession still verifies while the certificate a CA issues from those fields is for a name and a set of extensions nobody signed",
+      crmf: "the byte range a proof of possession covers, the key that possession is proven for and the subject a CA will issue to are separate properties of a parsed object, so a rebuilt message set could have them describe different requests: keep a genuine requester's signed range and signature, replace only the certTemplate subject or public key, and the proof still verifies while the certificate is issued for a name and a key nobody proved anything about",
+      attributeCertificate: "the signed byte range, the holder the privileges attach to and the attributes granting them are separate properties of a parsed object, so a rebuilt attribute certificate could have them describe different grants: keep a genuine issuer's signed bytes and signature, replace only the holder or an attribute, and the signature still verifies while the privileges are read for someone the issuer never granted them to"
+    });
     function acceptDerived(input, kind, parse, E, code, label) {
       var claims = _CLAIMS[kind];
       if (!claims) throw new TypeError("guard.parsed.acceptDerived: unknown kind " + kind);
@@ -2753,7 +3380,14 @@ var require_guard_parsed = __commonJS({
           throw E(code, who + " must be a " + kind + " DER Buffer, a PEM string, or a parsed " + kind);
         }
       }
-      var ns = { certificate: "x509", crl: "crl", cms: "cms" }[kind];
+      var ns = {
+        certificate: "x509",
+        crl: "crl",
+        cms: "cms",
+        csr: "csr",
+        crmf: "crmf",
+        attributeCertificate: "attrcert"
+      }[kind];
       return fromTrustedSource(
         input,
         kind,
@@ -2783,10 +3417,12 @@ var require_guard_secret = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-secret.js"(exports2, module2) {
     "use strict";
     var bytes = require_guard_bytes();
+    var intrinsic = require_guard_intrinsic();
+    var _fill = intrinsic.uncurry(Uint8Array.prototype.fill);
     function zeroize(value, ErrorClass, code, label) {
       if (value === null || value === void 0) return value;
       var view = bytes.view(value, ErrorClass, code, label);
-      view.fill(0);
+      _fill(view, 0);
       return value;
     }
     function zeroizeAll(list, ErrorClass, code, label) {
@@ -2803,13 +3439,149 @@ var require_guard_bytes = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-bytes.js"(exports2, module2) {
     "use strict";
     var async = require_guard_async();
+    var identifier = require_guard_identifier();
+    var time = require_guard_time();
+    var intrinsic = require_guard_intrinsic();
+    var util = { types: intrinsic.types };
+    var _isArray = intrinsic.isArray;
+    var _bufferFrom = intrinsic.bufferFrom;
+    var _isView = intrinsic.isView;
+    var _isBuffer = intrinsic.isBuffer;
+    var _create = intrinsic.create;
+    var _getPrototypeOf = intrinsic.getPrototypeOf;
+    var _getOwnPropertyDescriptor = intrinsic.getOwnPropertyDescriptor;
+    var _defineProperty = intrinsic.defineProperty;
+    var _objectKeys = intrinsic.keys;
+    var _isExtensible = intrinsic.isExtensible;
+    var _ownKeys = intrinsic.ownKeys;
+    var _stringify = intrinsic.stringify;
+    var _forEach = intrinsic.forEach;
+    var _map = intrinsic.map;
+    var _filter = intrinsic.filter;
+    var _reTest = intrinsic.uncurry(RegExp.prototype.test);
+    var _setForEach = intrinsic.uncurry(Set.prototype.forEach);
+    var _mapForEach = intrinsic.uncurry(Map.prototype.forEach);
+    var _String = intrinsic.String;
+    var _Date = intrinsic.Date;
+    var _apply = intrinsic.apply;
+    var _promiseFinally = intrinsic.promiseFinally;
+    var _ArrayBuffer = intrinsic.ArrayBuffer;
+    var _Uint8Array = intrinsic.Uint8Array;
+    var _DataView = intrinsic.DataView;
+    var _ObjectProto = intrinsic.ObjectProto;
+    var _setAdd = intrinsic.setAdd;
+    var _setHas = intrinsic.setHas;
+    var _mapSet = intrinsic.mapSet;
+    var _taSet = intrinsic.typedArraySet;
+    var _Set = intrinsic.Set;
+    var _Map = intrinsic.Map;
+    function _append(arr, v) {
+      _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true });
+    }
+    function isByteSource(x) {
+      return _isBuffer(x) || _isView(x) || _isArrayBuffer(x);
+    }
+    function _isArrayBuffer(v) {
+      return util.types.isArrayBuffer(v);
+    }
+    var _TYPED_ARRAY_PROTO = _getPrototypeOf(Uint8Array.prototype);
+    var _uncurriedGetter = intrinsic.getter;
+    var _taBuffer = _uncurriedGetter(_TYPED_ARRAY_PROTO, "buffer", "%TypedArray%.prototype");
+    var _taByteOffset = _uncurriedGetter(_TYPED_ARRAY_PROTO, "byteOffset", "%TypedArray%.prototype");
+    var _dvBuffer = _uncurriedGetter(DataView.prototype, "buffer", "DataView.prototype");
+    var _dvByteOffset = _uncurriedGetter(DataView.prototype, "byteOffset", "DataView.prototype");
+    function _storeOf(v) {
+      return util.types.isDataView(v) ? _dvBuffer(v) : _taBuffer(v);
+    }
+    function _offsetOf(v) {
+      return util.types.isDataView(v) ? _dvByteOffset(v) : _taByteOffset(v);
+    }
+    function _lengthOf(v) {
+      return intrinsic.sizeOf(v);
+    }
+    function _reView(v) {
+      return _bufferFrom(_storeOf(v), _offsetOf(v), _lengthOf(v));
+    }
+    var _CONCRETE_KINDS = _filter(
+      _map(
+        // allow:guard-reads-runtime-live -- module-init, see above
+        _filter(_objectKeys(util.types), function(name) {
+          return _reTest(/^is[A-Za-z0-9]+Array$/, name);
+        }),
+        // allow:guard-reads-runtime-live -- module-init, see above
+        function(name) {
+          return [util.types[name], globalThis[name.slice(2)]];
+        }
+      ),
+      function(row) {
+        return typeof row[0] === "function" && typeof row[1] === "function" && typeof row[1].BYTES_PER_ELEMENT === "number" && row[1].BYTES_PER_ELEMENT > 0;
+      }
+    );
+    function _concreteKindOf(v) {
+      for (var i = 0; i < _CONCRETE_KINDS.length; i++) {
+        if (_CONCRETE_KINDS[i][0](v)) return _CONCRETE_KINDS[i][1];
+      }
+      return null;
+    }
+    var _NAMED_KINDS = _filter([
+      ["isNativeError", "Error"],
+      ["isRegExp", "RegExp"],
+      ["isPromise", "Promise"],
+      ["isWeakMap", "WeakMap"],
+      ["isWeakSet", "WeakSet"],
+      ["isMap", "Map"],
+      ["isSet", "Set"],
+      ["isDate", "Date"],
+      ["isProxy", "Proxy"]
+    ], function(row) {
+      return typeof util.types[row[0]] === "function";
+    });
+    function _kindName(v) {
+      for (var i = 0; i < _NAMED_KINDS.length; i++) {
+        if (util.types[_NAMED_KINDS[i][0]](v)) return _NAMED_KINDS[i][1];
+      }
+      return typeof v === "function" ? "function" : "value";
+    }
+    function _article(name) {
+      return _reTest(/^[AEIOU]/i, name) ? "an" : "a";
+    }
+    function outputView(input, ErrorClass, code, label) {
+      if (!util.types.isUint8Array(input) && !_isView(input)) {
+        throw _raise(ErrorClass, code, label + ": expected a Buffer / TypedArray to write into");
+      }
+      try {
+        return _reView(input);
+      } catch (e) {
+        throw _raise(ErrorClass, code, label + ": output is not a usable byte view (detached backing buffer?)", e);
+      }
+    }
+    function lengthOf(view2) {
+      return _lengthOf(view2);
+    }
+    function _refuseShared(v, ErrorClass, code, label) {
+      if (util.types.isSharedArrayBuffer(v) || _isView(v) && util.types.isSharedArrayBuffer(_storeOf(v))) {
+        throw _raise(ErrorClass, code, label + ": shared memory cannot be used here, because another thread can rewrite it after it has been checked; pass a Buffer or a Uint8Array over memory this process owns");
+      }
+    }
+    var _ErrorProto = Error.prototype;
+    function _isErrorClass(E) {
+      if (typeof E !== "function") return false;
+      var seen = new _Set();
+      for (var p = E.prototype; p !== null && typeof p === "object"; p = _getPrototypeOf(p)) {
+        if (p === _ErrorProto) return true;
+        if (_setHas(seen, p)) return false;
+        _setAdd(seen, p);
+      }
+      return false;
+    }
     function _raise(E, code, message, cause) {
-      return E.prototype instanceof Error ? new E(code, message, cause) : E(code, message, cause);
+      return _isErrorClass(E) ? new E(code, message, cause) : E(code, message, cause);
     }
     function view(input, ErrorClass, code, label) {
-      if (Buffer.isBuffer(input) || input instanceof Uint8Array) {
+      _refuseShared(input, ErrorClass, code, label);
+      if (util.types.isUint8Array(input)) {
         try {
-          return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+          return _reView(input);
         } catch (e) {
           throw _raise(ErrorClass, code, label + ": input is not a usable byte view (detached backing buffer?)", e);
         }
@@ -2817,10 +3589,11 @@ var require_guard_bytes = __commonJS({
       throw _raise(ErrorClass, code, label + ": expected a Buffer / Uint8Array");
     }
     function source(input, ErrorClass, code, label) {
-      var isAb = input instanceof ArrayBuffer;
-      if (isAb || ArrayBuffer.isView(input)) {
+      _refuseShared(input, ErrorClass, code, label);
+      var isAb = _isArrayBuffer(input);
+      if (isAb || _isView(input)) {
         try {
-          return isAb ? Buffer.from(input) : Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+          return isAb ? _bufferFrom(input) : _reView(input);
         } catch (e) {
           throw _raise(ErrorClass, code, label + ": input is not a usable byte source (detached backing buffer?)", e);
         }
@@ -2828,39 +3601,62 @@ var require_guard_bytes = __commonJS({
       throw _raise(ErrorClass, code, label + ": expected a BufferSource (ArrayBuffer / TypedArray / Buffer)");
     }
     function snapshot(input, ErrorClass, code, label) {
-      return Buffer.from(view(input, ErrorClass, code, label));
+      return _bufferFrom(view(input, ErrorClass, code, label));
     }
     function snapshotSource(input, ErrorClass, code, label) {
-      return Buffer.from(source(input, ErrorClass, code, label));
+      return _bufferFrom(source(input, ErrorClass, code, label));
     }
     function snapshotDeep(value, ErrorClass, code, label, opts) {
       var o = opts || {};
       var cap = o.maxDepth == null ? 64 : o.maxDepth;
       return _deep(value, ErrorClass, code, label, cap, 0, o.collect || null);
     }
-    var _CRYPTO_KEY_SURFACE = { type: 1, extractable: 1, algorithm: 1, usages: 1 };
-    var _ERROR_SURFACE = { message: 1, stack: 1, name: 1, cause: 1 };
-    var _REGEXP_SURFACE = {
-      lastIndex: 1,
-      source: 1,
-      flags: 1,
-      global: 1,
-      ignoreCase: 1,
-      multiline: 1,
-      sticky: 1,
-      unicode: 1,
-      unicodeSets: 1,
-      hasIndices: 1,
-      dotAll: 1
-    };
-    var _THENABLE_SURFACE = { then: 1, catch: 1, finally: 1 };
+    function _surface(names) {
+      var t = _create(null);
+      _forEach(names, function(n) {
+        t[n] = 1;
+      });
+      t[Symbol.toStringTag] = 1;
+      return t;
+    }
+    var _CRYPTO_KEY_SURFACE = _surface([
+      "type",
+      "extractable",
+      "algorithm",
+      "usages",
+      "asymmetricKeyType",
+      "asymmetricKeyDetails",
+      "_handle"
+    ]);
+    var _ERROR_SURFACE = _surface(["message", "stack", "name", "cause"]);
+    var _REGEXP_SURFACE = _surface([
+      "lastIndex",
+      "source",
+      "flags",
+      "global",
+      "ignoreCase",
+      "multiline",
+      "sticky",
+      "unicode",
+      "unicodeSets",
+      "hasIndices",
+      "dotAll"
+    ]);
+    var _THENABLE_SURFACE = _surface(["then", "catch", "finally"]);
     function _opaqueSurface(v, ErrorClass, code, label) {
-      var proto = Object.getPrototypeOf(v);
-      if (proto === Object.prototype || proto === null) return null;
-      if (v instanceof WeakMap || v instanceof WeakSet) return {};
-      if (v instanceof Error) return _ERROR_SURFACE;
-      if (v instanceof RegExp) return _REGEXP_SURFACE;
-      if (require_webcrypto().isCryptoKeyLike(v)) return _CRYPTO_KEY_SURFACE;
+      var proto = _getPrototypeOf(v);
+      if (proto === _ObjectProto || proto === null) return null;
+      if (util.types.isWeakMap(v) || util.types.isWeakSet(v)) return _create(null);
+      if (util.types.isNativeError(v)) return _ERROR_SURFACE;
+      if (util.types.isRegExp(v)) return _REGEXP_SURFACE;
+      if (util.types.isKeyObject(v)) return _CRYPTO_KEY_SURFACE;
+      var keyLike;
+      try {
+        keyLike = require_webcrypto().isCryptoKeyLike(v);
+      } catch (e) {
+        throw _raise(ErrorClass, code, label + ": reading the key surface threw", e);
+      }
+      if (keyLike) return _CRYPTO_KEY_SURFACE;
       var then;
       try {
         then = v.then;
@@ -2870,96 +3666,163 @@ var require_guard_bytes = __commonJS({
       if (typeof then === "function") return _THENABLE_SURFACE;
       return null;
     }
-    function _opaqueIsSafeToPass(v, surface) {
-      var keys = _reachableKeys(v);
-      for (var i = 0; i < keys.length; i++) {
-        if (surface[keys[i]]) continue;
-        if (!_wasEnumerable(v, keys[i])) continue;
-        return false;
+    function _canChangeAfterTheCheck(v, name) {
+      var visited = new _Set();
+      for (var o = v; o && !_setHas(visited, o); o = _getPrototypeOf(o)) {
+        _setAdd(visited, o);
+        var d = _getOwnPropertyDescriptor(o, name);
+        if (!d) continue;
+        if (d.get || d.set || d.writable || d.configurable) return true;
+        return o !== v && _isExtensible(v);
       }
-      return true;
+      return false;
     }
-    function _reachableKeys(v) {
-      var names = [];
-      var seen = /* @__PURE__ */ Object.create(null);
-      for (var o = v; o && o !== Object.prototype; o = Object.getPrototypeOf(o)) {
-        var own = Object.getOwnPropertyNames(o);
-        for (var i = 0; i < own.length; i++) {
-          if (own[i] === "constructor" || seen[own[i]]) continue;
-          seen[own[i]] = true;
-          names.push(own[i]);
-        }
+    var _SETTLED_DEPTH = 4;
+    function _settledValueIsFixed(value, ErrorClass, code, label, depth) {
+      if (value === null || typeof value !== "object" && typeof value !== "function") return true;
+      if (depth >= _SETTLED_DEPTH) return false;
+      if (util.types.isProxy(value)) return false;
+      var surface = _opaqueSurface(value, ErrorClass, code, label);
+      if (!surface) return false;
+      return _opaqueFieldOutsideSurface(value, surface, ErrorClass, code, label, depth + 1) === null;
+    }
+    function _opaqueFieldOutsideSurface(v, surface, ErrorClass, code, label, depth) {
+      var keys = _namesToCopy(v, ErrorClass, code, label);
+      for (var i = 0; i < keys.length; i++) {
+        if (surface[keys[i]]) continue;
+        if (typeof keys[i] === "symbol") continue;
+        if (!_canChangeAfterTheCheck(v, keys[i]) && _settledValueIsFixed(v[keys[i]], ErrorClass, code, label, depth || 0)) continue;
+        return keys[i];
       }
-      return names;
+      return null;
     }
     function _copyBytesSameKind(v, ErrorClass, code, label, collect) {
       var src = source(v, ErrorClass, code, label);
-      var owned = new ArrayBuffer(src.length);
-      new Uint8Array(owned).set(src);
-      if (collect) collect.push(Buffer.from(owned, 0, src.length));
-      if (Buffer.isBuffer(v)) return Buffer.from(owned, 0, src.length);
-      if (v instanceof ArrayBuffer) return owned;
-      if (v instanceof DataView) return new DataView(owned);
-      return new v.constructor(owned, 0, src.length / v.BYTES_PER_ELEMENT);
+      var srcLen = _lengthOf(src);
+      var owned = new _ArrayBuffer(srcLen);
+      _taSet(new _Uint8Array(owned), src);
+      if (collect) _append(collect, _bufferFrom(owned, 0, srcLen));
+      if (_isBuffer(v)) return _bufferFrom(owned, 0, srcLen);
+      if (_isArrayBuffer(v)) return owned;
+      if (util.types.isDataView(v)) return new _DataView(owned);
+      var Ctor = _concreteKindOf(v);
+      if (!Ctor) {
+        throw _raise(ErrorClass, code, label + ": a " + (util.types.isTypedArray(v) ? "typed array of a kind this runtime added" : "byte view") + " cannot be copied while keeping its kind; pass a Buffer or a Uint8Array");
+      }
+      return new Ctor(owned, 0, srcLen / Ctor.BYTES_PER_ELEMENT);
+    }
+    function _protoChainIsCyclic(v) {
+      var visited = new _Set();
+      for (var o = v; o; o = _getPrototypeOf(o)) {
+        if (_setHas(visited, o)) return true;
+        _setAdd(visited, o);
+      }
+      return false;
+    }
+    function _protoChainHasProxy(v) {
+      var visited = new _Set();
+      for (var o = v; o && !_setHas(visited, o); o = _getPrototypeOf(o)) {
+        _setAdd(visited, o);
+        if (util.types.isProxy(o)) return true;
+      }
+      return false;
+    }
+    function _plainCopy(copy) {
+      return copy;
     }
     function _deep(v, ErrorClass, code, label, cap, depth, collect) {
       if (depth > cap) throw _raise(ErrorClass, code, label + " is nested too deeply to copy");
       if (v == null || typeof v !== "object") return v;
-      if (Buffer.isBuffer(v) || ArrayBuffer.isView(v) || v instanceof ArrayBuffer) {
+      _refuseShared(v, ErrorClass, code, label);
+      if (_protoChainHasProxy(v)) {
+        throw _raise(ErrorClass, code, label + ": a Proxy cannot be copied faithfully, because the keys it reports need not be the ones it answers; pass a plain object");
+      }
+      if (_protoChainIsCyclic(v)) {
+        throw _raise(ErrorClass, code, label + ": its prototype chain is a cycle, so it cannot be read or copied; pass a plain object");
+      }
+      if (_isBuffer(v) || _isView(v) || _isArrayBuffer(v)) {
         var bytesCopy = _copyBytesSameKind(v, ErrorClass, code, label, collect);
         _copyNamed(v, bytesCopy, ErrorClass, code, label, cap, depth, collect);
         return bytesCopy;
       }
       if (require_guard_parsed().isRecordedAsProduced(v)) return v;
-      if (v instanceof Date) return new Date(v.getTime());
-      if (Array.isArray(v)) {
+      if (util.types.isDate(v)) {
+        var dateCopy = new _Date(time.instantOf(v));
+        _copyNamed(v, dateCopy, ErrorClass, code, label, cap, depth, collect, _DATE_BEHAVIOR);
+        return _plainCopy(dateCopy);
+      }
+      if (_isArray(v)) {
         var arr = [];
-        for (var i = 0; i < v.length; i++) arr.push(_deep(v[i], ErrorClass, code, label, cap, depth + 1, collect));
+        var indexE = function(c, m) {
+          return _raise(ErrorClass, c, m);
+        };
+        var indices = identifier.readableIndices(v, indexE, code, label);
+        if (depth === 0) identifier.refuseAccessorFields(v, indices, indexE, code, label);
+        _forEach(indices, function(k) {
+          var element;
+          try {
+            element = v[k];
+          } catch (e) {
+            throw _raise(ErrorClass, code, label + ": reading element " + k + " threw", e);
+          }
+          arr[k] = _deep(element, ErrorClass, code, label, cap, depth + 1, collect);
+        });
+        arr.length = v.length;
         _copyNamed(v, arr, ErrorClass, code, label, cap, depth, collect);
-        return arr;
+        return _plainCopy(arr);
       }
       var surface = _opaqueSurface(v, ErrorClass, code, label);
       if (surface) {
-        if (_opaqueIsSafeToPass(v, surface)) return v;
-        throw _raise(ErrorClass, code, label + ": a " + (v.constructor && v.constructor.name || "value") + " carrying its own fields cannot be used here -- its state cannot be copied, so those fields would stay changeable after they were checked; pass the fields as a plain object");
+        var carried = _opaqueFieldOutsideSurface(v, surface, ErrorClass, code, label);
+        if (carried === null) return v;
+        throw _raise(ErrorClass, code, label + ": " + _article(_kindName(v)) + " " + _kindName(v) + " carrying its own field " + _stringify(_String(carried)) + " cannot be used here -- its state cannot be copied, so that field would stay changeable after it was checked; pass the fields as a plain object");
       }
-      if (v instanceof Map) return _copyEntries(v, /* @__PURE__ */ new Map(), ErrorClass, code, label, cap, depth, collect);
-      if (v instanceof Set) return _copyEntries(v, /* @__PURE__ */ new Set(), ErrorClass, code, label, cap, depth, collect);
-      var out = Object.create(Object.getPrototypeOf(v));
+      if (util.types.isMap(v)) {
+        return _plainCopy(_copyEntries(v, new _Map(), ErrorClass, code, label, cap, depth, collect));
+      }
+      if (util.types.isSet(v)) {
+        return _plainCopy(_copyEntries(v, new _Set(), ErrorClass, code, label, cap, depth, collect));
+      }
+      var out = _create(_getPrototypeOf(v) === null ? null : _ObjectProto);
       _copyNamed(v, out, ErrorClass, code, label, cap, depth, collect);
       return out;
     }
-    function _namesToCopy(src, dst) {
-      var indexed = Array.isArray(dst) || ArrayBuffer.isView(dst);
-      var kind = indexed || dst instanceof Map || dst instanceof Set || dst instanceof ArrayBuffer;
-      if (!kind) return _reachableKeys(src);
-      var own = Object.getOwnPropertyNames(src);
-      var out = [];
-      for (var i = 0; i < own.length; i++) {
-        if (own[i] === "length" || indexed && String(Number(own[i])) === own[i]) continue;
-        out.push(own[i]);
-      }
-      return out;
+    function _namesToCopy(src, ErrorClass, code, label, atArgument) {
+      var E = function(c, m) {
+        return _raise(ErrorClass, c, m);
+      };
+      var names = identifier.readableNames(src, E, code, label);
+      if (atArgument) identifier.refuseAccessorFields(src, names, E, code, label);
+      return names;
     }
     function _copyEntries(src, dst, ErrorClass, code, label, cap, depth, collect) {
-      src.forEach(function(value, key) {
+      var walk = util.types.isSet(src) ? _setForEach : _mapForEach;
+      walk(src, function(value, key) {
         var copiedValue = _deep(value, ErrorClass, code, label, cap, depth + 1, collect);
-        if (dst instanceof Set) dst.add(copiedValue);
-        else dst.set(_deep(key, ErrorClass, code, label, cap, depth + 1, collect), copiedValue);
+        if (util.types.isSet(dst)) _setAdd(dst, copiedValue);
+        else _mapSet(dst, _deep(key, ErrorClass, code, label, cap, depth + 1, collect), copiedValue);
       });
       _copyNamed(src, dst, ErrorClass, code, label, cap, depth, collect);
       return dst;
     }
-    function _copyNamed(src, dst, ErrorClass, code, label, cap, depth, collect) {
-      var keys = _namesToCopy(src, dst);
+    var _DATE_BEHAVIOR = (function() {
+      var t = _create(null);
+      _forEach(_ownKeys(Date.prototype), function(n) {
+        t[n] = 1;
+      });
+      return t;
+    })();
+    function _copyNamed(src, dst, ErrorClass, code, label, cap, depth, collect, behavior) {
+      var keys = _namesToCopy(src, ErrorClass, code, label, depth === 0);
       for (var k = 0; k < keys.length; k++) {
         var value;
         try {
           value = src[keys[k]];
         } catch (e) {
-          throw _raise(ErrorClass, code, label + ": reading " + JSON.stringify(keys[k]) + " threw", e);
+          throw _raise(ErrorClass, code, label + ": reading " + _stringify(keys[k]) + " threw", e);
         }
-        Object.defineProperty(dst, keys[k], {
+        if (behavior && behavior[keys[k]] && typeof value === "function") continue;
+        _defineProperty(dst, keys[k], {
           value: typeof value === "function" ? value : _deep(value, ErrorClass, code, label, cap, depth + 1, collect),
           writable: true,
           enumerable: _wasEnumerable(src, keys[k]),
@@ -2968,8 +3831,8 @@ var require_guard_bytes = __commonJS({
       }
     }
     function _wasEnumerable(v, name) {
-      for (var o = v; o && o !== Object.prototype; o = Object.getPrototypeOf(o)) {
-        var d = Object.getOwnPropertyDescriptor(o, name);
+      for (var o = v; o && o !== _ObjectProto; o = _getPrototypeOf(o)) {
+        var d = _getOwnPropertyDescriptor(o, name);
         if (d) return !!d.enumerable;
       }
       return false;
@@ -2988,7 +3851,7 @@ var require_guard_bytes = __commonJS({
       }
       try {
         for (var i = 0; i < args.length; i++) {
-          values.push(snapshotDeep(args[i][0], ErrorClass, code, args[i][1], { collect: copies }));
+          _append(values, snapshotDeep(args[i][0], ErrorClass, code, args[i][1], { collect: copies }));
         }
       } catch (e) {
         release();
@@ -2998,10 +3861,10 @@ var require_guard_bytes = __commonJS({
     }
     function fixedCall(ErrorClass, code, args, body) {
       var handle = null;
-      return async.deferred(function() {
+      return _promiseFinally(async.deferred(function() {
         handle = fixArguments(ErrorClass, code, args);
-        return body.apply(null, handle.values);
-      }).finally(function() {
+        return _apply(body, null, handle.values);
+      }), function() {
         if (handle) handle.release();
       });
     }
@@ -3010,6 +3873,9 @@ var require_guard_bytes = __commonJS({
       source,
       snapshot,
       snapshotSource,
+      isByteSource,
+      lengthOf,
+      outputView,
       snapshotDeep,
       fixArguments,
       fixedCall
@@ -3022,26 +3888,33 @@ var require_guard_text = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-text.js"(exports2, module2) {
     "use strict";
     var bytes = require_guard_bytes();
+    var intrinsic = require_guard_intrinsic();
+    var _toString = intrinsic.uncurry(Buffer.prototype.toString);
+    var _decode = intrinsic.uncurry(TextDecoder.prototype.decode);
+    var _byteLength = Buffer.byteLength;
+    var _isBuffer = Buffer.isBuffer;
+    var _isInteger = Number.isInteger;
+    var _TextDecoder = TextDecoder;
     var LATIN1 = "latin1";
     function decode(input, maxBytes, ErrorClass, spec) {
-      if (!Number.isInteger(maxBytes) || maxBytes < 0) {
+      if (!_isInteger(maxBytes) || maxBytes < 0) {
         throw new TypeError("guard.text.decode: maxBytes must be a non-negative integer");
       }
       var charset = spec.charset || LATIN1;
-      if (Buffer.isBuffer(input)) {
+      if (_isBuffer(input)) {
         input = bytes.view(input, ErrorClass, spec.badInput, spec.label);
-        if (input.length > maxBytes) throw new ErrorClass(spec.tooLarge, spec.label + " exceeds the size cap");
+        if (bytes.lengthOf(input) > maxBytes) throw new ErrorClass(spec.tooLarge, spec.label + " exceeds the size cap");
         if (spec.fatal) {
           try {
-            return new TextDecoder(charset, { fatal: true }).decode(input);
+            return _decode(new _TextDecoder(charset, { fatal: true }), input);
           } catch (e) {
             throw new ErrorClass(spec.badDecode, spec.label + " is not valid " + charset, e);
           }
         }
-        return input.toString(charset);
+        return _toString(input, charset);
       }
       if (typeof input === "string") {
-        var byteLen = charset === LATIN1 ? input.length : Buffer.byteLength(input, "utf8");
+        var byteLen = charset === LATIN1 ? input.length : _byteLength(input, "utf8");
         if (byteLen > maxBytes) throw new ErrorClass(spec.tooLarge, spec.label + " exceeds the size cap");
         return input;
       }
@@ -3056,14 +3929,16 @@ var require_guard_limits = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-limits.js"(exports2, module2) {
     "use strict";
     var constants = require_constants();
+    var _isInteger = require_guard_intrinsic().isInteger;
+    var _sizeOf = require_guard_intrinsic().sizeOf;
     function cap(value, key, dflt, opts) {
       if (value === void 0) return dflt;
       opts = opts || {};
       var min = opts.min === void 0 ? 0 : opts.min;
-      if (!Number.isInteger(min) || opts.max !== void 0 && !Number.isInteger(opts.max)) {
+      if (!_isInteger(min) || opts.max !== void 0 && !_isInteger(opts.max)) {
         throw new TypeError("guard.limits.cap: the min/max bounds for " + key + " must be integers");
       }
-      if (!Number.isInteger(value) || value < min || opts.max !== void 0 && value > opts.max) {
+      if (!_isInteger(value) || value < min || opts.max !== void 0 && value > opts.max) {
         var want = "an integer >= " + min + (opts.max !== void 0 ? " and <= " + opts.max : "");
         if (min === 0 && opts.max === void 0) want = "a non-negative integer";
         if (opts.E) throw opts.E(opts.code, (opts.label || key) + " must be " + want);
@@ -3079,7 +3954,7 @@ var require_guard_limits = __commonJS({
       return n;
     }
     function counter(max, E, code, label) {
-      if (!Number.isInteger(max) || max < 0) {
+      if (!_isInteger(max) || max < 0) {
         throw new TypeError("guard.limits.counter: max must be a non-negative integer");
       }
       var n = 0;
@@ -3091,11 +3966,12 @@ var require_guard_limits = __commonJS({
       };
     }
     function byteCap(buf, max, E, code, label) {
-      if (!Number.isInteger(max) || max < 0) {
+      if (!_isInteger(max) || max < 0) {
         throw new TypeError("guard.limits.byteCap: max must be a non-negative integer");
       }
-      if (buf.length > max) {
-        throw E(code, (label || "input") + " is " + buf.length + " bytes, over the " + max + "-byte cap");
+      var size = _sizeOf(buf);
+      if (size > max) {
+        throw E(code, (label || "input") + " is " + size + " bytes, over the " + max + "-byte cap");
       }
       return buf;
     }
@@ -3128,6 +4004,9 @@ var require_guard_crypto = __commonJS({
 var require_guard_range = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-range.js"(exports2, module2) {
     "use strict";
+    var _isSafeInteger = require_guard_intrinsic().isSafeInteger;
+    var _Number = require_guard_intrinsic().Number;
+    var _BigInt = require_guard_intrinsic().BigInt;
     var UINT31_MAX = 2147483647n;
     var SAFE_MAX = 9007199254740991n;
     var SAFE_MIN = -9007199254740991n;
@@ -3145,7 +4024,7 @@ var require_guard_range = __commonJS({
       if (typeof value !== "bigint" || value < min || value > max) {
         throw E(code, label + " must be an integer within " + min + ".." + max);
       }
-      return Number(value);
+      return _Number(value);
     }
     function uint31(value, E, code, label) {
       return int(value, 0n, UINT31_MAX, E, code, label);
@@ -3157,8 +4036,8 @@ var require_guard_range = __commonJS({
       var v;
       if (typeof value === "bigint") {
         v = value;
-      } else if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
-        v = BigInt(value);
+      } else if (typeof value === "number" && _isSafeInteger(value) && value >= 0) {
+        v = _BigInt(value);
       } else {
         throw E(code, label + " must be a non-negative safe-integer Number or a BigInt (a uint64)");
       }
@@ -3169,7 +4048,7 @@ var require_guard_range = __commonJS({
     }
     function authoredInteger(value, E, code, label) {
       if (typeof value === "bigint") return value;
-      if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value);
+      if (typeof value === "number" && _isSafeInteger(value)) return _BigInt(value);
       throw E(code, label + " must be an integer (a safe-integer number, or a bigint for a large value)");
     }
     module2.exports = {
@@ -3182,39 +4061,26 @@ var require_guard_range = __commonJS({
   }
 });
 
-// node_modules/@blamejs/pki/lib/guard-time.js
-var require_guard_time = __commonJS({
-  "node_modules/@blamejs/pki/lib/guard-time.js"(exports2, module2) {
-    "use strict";
-    function assertValid(value, E, code, label) {
-      if (!(value instanceof Date) || isNaN(value.getTime())) {
-        throw E(code, (label || "value") + " must be a valid Date");
-      }
-      return value;
-    }
-    function within(instant, lower, upper, E, code, label, opts) {
-      assertValid(instant, E, code, label);
-      assertValid(lower, E, code, (label || "window") + " lower bound");
-      assertValid(upper, E, code, (label || "window") + " upper bound");
-      var t = instant.getTime();
-      var lo = lower.getTime();
-      var hi = upper.getTime();
-      return t >= lo && (opts && opts.upperInclusive ? t <= hi : t < hi);
-    }
-    module2.exports = {
-      assertValid,
-      within
-    };
-  }
-});
-
 // node_modules/@blamejs/pki/lib/guard-name.js
 var require_guard_name = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-name.js"(exports2, module2) {
     "use strict";
+    var intrinsic = require_guard_intrinsic();
+    var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+    var _charAt = intrinsic.uncurry(String.prototype.charAt);
+    var _toLowerCase = intrinsic.uncurry(String.prototype.toLowerCase);
+    var _toUpperCase = intrinsic.uncurry(String.prototype.toUpperCase);
+    var _strSlice = intrinsic.uncurry(String.prototype.slice);
+    var _lastIndexOf = intrinsic.uncurry(String.prototype.lastIndexOf);
+    var _numToString = intrinsic.uncurry(Number.prototype.toString);
+    var _create = intrinsic.create;
+    var _hasOwn = intrinsic.hasOwn;
+    var _fromCharCode = String.fromCharCode;
+    var _String = String;
+    var _isArray = Array.isArray;
     function assertNoControlBytes(str, E, code, label) {
       for (var i = 0; i < str.length; i++) {
-        var c = str.charCodeAt(i);
+        var c = _charCodeAt(str, i);
         if (c === 0 || c < 32 && c !== 9) {
           throw E(code, label + " contains an embedded control byte (CVE-2009-2408)");
         }
@@ -3222,7 +4088,8 @@ var require_guard_name = __commonJS({
       return str;
     }
     function assertPrintableIa5(buf, E, code, label) {
-      for (var i = 0; i < buf.length; i++) {
+      var n = intrinsic.sizeOf(buf);
+      for (var i = 0; i < n; i++) {
         if (buf[i] < 32 || buf[i] > 126) {
           throw E(code, label + " must be a printable IA5String (no control bytes)");
         }
@@ -3237,25 +4104,34 @@ var require_guard_name = __commonJS({
       assertNoControlBytes(v, E, code, label);
       var out = "", lastWasSpace = true;
       for (var i = 0; i < v.length; i++) {
-        if (_isSpace(v.charCodeAt(i))) {
+        if (_isSpace(_charCodeAt(v, i))) {
           lastWasSpace = true;
           continue;
         }
         if (lastWasSpace && out.length) out += " ";
         lastWasSpace = false;
-        out += v.charAt(i);
+        out += _charAt(v, i);
       }
-      return out.toLowerCase();
+      return _toLowerCase(out);
     }
     function _assertSequence(a, b, E, code, label, what) {
-      if (!Array.isArray(a) || !Array.isArray(b)) {
+      if (!_isArray(a) || !_isArray(b)) {
         throw E(code, "cannot compare " + label + ": " + what + " comparison requires the RDN sequence on both sides (pass name.rdns, not the parsed Name)");
       }
+      if (_hasHole(a) || _hasHole(b)) {
+        throw E(code, "cannot compare " + label + ": " + what + " comparison requires a dense sequence on both sides");
+      }
+    }
+    function _hasHole(arr) {
+      for (var i = 0; i < arr.length; i++) {
+        if (!_hasOwn(arr, i)) return true;
+      }
+      return false;
     }
     function rdnEqual(a, b, E, code, label) {
       _assertSequence(a, b, E, code, label, "an RDN");
       if (a.length !== b.length) return false;
-      var used = [];
+      var used = _create(null);
       for (var i = 0; i < a.length; i++) {
         var found = false;
         for (var j = 0; j < b.length; j++) {
@@ -3279,46 +4155,46 @@ var require_guard_name = __commonJS({
       return true;
     }
     function escapeControlBytes(str) {
-      var s = String(str), out = "";
+      var s = _String(str), out = "";
       for (var i = 0; i < s.length; i++) {
-        var c = s.charCodeAt(i);
-        out += c < 32 || c === 127 ? "\\x" + (c < 16 ? "0" : "") + c.toString(16).toUpperCase() : s.charAt(i);
+        var c = _charCodeAt(s, i);
+        out += c < 32 || c === 127 ? "\\x" + (c < 16 ? "0" : "") + _toUpperCase(_numToString(c, 16)) : _charAt(s, i);
       }
       return out;
     }
     var DN_SPECIAL = { 44: 1, 43: 1, 34: 1, 92: 1, 60: 1, 62: 1, 59: 1 };
     function escapeDnValue(v) {
-      var s = String(v), out = "";
+      var s = _String(v), out = "";
       for (var i = 0; i < s.length; i++) {
-        var c = s.charCodeAt(i);
-        if (c < 32 || c === 127) out += "\\" + (c < 16 ? "0" : "") + c.toString(16).toUpperCase();
-        else if (DN_SPECIAL[c] === 1) out += "\\" + s.charAt(i);
-        else out += s.charAt(i);
+        var c = _charCodeAt(s, i);
+        if (c < 32 || c === 127) out += "\\" + (c < 16 ? "0" : "") + _toUpperCase(_numToString(c, 16));
+        else if (DN_SPECIAL[c] === 1) out += "\\" + _charAt(s, i);
+        else out += _charAt(s, i);
       }
-      if (out.length && out.charAt(out.length - 1) === " ") out = out.slice(0, -1) + "\\ ";
-      if (out.charAt(0) === "#" || out.charAt(0) === " ") out = "\\" + out;
+      if (out.length && _charAt(out, out.length - 1) === " ") out = _strSlice(out, 0, -1) + "\\ ";
+      if (_charAt(out, 0) === "#" || _charAt(out, 0) === " ") out = "\\" + out;
       return out;
     }
     function emailEqual(a, b) {
       if (typeof a !== "string" || typeof b !== "string") return "not-comparable";
-      var ai = a.lastIndexOf("@"), bi = b.lastIndexOf("@");
+      var ai = _lastIndexOf(a, "@"), bi = _lastIndexOf(b, "@");
       if (ai <= 0 || bi <= 0 || ai === a.length - 1 || bi === b.length - 1) return "not-comparable";
-      var aLocal = a.slice(0, ai), bLocal = b.slice(0, bi);
-      var aHost = a.slice(ai + 1), bHost = b.slice(bi + 1);
+      var aLocal = _strSlice(a, 0, ai), bLocal = _strSlice(b, 0, bi);
+      var aHost = _strSlice(a, ai + 1), bHost = _strSlice(b, bi + 1);
       if (!_asciiHost(aHost) || !_asciiHost(bHost)) return "not-comparable";
       if (aLocal !== bLocal) return "no-match";
       return _lowerAscii(aHost) === _lowerAscii(bHost) ? "match" : "no-match";
     }
     function _asciiHost(h) {
       if (h.length === 0) return false;
-      for (var i = 0; i < h.length; i++) if (h.charCodeAt(i) > 127) return false;
+      for (var i = 0; i < h.length; i++) if (_charCodeAt(h, i) > 127) return false;
       return true;
     }
     function _lowerAscii(s) {
       var out = "";
       for (var i = 0; i < s.length; i++) {
-        var c = s.charCodeAt(i);
-        out += c >= 65 && c <= 90 ? String.fromCharCode(c + 32) : s.charAt(i);
+        var c = _charCodeAt(s, i);
+        out += c >= 65 && c <= 90 ? _fromCharCode(c + 32) : _charAt(s, i);
       }
       return out;
     }
@@ -3340,9 +4216,17 @@ var require_guard_encoding = __commonJS({
     "use strict";
     function _alphabet(chars) {
       var t = new Uint8Array(128);
-      for (var i = 0; i < chars.length; i++) t[chars.charCodeAt(i)] = 1;
+      for (var i = 0; i < chars.length; i++) t[_charCodeAt(chars, i)] = 1;
       return t;
     }
+    var _intrinsic = require_guard_intrinsic();
+    var _bufferFrom = _intrinsic.bufferFrom;
+    var _toString = _intrinsic.uncurry(Buffer.prototype.toString);
+    var _charCodeAt = _intrinsic.uncurry(String.prototype.charCodeAt);
+    var _strSlice = _intrinsic.uncurry(String.prototype.slice);
+    var _toLowerCase = _intrinsic.uncurry(String.prototype.toLowerCase);
+    var _isInteger = _intrinsic.isInteger;
+    var _floor = _intrinsic.floor;
     var UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     var LOWER = "abcdefghijklmnopqrstuvwxyz";
     var DIGITS = "0123456789";
@@ -3351,17 +4235,17 @@ var require_guard_encoding = __commonJS({
     var HEX_ALPHABET = _alphabet(DIGITS + "abcdefABCDEF");
     function _inAlphabet(text, table) {
       for (var i = 0; i < text.length; i++) {
-        var c = text.charCodeAt(i);
+        var c = _charCodeAt(text, i);
         if (c > 127 || table[c] !== 1) return false;
       }
       return true;
     }
     function _capBefore(nChars, perByteChars, maxBytes, E, code, label) {
       if (maxBytes == null) return;
-      if (!Number.isInteger(maxBytes) || maxBytes < 0) {
+      if (!_isInteger(maxBytes) || maxBytes < 0) {
         throw new TypeError("guard.encoding: maxBytes must be a non-negative integer or null");
       }
-      if (Math.floor(nChars / perByteChars) > maxBytes) {
+      if (_floor(nChars / perByteChars) > maxBytes) {
         throw E(code, label + " exceeds the maximum decoded size of " + maxBytes + " bytes");
       }
     }
@@ -3370,19 +4254,19 @@ var require_guard_encoding = __commonJS({
       if (!_inAlphabet(text, B64URL_ALPHABET)) throw E(code, label + " is not base64url (padding or a non-alphabet character)");
       if (text.length % 4 === 1) throw E(code, label + " has an impossible base64url length");
       _capBefore(text.length * 3, 4, maxBytes, E, code, label);
-      var buf = Buffer.from(text, "base64url");
-      if (buf.toString("base64url") !== text) throw E(code, label + " is not canonical base64url");
+      var buf = _bufferFrom(text, "base64url");
+      if (_toString(buf, "base64url") !== text) throw E(code, label + " is not canonical base64url");
       return buf;
     }
     function base64(text, maxBytes, E, code, label) {
       if (typeof text !== "string") throw E(code, label + " must be a string");
       var pad = 0;
-      while (pad < 2 && text.length > pad && text.charCodeAt(text.length - 1 - pad) === 61) pad++;
-      if (!_inAlphabet(text.slice(0, text.length - pad), B64_ALPHABET)) throw E(code, label + " is not base64 (a non-alphabet character)");
+      while (pad < 2 && text.length > pad && _charCodeAt(text, text.length - 1 - pad) === 61) pad++;
+      if (!_inAlphabet(_strSlice(text, 0, text.length - pad), B64_ALPHABET)) throw E(code, label + " is not base64 (a non-alphabet character)");
       if (text.length % 4 !== 0) throw E(code, label + " must be whole 4-character base64 groups (RFC 4648 sec. 3.5)");
       _capBefore(text.length * 3, 4, maxBytes, E, code, label);
-      var buf = Buffer.from(text, "base64");
-      if (buf.toString("base64") !== text) throw E(code, label + " is not canonical base64 (RFC 4648 sec. 3.5)");
+      var buf = _bufferFrom(text, "base64");
+      if (_toString(buf, "base64") !== text) throw E(code, label + " is not canonical base64 (RFC 4648 sec. 3.5)");
       return buf;
     }
     function hex(text, maxBytes, E, code, label) {
@@ -3390,8 +4274,8 @@ var require_guard_encoding = __commonJS({
       if (!_inAlphabet(text, HEX_ALPHABET)) throw E(code, label + " is not hexadecimal");
       if (text.length % 2 !== 0) throw E(code, label + " must have an even number of hex digits");
       _capBefore(text.length, 2, maxBytes, E, code, label);
-      var buf = Buffer.from(text, "hex");
-      if (buf.toString("hex") !== text.toLowerCase()) throw E(code, label + " is not canonical hexadecimal");
+      var buf = _bufferFrom(text, "hex");
+      if (_toString(buf, "hex") !== _toLowerCase(text)) throw E(code, label + " is not canonical hexadecimal");
       return buf;
     }
     module2.exports = { base64url, base64, hex };
@@ -3402,6 +4286,10 @@ var require_guard_encoding = __commonJS({
 var require_guard_der = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-der.js"(exports2, module2) {
     "use strict";
+    var _compare = require_guard_intrinsic().compare;
+    var _forEach = require_guard_intrinsic().forEach;
+    var _sizeOf = require_guard_intrinsic().sizeOf;
+    var _create = require_guard_intrinsic().create;
     var asn1 = null;
     function _asn1() {
       if (asn1 === null) asn1 = require_asn1_der();
@@ -3411,7 +4299,7 @@ var require_guard_der = __commonJS({
     function _readers() {
       if (VALUE_READERS !== null) return VALUE_READERS;
       var asn12 = _asn1();
-      var m = {}, R = asn12.read, T = asn12.TAGS;
+      var m = _create(null), R = asn12.read, T = asn12.TAGS;
       m[T.BOOLEAN] = R.boolean;
       m[T.INTEGER] = R.integer;
       m[T.ENUMERATED] = R.enumerated;
@@ -3422,7 +4310,7 @@ var require_guard_der = __commonJS({
       m[T.UTC_TIME] = R.time;
       m[T.GENERALIZED_TIME] = R.time;
       m[T.NUMERIC_STRING] = R.numericString;
-      [
+      _forEach([
         T.UTF8_STRING,
         T.PRINTABLE_STRING,
         T.IA5_STRING,
@@ -3430,15 +4318,19 @@ var require_guard_der = __commonJS({
         T.VISIBLE_STRING,
         T.BMP_STRING,
         T.UNIVERSAL_STRING
-      ].forEach(function(t) {
+      ], function(t) {
         m[t] = R.string;
       });
       VALUE_READERS = m;
       return VALUE_READERS;
     }
-    var TAG_CLASS_RANK = { universal: 0, application: 1, context: 2, private: 3 };
+    var TAG_CLASS_RANK = _create(null);
+    TAG_CLASS_RANK.universal = 0;
+    TAG_CLASS_RANK.application = 1;
+    TAG_CLASS_RANK.context = 2;
+    TAG_CLASS_RANK["private"] = 3;
     function setOrderOk(kids) {
-      var i, dup = false, seen = {};
+      var i, dup = false, seen = _create(null);
       for (i = 0; i < kids.length; i++) {
         var key = kids[i].tagClass + ":" + kids[i].tagNumber;
         if (seen[key]) {
@@ -3449,7 +4341,7 @@ var require_guard_der = __commonJS({
       }
       var octetAsc = true, tagAsc = true;
       for (i = 1; i < kids.length; i++) {
-        if (Buffer.compare(kids[i - 1].bytes, kids[i].bytes) > 0) octetAsc = false;
+        if (_compare(kids[i - 1].bytes, kids[i].bytes) > 0) octetAsc = false;
         var pc = TAG_CLASS_RANK[kids[i - 1].tagClass], cc = TAG_CLASS_RANK[kids[i].tagClass];
         if (pc !== cc ? pc > cc : kids[i - 1].tagNumber > kids[i].tagNumber) tagAsc = false;
       }
@@ -3482,7 +4374,7 @@ var require_guard_der = __commonJS({
       }
     }
     function tlv(content, E, code, label) {
-      if (!content || content.length === 0) throw E(code, label + " must be a non-empty DER element");
+      if (!content || _sizeOf(content) === 0) throw E(code, label + " must be a non-empty DER element");
       var node;
       try {
         node = _asn1().decode(content);
@@ -3501,6 +4393,17 @@ var require_guard_json = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-json.js"(exports2, module2) {
     "use strict";
     var text = require_guard_text();
+    var _defineProperty = require_guard_intrinsic().defineProperty;
+    var _fromCharCode = require_guard_intrinsic().fromCharCode;
+    var _charCodeAt = require_guard_intrinsic().uncurry(String.prototype.charCodeAt);
+    var _strSlice = require_guard_intrinsic().uncurry(String.prototype.slice);
+    var _hasOwn = require_guard_intrinsic().hasOwn;
+    var _Number = require_guard_intrinsic().Number;
+    var _isFinite = require_guard_intrinsic().isFinite;
+    var _stringify = require_guard_intrinsic().stringify;
+    function _append(arr, v) {
+      _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true });
+    }
     var limits = require_guard_limits();
     function _hexVal(c) {
       if (c >= 48 && c <= 57) return c - 48;
@@ -3528,7 +4431,7 @@ var require_guard_json = __commonJS({
       var i = 0, n = str.length;
       function ws() {
         while (i < n) {
-          var c = str.charCodeAt(i);
+          var c = _charCodeAt(str, i);
           if (c === 32 || c === 9 || c === 10 || c === 13) i++;
           else break;
         }
@@ -3545,15 +4448,15 @@ var require_guard_json = __commonJS({
         if (c === "[") return array(depth);
         if (c === '"') return string();
         if (c === "-" || c >= "0" && c <= "9") return number();
-        if (str.substr(i, 4) === "true") {
+        if (_strSlice(str, i, i + 4) === "true") {
           i += 4;
           return true;
         }
-        if (str.substr(i, 5) === "false") {
+        if (_strSlice(str, i, i + 5) === "false") {
           i += 5;
           return false;
         }
-        if (str.substr(i, 4) === "null") {
+        if (_strSlice(str, i, i + 4) === "null") {
           i += 4;
           return null;
         }
@@ -3572,11 +4475,11 @@ var require_guard_json = __commonJS({
           ws();
           if (str[i] !== '"') fail("expected a string key");
           var key = string();
-          if (Object.prototype.hasOwnProperty.call(out, key)) throw E(spec.duplicateMember, "duplicate JSON member " + JSON.stringify(key));
+          if (_hasOwn(out, key)) throw E(spec.duplicateMember, "duplicate JSON member " + _stringify(key));
           ws();
           if (str[i] !== ":") fail("expected ':'");
           i++;
-          Object.defineProperty(out, key, { value: value(depth + 1), writable: true, enumerable: true, configurable: true });
+          _defineProperty(out, key, { value: value(depth + 1), writable: true, enumerable: true, configurable: true });
           ws();
           if (str[i] === ",") {
             i++;
@@ -3598,7 +4501,7 @@ var require_guard_json = __commonJS({
           return out;
         }
         for (; ; ) {
-          out.push(value(depth + 1));
+          _append(out, value(depth + 1));
           ws();
           if (str[i] === ",") {
             i++;
@@ -3633,14 +4536,14 @@ var require_guard_json = __commonJS({
               var cp = 0;
               if (i + 4 > n) fail("bad \\u escape");
               for (var h = 0; h < 4; h++) {
-                var d = _hexVal(str.charCodeAt(i + h));
+                var d = _hexVal(_charCodeAt(str, i + h));
                 if (d < 0) fail("bad \\u escape");
                 cp = cp << 4 | d;
               }
-              s += String.fromCharCode(cp);
+              s += _fromCharCode(cp);
               i += 4;
             } else fail("bad escape");
-          } else if (c.charCodeAt(0) < 32) {
+          } else if (_charCodeAt(c, 0) < 32) {
             fail("control character in string");
           } else s += c;
         }
@@ -3666,8 +4569,8 @@ var require_guard_json = __commonJS({
           while (i < n && str[i] >= "0" && str[i] <= "9") i++;
           if (i === expStart) fail("malformed number");
         }
-        var v = Number(str.slice(start, i));
-        if (!isFinite(v)) fail("bad number");
+        var v = _Number(_strSlice(str, start, i));
+        if (!_isFinite(v)) fail("bad number");
         return v;
       }
       var result = value(0);
@@ -3679,73 +4582,28 @@ var require_guard_json = __commonJS({
   }
 });
 
-// node_modules/@blamejs/pki/lib/guard-identifier.js
-var require_guard_identifier = __commonJS({
-  "node_modules/@blamejs/pki/lib/guard-identifier.js"(exports2, module2) {
-    "use strict";
-    function _isDottedDecimal(str) {
-      if (str.length === 0) return false;
-      var arcs = 0, digits = 0, leadingZero = false;
-      for (var i = 0; i < str.length; i++) {
-        var c = str.charCodeAt(i);
-        if (c === 46) {
-          if (digits === 0 || leadingZero) return false;
-          arcs++;
-          digits = 0;
-          leadingZero = false;
-          continue;
-        }
-        if (c < 48 || c > 57) return false;
-        if (digits === 1 && str.charCodeAt(i - 1) === 48) leadingZero = true;
-        digits++;
-      }
-      if (digits === 0 || leadingZero) return false;
-      return arcs >= 1;
-    }
-    function assertCanonicalOid(str, E, code, label, boundsCode) {
-      var who = label || "OID";
-      if (typeof str !== "string" || !_isDottedDecimal(str)) {
-        throw E(code, who + " must be a canonical dotted-decimal OID string of two or more arcs with no leading-zero component");
-      }
-      if (boundsCode === null) return str;
-      var bcode = boundsCode === void 0 ? code : boundsCode;
-      var parts = str.split(".");
-      var root = BigInt(parts[0]);
-      var second = BigInt(parts[1]);
-      if (root > 2n) throw E(bcode, who + " root arc must be 0, 1, or 2 (X.660)");
-      if (root < 2n && second > 39n) throw E(bcode, who + " second arc must be 0..39 under roots 0 and 1 (X.660)");
-      return str;
-    }
-    function assertKnownKeys(obj, known, E, code, message) {
-      var describe = typeof message === "function" ? message : function(k) {
-        return message + JSON.stringify(k);
-      };
-      Object.keys(obj).forEach(function(k) {
-        if (!Object.prototype.hasOwnProperty.call(known, k)) throw E(code, describe(k));
-      });
-    }
-    module2.exports = { assertCanonicalOid, assertKnownKeys };
-  }
-});
-
 // node_modules/@blamejs/pki/lib/guard-header.js
 var require_guard_header = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-header.js"(exports2, module2) {
     "use strict";
     var C = require_constants();
+    var _byteLength = require_guard_intrinsic().byteLength;
+    var _charCodeAt = require_guard_intrinsic().uncurry(String.prototype.charCodeAt);
+    var _stringify = require_guard_intrinsic().stringify;
+    var _String = require_guard_intrinsic().String;
     function assertField(name, value, E, code) {
       if (typeof name !== "string" || name.length === 0) throw new E(code, "a header field name must be a non-empty string");
       for (var i = 0; i < name.length; i++) {
-        var nc = name.charCodeAt(i);
-        if (nc < 33 || nc > 126 || nc === 58) throw new E(code, "a header field name must be RFC 5322 ftext (printable ASCII, no space / ':' / control): " + JSON.stringify(name));
+        var nc = _charCodeAt(name, i);
+        if (nc < 33 || nc > 126 || nc === 58) throw new E(code, "a header field name must be RFC 5322 ftext (printable ASCII, no space / ':' / control): " + _stringify(name));
       }
-      var v = typeof value === "string" ? value : String(value);
+      var v = typeof value === "string" ? value : _String(value);
       for (var j = 0; j < v.length; j++) {
-        var vc = v.charCodeAt(j);
-        if (vc === 0 || vc === 13 || vc === 10) throw new E(code, "a header field value must not contain CR / LF / NUL (header injection) in " + JSON.stringify(name));
+        var vc = _charCodeAt(v, j);
+        if (vc === 0 || vc === 13 || vc === 10) throw new E(code, "a header field value must not contain CR / LF / NUL (header injection) in " + _stringify(name));
       }
-      if (Buffer.byteLength(name, "utf8") + 2 + Buffer.byteLength(v, "utf8") > C.LIMITS.HEADER_LINE_MAX_OCTETS) {
-        throw new E(code, "a header field line exceeds RFC 5322's " + C.LIMITS.HEADER_LINE_MAX_OCTETS + "-octet limit: " + JSON.stringify(name));
+      if (_byteLength(name, "utf8") + 2 + _byteLength(v, "utf8") > C.LIMITS.HEADER_LINE_MAX_OCTETS) {
+        throw new E(code, "a header field line exceeds RFC 5322's " + C.LIMITS.HEADER_LINE_MAX_OCTETS + "-octet limit: " + _stringify(name));
       }
       return v;
     }
@@ -3758,6 +4616,16 @@ var require_guard_compress = __commonJS({
   "node_modules/@blamejs/pki/lib/guard-compress.js"(exports2, module2) {
     "use strict";
     var zlib = require("zlib");
+    var _intrinsic = require_guard_intrinsic();
+    var _bufferFrom = _intrinsic.bufferFrom;
+    var _isBuffer = _intrinsic.isBuffer;
+    var _isInteger = _intrinsic.isInteger;
+    var _objectKeys = _intrinsic.keys;
+    var _stringify = _intrinsic.stringify;
+    var _compare = _intrinsic.compare;
+    var _sizeOf = _intrinsic.sizeOf;
+    var _subarray = _intrinsic.uncurry(Uint8Array.prototype.subarray);
+    var _hasOwn = _intrinsic.hasOwn;
     var DECOMPRESS = {
       zlib: zlib.inflateSync,
       // RFC 1950
@@ -3775,41 +4643,41 @@ var require_guard_compress = __commonJS({
       var compress = _PROBE_COMPRESS[name];
       var decompress = DECOMPRESS[name];
       if (typeof compress !== "function" || typeof decompress !== "function") return false;
-      var sample = Buffer.from("0123456789abcdefghijklmnopqrstuvwxyz0123456789");
+      var sample = _bufferFrom("0123456789abcdefghijklmnopqrstuvwxyz0123456789");
       var frame, whole;
       try {
         frame = compress(sample);
       } catch (_e) {
         return false;
       }
-      if (!Buffer.isBuffer(frame) || frame.length < 4) return false;
+      if (!_isBuffer(frame) || _sizeOf(frame) < 4) return false;
       try {
         whole = decompress(frame, { maxOutputLength: 4096 });
       } catch (_e2) {
         return false;
       }
-      if (!Buffer.isBuffer(whole) || !whole.equals(sample)) return false;
+      if (!_isBuffer(whole) || _compare(whole, sample) !== 0) return false;
       var cutAccepted = false;
       try {
-        decompress(frame.subarray(0, frame.length - 2), { maxOutputLength: 4096 });
+        decompress(_subarray(frame, 0, _sizeOf(frame) - 2), { maxOutputLength: 4096 });
         cutAccepted = true;
       } catch (_e3) {
       }
       return !cutAccepted;
     }
     var SAFE = {};
-    Object.keys(DECOMPRESS).forEach(function(n) {
+    _intrinsic.forEach(_objectKeys(DECOMPRESS), function(n) {
       if (_reportsTruncation(n)) SAFE[n] = true;
     });
     function bounded(algorithm, stream, cap, E, codes, label) {
       var decompress = DECOMPRESS[algorithm];
-      if (!Object.prototype.hasOwnProperty.call(SAFE, algorithm) || !decompress) {
-        throw new TypeError("guard.compress.bounded: unknown or unsafe algorithm " + JSON.stringify(algorithm));
+      if (!_hasOwn(SAFE, algorithm) || !decompress) {
+        throw new TypeError("guard.compress.bounded: unknown or unsafe algorithm " + _stringify(algorithm));
       }
-      if (!Buffer.isBuffer(stream)) {
+      if (!_isBuffer(stream)) {
         throw new TypeError("guard.compress.bounded: stream must be a Buffer (route the input through guard.bytes.view first)");
       }
-      if (!Number.isInteger(cap) || cap < 1) {
+      if (!_isInteger(cap) || cap < 1) {
         throw new TypeError("guard.compress.bounded: cap must be a positive integer");
       }
       var what = label || "the compressed input";
@@ -3823,13 +4691,14 @@ var require_guard_compress = __commonJS({
         throw E(codes.failed, what + " could not be decompressed", e);
       }
       var consumed = res.engine.bytesWritten;
-      if (consumed !== stream.length) {
-        throw E(codes.failed, what + " carries " + (stream.length - consumed) + " trailing byte(s) after the end of the compressed stream");
+      var streamLen = _sizeOf(stream);
+      if (consumed !== streamLen) {
+        throw E(codes.failed, what + " carries " + (streamLen - consumed) + " trailing byte(s) after the end of the compressed stream");
       }
       return res.buffer;
     }
     function algorithms() {
-      return Object.keys(SAFE);
+      return _objectKeys(SAFE);
     }
     module2.exports = { bounded, algorithms };
   }
@@ -3855,6 +4724,7 @@ 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,
@@ -3871,7 +4741,8 @@ var require_guard_all = __commonJS({
       compress,
       secret,
       parsed,
-      async: async_
+      async: async_,
+      intrinsic
     };
   }
 });
@@ -4363,7 +5234,7 @@ var require_asn1_der = __commonJS({
       var d = /* @__PURE__ */ new Date(0);
       d.setUTCFullYear(year, month - 1, day);
       d.setUTCHours(hour, min, sec, ms);
-      if (isNaN(d.getTime())) throw new Asn1Error("asn1/bad-time", "unparseable time " + JSON.stringify(s));
+      if (isNaN(guard.time.instantOf(d))) throw new Asn1Error("asn1/bad-time", "unparseable time " + JSON.stringify(s));
       if (d.getUTCFullYear() !== year || d.getUTCMonth() !== month - 1 || d.getUTCDate() !== day || d.getUTCHours() !== hour || d.getUTCMinutes() !== min || d.getUTCSeconds() !== sec) {
         throw new Asn1Error("asn1/bad-time", "time component out of range " + JSON.stringify(s));
       }
@@ -4938,7 +5809,7 @@ var require_cbor_det = __commonJS({
       }
       var ns = Number(secs);
       var d = new Date(ns < 0 ? -constants.TIME.seconds(-ns) : constants.TIME.seconds(ns));
-      if (isNaN(d.getTime())) throw new CborError("cbor/bad-time", "epoch time out of range");
+      if (isNaN(guard.time.instantOf(d))) throw new CborError("cbor/bad-time", "epoch time out of range");
       return d;
     }
     function readOid(node) {
@@ -5071,12 +5942,12 @@ var require_cbor_det = __commonJS({
       },
       time: function(v) {
         var ms;
-        if (v instanceof Date) {
-          ms = v.getTime();
+        if (guard.time.isDate(v)) {
+          ms = guard.time.instantOf(v);
           if (Number.isNaN(ms)) throw new CborError("cbor/bad-time", "build.time: an Invalid Date has no epoch value");
           if (ms % 1e3 !== 0) throw new CborError("cbor/bad-time", "build.time: a Date with sub-second precision cannot be a second-granularity CBOR epoch; round to whole seconds");
         }
-        var secs = v instanceof Date ? BigInt(Math.floor(ms / 1e3)) : typeof v === "bigint" ? v : BigInt(v);
+        var secs = guard.time.isDate(v) ? BigInt(Math.floor(ms / 1e3)) : typeof v === "bigint" ? v : BigInt(v);
         if (secs < -_MAX_EPOCH_SECONDS || secs > _MAX_EPOCH_SECONDS) throw new CborError("cbor/bad-time", "build.time: epoch seconds " + secs + " are outside the representable Date range");
         return build.tag(1, build.int(secs));
       },
@@ -7476,7 +8347,7 @@ var require_ct = __commonJS({
       if (typeof ti !== "object") throw _ctErr("ct/bad-log-list", "a CT log temporal_interval must be an object");
       var start = rfc3339.parse(ti.start_inclusive, _ctErr, "ct/bad-date", "temporal_interval.start_inclusive");
       var end = rfc3339.parse(ti.end_exclusive, _ctErr, "ct/bad-date", "temporal_interval.end_exclusive");
-      if (start.getTime() >= end.getTime()) throw _ctErr("ct/bad-log-list", "a CT log temporal_interval start_inclusive must be strictly before end_exclusive");
+      if (guard.time.instantOf(start) >= guard.time.instantOf(end)) throw _ctErr("ct/bad-log-list", "a CT log temporal_interval start_inclusive must be strictly before end_exclusive");
       return { startInclusive: start, endExclusive: end };
     }
     function _parseLog(log, operatorName) {
@@ -7505,10 +8376,10 @@ var require_ct = __commonJS({
     function _sameTemporal(a, b) {
       if (a == null && b == null) return true;
       if (a == null || b == null) return false;
-      return a.startInclusive.getTime() === b.startInclusive.getTime() && a.endExclusive.getTime() === b.endExclusive.getTime();
+      return guard.time.instantOf(a.startInclusive) === guard.time.instantOf(b.startInclusive) && guard.time.instantOf(a.endExclusive) === guard.time.instantOf(b.endExclusive);
     }
     function _logsAgree(a, b) {
-      return a.state.name === b.state.name && a.state.since.getTime() === b.state.since.getTime() && _sameTemporal(a.temporalInterval, b.temporalInterval);
+      return a.state.name === b.state.name && guard.time.instantOf(a.state.since) === guard.time.instantOf(b.state.since) && _sameTemporal(a.temporalInterval, b.temporalInterval);
     }
     function parseLogList(json, opts) {
       void opts;
@@ -7550,7 +8421,7 @@ var require_ct = __commonJS({
       return { logs, byLogId, version, timestamp };
     }
     function _resolveNotAfter(entry, opts) {
-      if (opts.certNotAfter instanceof Date) return opts.certNotAfter;
+      if (guard.time.isDate(opts.certNotAfter)) return opts.certNotAfter;
       if (entry && entry.entryType === 0 && entry.leafCert != null) {
         var x509 = require_schema_x509();
         try {
@@ -7570,7 +8441,7 @@ var require_ct = __commonJS({
       if (!log.state.trusted) {
         if (!log.state.conditional) throw _ctErr("ct/log-untrusted", "the CT log state '" + log.state.name + "' is not trusted");
         var ts = guard.range.uint64(sct.timestamp, _ctErr, "ct/bad-input", "sct.timestamp");
-        if (ts >= BigInt(log.state.since.getTime())) throw _ctErr("ct/log-untrusted", "the CT log is retired and the SCT is not timestamped before its retirement (" + log.state.since.toISOString() + ")");
+        if (ts >= BigInt(guard.time.instantOf(log.state.since))) throw _ctErr("ct/log-untrusted", "the CT log is retired and the SCT is not timestamped before its retirement (" + log.state.since.toISOString() + ")");
       }
       if (log.temporalInterval) {
         var notAfter = _resolveNotAfter(entry, opts);
@@ -10716,12 +11587,12 @@ var require_schema_c509 = __commonJS({
       if (r.serialNumber == null && r.serialNumberHex == null) throw _err("c509/bad-input", "a C509 result must carry serialNumber or serialNumberHex");
       if (!r.signatureAlgorithm || typeof r.signatureAlgorithm.name !== "string") throw _err("c509/bad-input", "a C509 result must carry signatureAlgorithm.name");
       if (!r.subjectPublicKeyAlgorithm || typeof r.subjectPublicKeyAlgorithm.name !== "string") throw _err("c509/bad-input", "a C509 result must carry subjectPublicKeyAlgorithm.name");
-      if (!r.validity || !(r.validity.notBefore instanceof Date) || r.validity.notAfter !== null && !(r.validity.notAfter instanceof Date)) throw _err("c509/bad-input", "a C509 result must carry validity.notBefore (Date) and notAfter (Date or null)");
+      if (!r.validity || !guard.time.isDate(r.validity.notBefore) || r.validity.notAfter !== null && !guard.time.isDate(r.validity.notAfter)) throw _err("c509/bad-input", "a C509 result must carry validity.notBefore (Date) and notAfter (Date or null)");
       if (!Array.isArray(r.extensions)) throw _err("c509/bad-input", "a C509 result must carry an extensions array");
       if (!Buffer.isBuffer(r.signatureValue)) throw _err("c509/bad-input", "a C509 result must carry a Buffer signatureValue");
     }
     function _validityUint(date, label) {
-      var secs = Math.floor(date.getTime() / 1e3);
+      var secs = Math.floor(guard.time.instantOf(date) / 1e3);
       if (!isFinite(secs) || secs < 0) throw _err("c509/bad-validity", label + " is before the Unix epoch or not a valid date; C509 ~time is a non-negative CBOR epoch");
       return cbor.build.uint(BigInt(secs));
     }
@@ -10869,7 +11740,7 @@ var require_schema_c509 = __commonJS({
         // against a UTF8String of the same characters) would rebuild different bytes and break the
         // signature that covers them. Byte-identical is exactly the condition under which that is safe.
         issuer: c.issuer.bytes.equals(c.subject.bytes) ? null : _c509NameFromDer(c.issuer.bytes),
-        validity: { notBefore: c.validity.notBefore, notAfter: c.validity.notAfter.getTime() === _NO_EXPIRY ? null : c.validity.notAfter },
+        validity: { notBefore: c.validity.notBefore, notAfter: guard.time.instantOf(c.validity.notAfter) === _NO_EXPIRY ? null : c.validity.notAfter },
         subject: _c509NameFromDer(c.subject.bytes),
         subjectPublicKeyAlgorithm: { name: "ecPublicKey", oid: c.subjectPublicKeyInfo.algorithm.oid, curve },
         subjectPublicKey: _compressEcPoint(asn1.read.bitString(spkiNode.children[1]).bytes, coordLen),
@@ -11164,7 +12035,7 @@ var require_schema_csr = __commonJS({
         };
       }
     });
-    var parse = pkix.makeParser({ pemLabel: "CERTIFICATE REQUEST", PemError, ErrorClass: CsrError, prefix: "csr", what: "certification request", topSchema: CERTIFICATION_REQUEST, ns: NS });
+    var parse = pkix.makeRecordingParser({ pemLabel: "CERTIFICATE REQUEST", PemError, ErrorClass: CsrError, prefix: "csr", what: "certification request", topSchema: CERTIFICATION_REQUEST, ns: NS }, "csr");
     function pemDecode(text, label) {
       return pkix.pemDecode(text, label || "CERTIFICATE REQUEST", PemError);
     }
@@ -13750,7 +14621,7 @@ var require_schema_crmf = __commonJS({
         }) };
       }
     });
-    var parse = pkix.makeParser({
+    var parse = pkix.makeRecordingParser({
       pemLabel: null,
       PemError,
       ErrorClass: CrmfError,
@@ -13758,7 +14629,7 @@ var require_schema_crmf = __commonJS({
       what: "certificate request message",
       topSchema: CERT_REQ_MESSAGES,
       ns: NS
-    });
+    }, "crmf");
     function pemDecode(text, label) {
       return pkix.pemDecode(text, label || null, PemError);
     }
@@ -15129,11 +16000,18 @@ var require_schema_attrcert = __commonJS({
     function _legacyV1Error() {
       return new AttrCertError("attrcert/legacy-v1-not-supported", "AttributeCertificateV1 (X.509-1997) is obsolete and not parsed by this build (RFC 5755 sec. 1)");
     }
-    function parse(input) {
+    function _parseAc(input) {
       var root = pkix.decodeRoot(pkix.coerceToDer(input, PARSE_OPTS), PARSE_OPTS);
       if (matchesV1(root)) throw _legacyV1Error();
       return schema.walk(ATTRIBUTE_CERTIFICATE, root, NS).result;
     }
+    var parse = guard.parsed.recordingParser(
+      "attributeCertificate",
+      _parseAc,
+      AttrCertError,
+      "attrcert/bad-input",
+      "an attribute certificate"
+    );
     function parseV1(input) {
       pkix.decodeRoot(pkix.coerceToDer(input, PARSE_OPTS), PARSE_OPTS);
       throw _legacyV1Error();
@@ -15185,6 +16063,9 @@ var require_schema_attrcert = __commonJS({
       var gn = schema.walk(_GN, node, NS);
       return { tagNumber: gn.tagNumber, value: gn.value };
     }
+    function readGeneralName(der, code) {
+      return _oneGN(asn1.decode(der), code || "attrcert/bad-input");
+    }
     function _svceAuthInfo(authInfoAllowed, code) {
       return function(buf) {
         var kids = _seqChildren(buf, code, "SvceAuthInfo");
@@ -15433,6 +16314,7 @@ var require_schema_attrcert = __commonJS({
       pemEncode,
       matches,
       matchesV1,
+      readGeneralName,
       validateAttributeValue,
       validateExtensionValue
     };
@@ -16683,6 +17565,7 @@ var require_ocsp_verify = __commonJS({
   "node_modules/@blamejs/pki/lib/ocsp-verify.js"(exports2, module2) {
     "use strict";
     var asn1 = require_asn1_der();
+    var guard = require_guard_all();
     var oid = require_oid();
     var x509 = require_schema_x509();
     var compositeSig = require_composite_sig();
@@ -16781,7 +17664,7 @@ var require_ocsp_verify = __commonJS({
           if (!issuedByCa) continue;
           if (!isOctetAligned(rc.signatureValue)) continue;
           if (!await verifyWithSpki(rc.signatureAlgorithm, rc.signatureValue.bytes, issuer.workingPublicKey, rc.tbsBytes)) continue;
-          if (time < rc.validity.notBefore || time > rc.validity.notAfter) continue;
+          if (guard.time.instantOf(time) < guard.time.instantOf(rc.validity.notBefore) || guard.time.instantOf(time) > guard.time.instantOf(rc.validity.notAfter)) continue;
           var eku;
           try {
             eku = decodeExt(rc, OID_EKU);
@@ -16824,14 +17707,14 @@ var require_ocsp_verify = __commonJS({
           var sr = br.responses[s];
           if (!await ocspCertIdMatches(sr.certID, cert, issuerNameCandidates, issuerKeyBits)) continue;
           if (ocspHasCriticalExtension(sr.singleExtensions)) continue;
-          if (sr.thisUpdate > time) continue;
-          if (!sr.nextUpdate || sr.nextUpdate < time) continue;
+          if (guard.time.instantOf(sr.thisUpdate) > guard.time.instantOf(time)) continue;
+          if (!sr.nextUpdate || guard.time.instantOf(sr.nextUpdate) < guard.time.instantOf(time)) continue;
           out.matched = true;
           out.thisUpdate = sr.thisUpdate;
           out.nextUpdate = sr.nextUpdate;
           var st = sr.certStatus;
           if (st.type === "revoked") {
-            if (historical && st.revocationTime instanceof Date && st.revocationTime.getTime() > time.getTime()) {
+            if (historical && guard.time.isDate(st.revocationTime) && guard.time.instantOf(st.revocationTime) > guard.time.instantOf(time)) {
               out.sawGood = true;
             } else if (!out.revoked) {
               out.revoked = { revocationReason: st.revocationReason || null, reason: "certificate reported revoked by an authorized OCSP responder" + (st.revocationReason ? " (" + st.revocationReason + ")" : "") };
@@ -16856,20 +17739,88 @@ var require_ocsp_verify = __commonJS({
   }
 });
 
+// node_modules/@blamejs/pki/lib/verify-seam.js
+var require_verify_seam = __commonJS({
+  "node_modules/@blamejs/pki/lib/verify-seam.js"(exports2, module2) {
+    "use strict";
+    var guard = require_guard_all();
+    function makeSeam(name, ErrorClass, code) {
+      var engine = null;
+      return {
+        setEngine: function(verifyWithSpki) {
+          engine = verifyWithSpki;
+        },
+        verify: function(sigAlg, signature, spkiBytes, preimage) {
+          if (engine == null) {
+            throw new ErrorClass(code, "the " + name + " signature engine is not initialized (require pki before use)");
+          }
+          if (!guard.crypto.isOctetAligned(signature)) return Promise.resolve(false);
+          return engine(sigAlg, signature.bytes, spkiBytes, preimage);
+        }
+      };
+    }
+    module2.exports = { makeSeam };
+  }
+});
+
 // node_modules/@blamejs/pki/lib/crl-verify.js
 var require_crl_verify = __commonJS({
   "node_modules/@blamejs/pki/lib/crl-verify.js"(exports2, module2) {
     "use strict";
-    var guard = require_guard_all();
-    var _engine = null;
-    function setEngine(verifyWithSpki) {
-      _engine = verifyWithSpki;
-    }
+    var frameworkError = require_framework_error();
+    var seam = require_verify_seam();
+    var _seam = seam.makeSeam("crl-verify", frameworkError.CrlError, "crl/bad-input");
     function verifyCrlSignature(crl, spkiBytes) {
-      if (!guard.crypto.isOctetAligned(crl.signatureValue)) return Promise.resolve(false);
-      return _engine(crl.signatureAlgorithm, crl.signatureValue.bytes, spkiBytes, crl.tbsBytes);
+      return _seam.verify(crl.signatureAlgorithm, crl.signatureValue, spkiBytes, crl.tbsBytes);
+    }
+    module2.exports = { setEngine: _seam.setEngine, verifyCrlSignature };
+  }
+});
+
+// node_modules/@blamejs/pki/lib/csr-verify.js
+var require_csr_verify = __commonJS({
+  "node_modules/@blamejs/pki/lib/csr-verify.js"(exports2, module2) {
+    "use strict";
+    var frameworkError = require_framework_error();
+    var seam = require_verify_seam();
+    var _seam = seam.makeSeam("csr-verify", frameworkError.CsrError, "csr/bad-input");
+    function verifyCsrSignature(parsed) {
+      return _seam.verify(
+        parsed.signatureAlgorithm,
+        parsed.signatureValue,
+        parsed.subjectPublicKeyInfo.bytes,
+        parsed.certificationRequestInfoBytes
+      );
+    }
+    module2.exports = { setEngine: _seam.setEngine, verifyCsrSignature };
+  }
+});
+
+// node_modules/@blamejs/pki/lib/crmf-verify.js
+var require_crmf_verify = __commonJS({
+  "node_modules/@blamejs/pki/lib/crmf-verify.js"(exports2, module2) {
+    "use strict";
+    var frameworkError = require_framework_error();
+    var seam = require_verify_seam();
+    var _seam = seam.makeSeam("crmf-verify", frameworkError.CrmfError, "crmf/bad-input");
+    function verifyPopSignature(popo, spkiBytes, preimage) {
+      return _seam.verify(popo.algorithmIdentifier, popo.signature, spkiBytes, preimage);
     }
-    module2.exports = { setEngine, verifyCrlSignature };
+    module2.exports = { setEngine: _seam.setEngine, verifyPopSignature };
+  }
+});
+
+// node_modules/@blamejs/pki/lib/attrcert-verify.js
+var require_attrcert_verify = __commonJS({
+  "node_modules/@blamejs/pki/lib/attrcert-verify.js"(exports2, module2) {
+    "use strict";
+    var frameworkError = require_framework_error();
+    var seam = require_verify_seam();
+    var _seam = seam.makeSeam("attrcert-verify", frameworkError.AttrCertError, "attrcert/bad-input");
+    function verifyAcSignature(ac, spkiBytes) {
+      return _seam.verify(ac.signatureAlgorithm, ac.signatureValue, spkiBytes, ac.tbsBytes);
+    }
+    module2.exports = { setEngine: _seam.setEngine, verifyAcSignature };
   }
 });
 
@@ -17602,6 +18553,8 @@ var require_crmf_sign = __commonJS({
     var pkiBuild = require_pki_build();
     var frameworkError = require_framework_error();
     var guard = require_guard_all();
+    require_path_validate();
+    var crmfVerify = require_crmf_verify();
     var CrmfError = frameworkError.CrmfError;
     var b = asn1.build;
     function _err(code, message, cause) {
@@ -17647,7 +18600,7 @@ var require_crmf_sign = __commonJS({
       var parts = [];
       if (nb != null) parts.push(b.explicit(0, _b.timeDer(nb, "validity notBefore")));
       if (na != null) parts.push(b.explicit(1, _b.timeDer(na, "validity notAfter")));
-      if (nb != null && na != null && nb.getTime() > na.getTime()) throw _err("crmf/bad-validity", "notBefore must not be after notAfter");
+      if (nb != null && na != null && guard.time.instantOf(nb) > guard.time.instantOf(na)) throw _err("crmf/bad-validity", "notBefore must not be after notAfter");
       return b.implicit(4, b.sequence(parts));
     }
     function _encodeCertTemplate(tpl, opts) {
@@ -17817,7 +18770,75 @@ var require_crmf_sign = __commonJS({
     function buildCertTemplate(template) {
       return _encodeCertTemplate(template, { revocation: true }).der;
     }
-    module2.exports = { build, buildCertTemplate };
+    function _coerceMessages(input) {
+      return guard.parsed.acceptDerived(input, "crmf", crmf.parse, _err, "crmf/bad-input", "the certificate request messages");
+    }
+    function _verifyOne(msg) {
+      var t = msg.certReq && msg.certReq.certTemplate;
+      var base = {
+        certReqId: msg.certReq && msg.certReq.certReqId,
+        subject: t && t.subject || null,
+        subjectBound: false,
+        publicKey: t && t.publicKey && t.publicKey.bytes || null
+      };
+      function settle(extra) {
+        return Promise.resolve(Object.assign({}, base, extra));
+      }
+      var popo = msg.popo;
+      if (popo == null) {
+        return settle({
+          verified: false,
+          method: null,
+          cryptographicallyVerified: false,
+          reason: "the request carries no proof of possession"
+        });
+      }
+      if (popo.type === "raVerified") {
+        return settle({
+          verified: false,
+          method: "raVerified",
+          cryptographicallyVerified: false,
+          reason: "raVerified asserts the RA checked possession out of band -- this is not a proof and cannot be verified from the message"
+        });
+      }
+      if (popo.type !== "signature") {
+        return settle({
+          verified: false,
+          method: popo.type,
+          cryptographicallyVerified: false,
+          reason: "a " + popo.type + " proof of possession completes over an exchange this verifier does not hold (RFC 4211 sec. 4.2, 4.3)"
+        });
+      }
+      var pin = popo.poposkInput;
+      var preimage = pin ? pin.signedBytes : msg.certReq.certReqBytes;
+      var spki = pin ? pin.publicKey : base.publicKey;
+      var bound = !pin;
+      return crmfVerify.verifyPopSignature(popo, spki, preimage).then(function(ok) {
+        return Object.assign({}, base, {
+          verified: ok === true,
+          method: "signature",
+          cryptographicallyVerified: ok === true,
+          subject: bound ? base.subject : null,
+          subjectBound: bound,
+          publicKey: spki || null,
+          reason: ok === true ? void 0 : "the proof-of-possession signature does not verify under the requested public key"
+        });
+      });
+    }
+    function verifyPop(messages) {
+      return guard.async.deferred(function() {
+        return _verifyPop(messages);
+      });
+    }
+    function _verifyPop(messages) {
+      var parsed = _coerceMessages(messages);
+      return Promise.all(parsed.messages.map(_verifyOne)).then(function(out) {
+        return { verified: out.length > 0 && out.every(function(m) {
+          return m.verified === true;
+        }), messages: out };
+      });
+    }
+    module2.exports = { build, buildCertTemplate, verifyPop };
   }
 });
 
@@ -18768,6 +19789,33 @@ var require_cmp_build = __commonJS({
 var require_cmp_verify = __commonJS({
   "node_modules/@blamejs/pki/lib/cmp-verify.js"(exports2, module2) {
     "use strict";
+    var intrinsic = require_guard_intrinsic();
+    var _sizeOf = intrinsic.sizeOf;
+    var util = { types: intrinsic.types };
+    var _isBuffer = intrinsic.isBuffer;
+    var _bufferFrom = intrinsic.bufferFrom;
+    var _fromCharCode = intrinsic.fromCharCode;
+    var _stringify = intrinsic.stringify;
+    var _getOwnPropertyNames = intrinsic.getOwnPropertyNames;
+    var _charAt = intrinsic.uncurry(String.prototype.charAt);
+    var _create = intrinsic.create;
+    var _floor = intrinsic.floor;
+    var _ceil = intrinsic.ceil;
+    var _min = intrinsic.min;
+    var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+    var _toLowerCase = intrinsic.uncurry(String.prototype.toLowerCase);
+    var _strIndexOf = intrinsic.uncurry(String.prototype.indexOf);
+    var _compare = intrinsic.compare;
+    var _toString = intrinsic.uncurry(Buffer.prototype.toString);
+    var _map = intrinsic.map;
+    var _String = intrinsic.String;
+    var _isFinite = intrinsic.isFinite;
+    var _strSlice = intrinsic.uncurry(String.prototype.slice);
+    var _strLastIndexOf = intrinsic.uncurry(String.prototype.lastIndexOf);
+    var _strSearch = intrinsic.uncurry(String.prototype.search);
+    var _reTest = intrinsic.uncurry(RegExp.prototype.test);
+    var _reExec = intrinsic.uncurry(RegExp.prototype.exec);
+    var _isArray = Array.isArray;
     var asn1 = require_asn1_der();
     var oid = require_oid();
     var cmpBuild = require_cmp_build();
@@ -18799,7 +19847,7 @@ var require_cmp_verify = __commonJS({
       revocationChecker: 1,
       maxIterations: 1
     };
-    var PRF_HASH = {};
+    var PRF_HASH = _create(null);
     PRF_HASH[oid.byName("hmacWithSHA256")] = "SHA-256";
     PRF_HASH[oid.byName("hmacWithSHA384")] = "SHA-384";
     PRF_HASH[oid.byName("hmacWithSHA512")] = "SHA-512";
@@ -18810,7 +19858,7 @@ var require_cmp_verify = __commonJS({
     var PBMAC1_KEYLEN_MIN = 20;
     var PBMAC1_KEYLEN_MAX = 1024;
     var PRF_HLEN = { "SHA-256": 32, "SHA-384": 48, "SHA-512": 64 };
-    var UNSUPPORTED_MAC_OIDS = {};
+    var UNSUPPORTED_MAC_OIDS = _create(null);
     ["passwordBasedMac", "dhBasedMac", "kemBasedMac"].forEach(function(n) {
       var o = oid.byName(n);
       if (o) UNSUPPORTED_MAC_OIDS[o] = n;
@@ -18845,28 +19893,28 @@ var require_cmp_verify = __commonJS({
       return _verdict(m, type, alg, false, false, code, reason, signer || null);
     }
     function _coerce(message) {
-      if (message && typeof message === "object" && !Buffer.isBuffer(message) && !(message instanceof Uint8Array) && message.headerBytes !== void 0 && message.bodyBytes !== void 0 && message.header !== void 0 && message.body !== void 0) {
+      if (message && typeof message === "object" && !_isBuffer(message) && !util.types.isUint8Array(message) && message.headerBytes !== void 0 && message.bodyBytes !== void 0 && message.header !== void 0 && message.body !== void 0) {
         try {
           return cmp.parse(_reassemble(message));
         } catch (e) {
           throw e instanceof CmpError ? e : _err("cmp/bad-input", "the parsed PKIMessage object carries a malformed raw slice (headerBytes / bodyBytes / protection / extraCerts): " + (e && e.message || e), e);
         }
       }
-      if (Buffer.isBuffer(message) || message instanceof Uint8Array) return cmp.parse(Buffer.from(message));
+      if (_isBuffer(message) || util.types.isUint8Array(message)) return cmp.parse(_bufferFrom(message));
       return cmp.parse(message);
     }
     function _reassemble(m) {
       var kids = [b.raw(m.headerBytes), b.raw(m.bodyBytes)];
-      if (m.protection != null) kids.push(b.explicit(0, b.bitString(m.protection.bytes, m.protection.unusedBits)));
+      if (m.protection != null) _append(kids, b.explicit(0, b.bitString(m.protection.bytes, m.protection.unusedBits)));
       if (m.extraCerts != null && m.extraCerts.length) {
-        kids.push(b.explicit(1, b.sequence(m.extraCerts.map(function(c) {
+        _append(kids, b.explicit(1, b.sequence(_map(m.extraCerts, function(c) {
           return b.raw(c);
         }))));
       }
       return b.sequence(kids);
     }
     function _certDer(cert, what) {
-      if (Buffer.isBuffer(cert) || cert instanceof Uint8Array) return guard.bytes.view(cert, CmpError, "cmp/bad-input", what);
+      if (_isBuffer(cert) || util.types.isUint8Array(cert)) return guard.bytes.view(cert, CmpError, "cmp/bad-input", what);
       if (typeof cert === "string") {
         try {
           return x509.pemDecode(cert);
@@ -18911,7 +19959,7 @@ var require_cmp_verify = __commonJS({
       if (!sender || !sender.bytes) return false;
       var subjectRdns = parsed.subject.rdns;
       if (subjectRdns.length > 0) {
-        var isDirName = sender.tagClass === "context" && sender.tagNumber === 4 && sender.value && Array.isArray(sender.value.rdns);
+        var isDirName = sender.tagClass === "context" && sender.tagNumber === 4 && sender.value && _isArray(sender.value.rdns);
         if (isDirName && guard.name.dnEqual(sender.value.rdns, subjectRdns, NS.E, "cmp/sender-mismatch", "the header sender / signer subject")) return true;
       }
       var san = _sanGeneralNames(parsed);
@@ -18922,18 +19970,18 @@ var require_cmp_verify = __commonJS({
       if (sanNode.tagClass !== sender.tagClass || sanNode.tagNumber !== sender.tagNumber) return false;
       if (sanNode.tagClass === "context") {
         if (sanNode.tagNumber === 2 && sanNode.content) {
-          var dnsSan = sanNode.content.toString("latin1"), dnsSender = String(sender.value);
+          var dnsSan = _toString(sanNode.content, "latin1"), dnsSender = _String(sender.value);
           if (pkix.dnsNameProblem(dnsSan) !== null || pkix.dnsNameProblem(dnsSender) !== null) return dnsSan === dnsSender;
-          return dnsSender.toLowerCase() === dnsSan.toLowerCase();
+          return _toLowerCase(dnsSender) === _toLowerCase(dnsSan);
         }
         if (sanNode.tagNumber === 1 && sanNode.content) {
-          return _rfc822Equal(String(sender.value), sanNode.content.toString("latin1"));
+          return _rfc822Equal(_String(sender.value), _toString(sanNode.content, "latin1"));
         }
         if (sanNode.tagNumber === 6 && sanNode.content) {
-          return _uriEqual(String(sender.value), sanNode.content.toString("latin1"));
+          return _uriEqual(_String(sender.value), _toString(sanNode.content, "latin1"));
         }
         if (sanNode.tagNumber === 4 && sanNode.children && sanNode.children.length) {
-          if (!sender.value || !Array.isArray(sender.value.rdns)) return false;
+          if (!sender.value || !_isArray(sender.value.rdns)) return false;
           var sanName;
           try {
             sanName = schema.embeddedDer(pkix.name(NS), sanNode.children[0].bytes, NS, { code: "cmp/sender-mismatch", what: "SAN directoryName" }).result;
@@ -18943,14 +19991,14 @@ var require_cmp_verify = __commonJS({
           return guard.name.dnEqual(sender.value.rdns, sanName.rdns, NS.E, "cmp/sender-mismatch", "SAN directoryName");
         }
       }
-      return sanNode.bytes.equals(sender.bytes);
+      return _compare(sanNode.bytes, sender.bytes) === 0;
     }
     function _mailboxSplit(s) {
       var sep;
-      if (s.charAt(0) === '"') {
+      if (_charAt(s, 0) === '"') {
         var i = 1;
         while (i < s.length) {
-          var c = s.charAt(i);
+          var c = _charAt(s, i);
           if (c === "\\") {
             i += 2;
             continue;
@@ -18958,60 +20006,60 @@ var require_cmp_verify = __commonJS({
           if (c === '"') break;
           i++;
         }
-        if (i >= s.length || s.charAt(i) !== '"' || s.charAt(i + 1) !== "@") return -1;
+        if (i >= s.length || _charAt(s, i) !== '"' || _charAt(s, i + 1) !== "@") return -1;
         sep = i + 1;
       } else {
-        sep = s.indexOf("@");
-        if (sep < 0 || sep !== s.lastIndexOf("@")) return -1;
+        sep = _strIndexOf(s, "@");
+        if (sep < 0 || sep !== _strLastIndexOf(s, "@")) return -1;
       }
-      var local = s.slice(0, sep), domain = s.slice(sep + 1);
+      var local = _strSlice(s, 0, sep), domain = _strSlice(s, sep + 1);
       if (pkix.dnsNameProblem(domain) !== null) return -1;
-      if (s.charAt(0) !== '"' && (local.length === 0 || local.charAt(0) === "." || local.charAt(local.length - 1) === "." || local.indexOf("..") !== -1 || !/^[A-Za-z0-9!#$%&'*+/=?^_`{|}~.-]+$/.test(local))) return -1;
+      if (_charAt(s, 0) !== '"' && (local.length === 0 || _charAt(local, 0) === "." || _charAt(local, local.length - 1) === "." || _strIndexOf(local, "..") !== -1 || !_reTest(/^[A-Za-z0-9!#$%&'*+/=?^_`{|}~.-]+$/, local))) return -1;
       return sep;
     }
     function _rfc822Equal(a, b2) {
       var ai = _mailboxSplit(a), bi = _mailboxSplit(b2);
       if (ai < 0 || bi < 0) return a === b2;
-      return a.slice(0, ai) === b2.slice(0, bi) && _lowerAsciiDomain(a.slice(ai + 1)) === _lowerAsciiDomain(b2.slice(bi + 1));
+      return _strSlice(a, 0, ai) === _strSlice(b2, 0, bi) && _lowerAsciiDomain(_strSlice(a, ai + 1)) === _lowerAsciiDomain(_strSlice(b2, bi + 1));
     }
     function _lowerAsciiDomain(h) {
       var out = "";
       for (var i = 0; i < h.length; i++) {
-        var c = h.charCodeAt(i);
-        out += c >= 65 && c <= 90 ? String.fromCharCode(c + 32) : h.charAt(i);
+        var c = _charCodeAt(h, i);
+        out += c >= 65 && c <= 90 ? _fromCharCode(c + 32) : _charAt(h, i);
       }
       return out;
     }
     function _normalizeUri(u) {
-      if (!/^[A-Za-z0-9._~:/?#@!$&'()*+,;=%[\]-]*$/.test(u) || /%(?![0-9A-Fa-f]{2})/.test(u)) return null;
-      var m = /^([a-zA-Z][a-zA-Z0-9+.-]*):(.*)$/.exec(u);
+      if (!_reTest(/^[A-Za-z0-9._~:/?#@!$&'()*+,;=%[\]-]*$/, u) || _reTest(/%(?![0-9A-Fa-f]{2})/, u)) return null;
+      var m = _reExec(/^([a-zA-Z][a-zA-Z0-9+.-]*):(.*)$/, u);
       if (!m) return null;
-      var scheme = m[1].toLowerCase();
+      var scheme = _toLowerCase(m[1]);
       var rest = m[2];
-      if (rest.slice(0, 2) !== "//") return null;
-      var body = rest.slice(2);
-      var cut = body.search(/[/?#]/);
+      if (_strSlice(rest, 0, 2) !== "//") return null;
+      var body = _strSlice(rest, 2);
+      var cut = _strSearch(body, /[/?#]/);
       var split = cut < 0 ? body.length : cut;
-      var authority = body.slice(0, split), tail = body.slice(split);
-      if (authority.indexOf("@") !== authority.lastIndexOf("@")) return null;
-      var at = authority.lastIndexOf("@");
-      var userinfo = at < 0 ? "" : authority.slice(0, at + 1);
-      var hostport = at < 0 ? authority : authority.slice(at + 1);
+      var authority = _strSlice(body, 0, split), tail = _strSlice(body, split);
+      if (_strIndexOf(authority, "@") !== _strLastIndexOf(authority, "@")) return null;
+      var at = _strLastIndexOf(authority, "@");
+      var userinfo = at < 0 ? "" : _strSlice(authority, 0, at + 1);
+      var hostport = at < 0 ? authority : _strSlice(authority, at + 1);
       var host, port;
-      if (hostport.charAt(0) === "[") {
-        var rb = hostport.indexOf("]");
+      if (_charAt(hostport, 0) === "[") {
+        var rb = _strIndexOf(hostport, "]");
         if (rb < 0) return null;
-        host = hostport.slice(0, rb + 1);
-        port = hostport.slice(rb + 1);
+        host = _strSlice(hostport, 0, rb + 1);
+        port = _strSlice(hostport, rb + 1);
       } else {
-        var ci = hostport.indexOf(":");
-        host = ci < 0 ? hostport : hostport.slice(0, ci);
-        port = ci < 0 ? "" : hostport.slice(ci);
+        var ci = _strIndexOf(hostport, ":");
+        host = ci < 0 ? hostport : _strSlice(hostport, 0, ci);
+        port = ci < 0 ? "" : _strSlice(hostport, ci);
       }
-      if (port !== "" && !/^:[0-9]*$/.test(port)) return null;
-      var hostOk = host.charAt(0) === "[" ? host.charAt(host.length - 1) === "]" && ipUtils.expandIpv6Hex(host.slice(1, -1)) !== null : pkix.dnsNameProblem(host) === null;
+      if (port !== "" && !_reTest(/^:[0-9]*$/, port)) return null;
+      var hostOk = _charAt(host, 0) === "[" ? _charAt(host, host.length - 1) === "]" && ipUtils.expandIpv6Hex(_strSlice(host, 1, -1)) !== null : pkix.dnsNameProblem(host) === null;
       if (!hostOk) return null;
-      return scheme + "://" + userinfo + host.toLowerCase() + port + tail;
+      return scheme + "://" + userinfo + _toLowerCase(host) + port + tail;
     }
     function _uriEqual(a, b2) {
       var na = _normalizeUri(a), nb = _normalizeUri(b2);
@@ -19037,7 +20085,7 @@ var require_cmp_verify = __commonJS({
         return _signerObj(der, p);
       }
       if (opts.signerCert != null) {
-        var scDer = Buffer.from(_certDer(opts.signerCert, "opts.signerCert"));
+        var scDer = _bufferFrom(_certDer(opts.signerCert, "opts.signerCert"));
         var scParsed;
         try {
           scParsed = x509.parse(scDer);
@@ -19057,12 +20105,12 @@ var require_cmp_verify = __commonJS({
       return null;
     }
     function _bufEq(a, x) {
-      if (!Buffer.isBuffer(a)) return false;
-      if (!Buffer.isBuffer(x)) {
-        if (x instanceof Uint8Array) x = Buffer.from(x);
+      if (!_isBuffer(a)) return false;
+      if (!_isBuffer(x)) {
+        if (util.types.isUint8Array(x)) x = _bufferFrom(x);
         else return false;
       }
-      return a.length === x.length && a.equals(x);
+      return _compare(a, x) === 0;
     }
     function _headerChecks(m, opts) {
       if (opts.transactionID != null && !_bufEq(m.header.transactionID, opts.transactionID)) {
@@ -19101,10 +20149,10 @@ var require_cmp_verify = __commonJS({
       var kdf = params.kdf;
       var prfHash = PRF_HASH[kdf.prfOid];
       var macHash = PRF_HASH[params.schemeOid];
-      if (!prfHash) return _fail(m, "mac", protectionAlg, "cmp/unsupported-algorithm", "unsupported PBMAC1 PBKDF2 PRF " + JSON.stringify(kdf.prfName) + " (SHA-256/384/512 only; RFC 9481 sec. 7, RFC 9579 sec. 7)");
-      if (!macHash) return _fail(m, "mac", protectionAlg, "cmp/unsupported-algorithm", "unsupported PBMAC1 messageAuthScheme " + JSON.stringify(params.schemeName) + " (SHA-256/384/512 only)");
+      if (!prfHash) return _fail(m, "mac", protectionAlg, "cmp/unsupported-algorithm", "unsupported PBMAC1 PBKDF2 PRF " + _stringify(kdf.prfName) + " (SHA-256/384/512 only; RFC 9481 sec. 7, RFC 9579 sec. 7)");
+      if (!macHash) return _fail(m, "mac", protectionAlg, "cmp/unsupported-algorithm", "unsupported PBMAC1 messageAuthScheme " + _stringify(params.schemeName) + " (SHA-256/384/512 only)");
       _capWork(kdf.iterationCount, kdf.salt, kdf.keyLength, prfHash, opts);
-      var secret = typeof opts.sharedSecret === "string" ? Buffer.from(opts.sharedSecret, "utf8") : guard.bytes.view(opts.sharedSecret, CmpError, "cmp/bad-input", "opts.sharedSecret");
+      var secret = typeof opts.sharedSecret === "string" ? _bufferFrom(opts.sharedSecret, "utf8") : guard.bytes.view(opts.sharedSecret, CmpError, "cmp/bad-input", "opts.sharedSecret");
       var computed = await pbes2.pbmac1(secret, kdf.salt, kdf.iterationCount, kdf.keyLength, prfHash, macHash, protectedPart);
       if (!guard.crypto.constantTimeEqual(computed, protection.bytes)) {
         return _fail(m, "mac", protectionAlg, "cmp/protection-failed", "the PBMAC1 MAC does not verify (a wrong shared secret or a tampered ProtectedPart)");
@@ -19116,16 +20164,17 @@ var require_cmp_verify = __commonJS({
     function _capWork(iterationCount, salt, keyLength, prfHash, opts) {
       var cap = PBMAC1_MAX_ITER;
       if (opts.maxIterations != null) {
-        if (typeof opts.maxIterations !== "number" || !isFinite(opts.maxIterations) || opts.maxIterations < 1 || Math.floor(opts.maxIterations) !== opts.maxIterations) {
+        if (typeof opts.maxIterations !== "number" || !_isFinite(opts.maxIterations) || opts.maxIterations < 1 || _floor(opts.maxIterations) !== opts.maxIterations) {
           throw _err("cmp/bad-input", "opts.maxIterations must be a positive integer");
         }
-        cap = Math.min(opts.maxIterations, cap);
+        cap = _min(opts.maxIterations, cap);
       }
       if (iterationCount < PBMAC1_MIN_ITER) throw _err("cmp/bad-input", "the PBMAC1 iterationCount " + iterationCount + " is below the floor " + PBMAC1_MIN_ITER + " (RFC 8018 sec. 4.2)");
       if (iterationCount > cap) throw _err("cmp/bad-input", "the PBMAC1 iterationCount " + iterationCount + " exceeds the cap " + cap);
-      if (!salt || salt.length < PBMAC1_MIN_SALT || salt.length > PBMAC1_MAX_SALT) throw _err("cmp/bad-input", "the PBMAC1 salt length must be in [" + PBMAC1_MIN_SALT + ", " + PBMAC1_MAX_SALT + "] octets (RFC 8018 sec. 4.1)");
+      var saltLen = salt ? _sizeOf(salt) : 0;
+      if (!salt || saltLen < PBMAC1_MIN_SALT || saltLen > PBMAC1_MAX_SALT) throw _err("cmp/bad-input", "the PBMAC1 salt length must be in [" + PBMAC1_MIN_SALT + ", " + PBMAC1_MAX_SALT + "] octets (RFC 8018 sec. 4.1)");
       if (keyLength < PBMAC1_KEYLEN_MIN || keyLength > PBMAC1_KEYLEN_MAX) throw _err("cmp/bad-input", "the PBMAC1 keyLength must be in [" + PBMAC1_KEYLEN_MIN + ", " + PBMAC1_KEYLEN_MAX + "] (RFC 9579 sec. 9)");
-      var blocks = Math.ceil(keyLength / (PRF_HLEN[prfHash] || 32));
+      var blocks = _ceil(keyLength / (PRF_HLEN[prfHash] || 32));
       if (iterationCount * blocks > cap) throw _err("cmp/bad-input", "the PBMAC1 combined work (iterationCount " + iterationCount + " x " + blocks + " derived blocks) exceeds the cap " + cap);
     }
     async function _verifySignature(m, protectedPart, protectionAlg, protection, opts) {
@@ -19148,7 +20197,7 @@ var require_cmp_verify = __commonJS({
       try {
         var p = guard.parsed.acceptDerived(c, "certificate", x509.parse, _err, "cmp/bad-input", "a pool certificate");
         if (!guard.parsed.isCert(p)) return null;
-        return p.tbsBytes.toString("base64") + "|" + p.signatureValue.bytes.toString("base64");
+        return _toString(p.tbsBytes, "base64") + "|" + _toString(p.signatureValue.bytes, "base64");
       } catch (_e) {
         return null;
       }
@@ -19157,43 +20206,48 @@ var require_cmp_verify = __commonJS({
       if (!_keyUsageAllowsSigning(signer.parsed)) {
         return { trusted: false, reason: "the signer certificate keyUsage does not assert digitalSignature (RFC 9483 sec. 3.2)" };
       }
-      var time = opts.time != null ? opts.time : /* @__PURE__ */ new Date();
+      var time = opts.time != null ? opts.time : new _Date();
       var anchors = _certList(opts.trustAnchors);
       var pool = _certList(opts.intermediates);
       var room = constants.LIMITS.PATH_BUILD_MAX_CANDIDATES - pool.length;
       if (room > 0) {
-        var seen = /* @__PURE__ */ Object.create(null);
+        var seen = _create(null);
         var sk = _certKey(signer.parsed);
         if (sk) seen[sk] = 1;
-        pool.forEach(function(c) {
-          var k = _certKey(c);
-          if (k) seen[k] = 1;
-        });
-        var useful = extra.filter(function(c) {
-          var k = _certKey(c);
-          return k == null || !seen[k];
-        });
-        pool = pool.concat(useful.slice(0, room));
+        var pi, pk;
+        for (pi = 0; pi < pool.length; pi++) {
+          pk = _certKey(pool[pi]);
+          if (pk) seen[pk] = 1;
+        }
+        var merged = [];
+        for (pi = 0; pi < pool.length; pi++) _append(merged, pool[pi]);
+        for (pi = 0; pi < extra.length && merged.length - pool.length < room; pi++) {
+          pk = _certKey(extra[pi]);
+          if (pk == null || !seen[pk]) _append(merged, extra[pi]);
+        }
+        pool = merged;
       }
       var buildOpts = { trustAnchors: anchors, intermediates: pool, validate: true, time };
       if (opts.revocationChecker != null) buildOpts.revocationChecker = opts.revocationChecker;
       try {
         var res = await _engine.build(signer.der, buildOpts);
         if (!res || res.valid !== true) return { trusted: false, reason: "the signer certificate did not chain to a supplied trust anchor" };
-        var byKey = /* @__PURE__ */ Object.create(null);
+        var byKey = _create(null);
         var skey = _certKey(signer.parsed);
         if (skey) byKey[skey] = signer.der;
-        pool.forEach(function(c) {
-          if (Buffer.isBuffer(c) || c instanceof Uint8Array) {
-            var k = _certKey(c);
-            if (k && !byKey[k]) byKey[k] = c;
-          }
-        });
-        var chain = res.path.map(function(pc) {
-          var k = _certKey(pc);
-          var d = k ? byKey[k] : null;
-          return d ? Buffer.from(d) : null;
-        }).filter(Boolean);
+        var ci, ck;
+        for (ci = 0; ci < pool.length; ci++) {
+          var pc = pool[ci];
+          if (!_isBuffer(pc) && !util.types.isUint8Array(pc)) continue;
+          ck = _certKey(pc);
+          if (ck && !byKey[ck]) byKey[ck] = pc;
+        }
+        var chain = [];
+        for (ci = 0; ci < res.path.length; ci++) {
+          ck = _certKey(res.path[ci]);
+          var d = ck ? byKey[ck] : null;
+          if (d) _append(chain, _bufferFrom(d));
+        }
         return { trusted: true, reason: null, chain };
       } catch (e) {
         if (e && e.code === "path/bad-input") {
@@ -19205,12 +20259,12 @@ var require_cmp_verify = __commonJS({
     var MAX_EXTRA_CERTS = 32;
     var MAX_EXTRA_SCAN = 256;
     function _boundExtraCerts(extra) {
-      if (!Array.isArray(extra) || !extra.length) return [];
-      var out = [], seen = /* @__PURE__ */ Object.create(null);
+      if (!_isArray(extra) || !extra.length) return [];
+      var out = [], seen = _create(null);
       for (var i = 0; i < extra.length && out.length < MAX_EXTRA_CERTS && i < MAX_EXTRA_SCAN; i++) {
         var c = extra[i];
-        if (!Buffer.isBuffer(c) && !(c instanceof Uint8Array)) continue;
-        var key = Buffer.from(c).toString("base64");
+        if (!_isBuffer(c) && !util.types.isUint8Array(c)) continue;
+        var key = _toString(_bufferFrom(c), "base64");
         if (seen[key]) continue;
         seen[key] = true;
         try {
@@ -19218,33 +20272,105 @@ var require_cmp_verify = __commonJS({
         } catch (_e) {
           continue;
         }
-        out.push(c);
+        _append(out, c);
       }
       return out;
     }
+    var _defineOwn = Object.defineProperty;
+    var _Date = Date;
+    function _append(arr, v) {
+      _defineOwn(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true });
+    }
     function _certList(v) {
       if (v == null) return [];
-      var arr = Array.isArray(v) ? v : [v];
-      return arr.map(function(c) {
-        return Buffer.isBuffer(c) || c instanceof Uint8Array || typeof c === "string" ? _certDer(c, "a trust anchor / intermediate") : c;
-      });
+      var arr = _isArray(v) ? v : [v];
+      var out = [];
+      for (var i = 0, n = arr.length; i < n; i++) {
+        var c = arr[i];
+        _append(out, _isBuffer(c) || util.types.isUint8Array(c) || typeof c === "string" ? _certDer(c, "a trust anchor / intermediate") : c);
+      }
+      return out;
     }
     function _nonEmptySecret(s) {
-      if (typeof s === "string") return s.length > 0;
-      return (Buffer.isBuffer(s) || s instanceof Uint8Array) && s.length > 0;
+      if (typeof s === "string") return _sizeOf(s) > 0;
+      if (!_isBuffer(s) && !util.types.isUint8Array(s)) return false;
+      return _sizeOf(s) > 0;
     }
     function verify(message, opts) {
-      return guard.async.deferred(function() {
-        return _verify(message, opts);
+      var made = [];
+      return guard.async.deferred(async function() {
+        try {
+          return await _verify(message, _fixVerifyOptions(opts, made));
+        } finally {
+          guard.secret.zeroizeAll(made, CmpError, "cmp/bad-input", "the copied PBMAC1 shared secret");
+        }
       });
     }
-    async function _verify(message, opts) {
+    function _fixByteish(v, label) {
+      if (!util.types.isUint8Array(v)) return v;
+      return guard.bytes.snapshot(v, CmpError, "cmp/bad-input", "opts." + label);
+    }
+    function _assertEchoBytes(v, name) {
+      if (v == null) return;
+      if (util.types.isUint8Array(v)) return;
+      throw _err("cmp/bad-input", "opts." + name + " must be a Buffer / Uint8Array");
+    }
+    function _fixSecret(v, made) {
+      if (typeof v === "string") {
+        var fromString = _bufferFrom(v, "utf8");
+        _append(made, fromString);
+        return fromString;
+      }
+      var copy = _fixByteish(v, "sharedSecret");
+      if (util.types.isUint8Array(copy)) _append(made, copy);
+      return copy;
+    }
+    function _fixCertList(v, label) {
+      if (v == null) return v;
+      if (!_isArray(v)) return _fixByteish(v, label);
+      var indices = guard.identifier.readableIndices(v, _err, "cmp/bad-input", "opts." + label);
+      guard.identifier.refuseAccessorFields(v, indices, _err, "cmp/bad-input", "opts." + label);
+      var n = v.length;
+      var names = _getOwnPropertyNames(v);
+      var own = 0, j, k, ix;
+      for (j = 0; j < names.length; j++) {
+        k = names[j];
+        ix = k >>> 0;
+        if (_String(ix) === k && ix !== 4294967295 && ix < n) own += 1;
+      }
+      if (own !== n) {
+        throw _err("cmp/bad-input", "a certificate list must be a dense array of certificates; this one holds " + own + " of its " + n + " positions as its own elements, so the rest are holes or come from its prototype");
+      }
+      var out = [];
+      for (var i = 0; i < n; i++) _append(out, _fixByteish(v[i], label + "[" + i + "]"));
+      return out;
+    }
+    function _fixTime(v) {
+      return guard.time.isDate(v) ? new _Date(guard.time.instantOf(v)) : v;
+    }
+    function _fixVerifyOptions(opts, made) {
       if (opts == null) opts = {};
-      if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("cmp/bad-input", "opts must be an object");
+      opts = guard.identifier.optionsObject(opts, _err, "cmp/bad-input", "pki.cmp.verify options");
       guard.identifier.assertKnownKeys(opts, KNOWN_VERIFY_OPTS, _err, "cmp/bad-input", "unknown opts field ");
-      ["transactionID", "expectRecipNonce"].forEach(function(k) {
-        if (opts[k] != null && !Buffer.isBuffer(opts[k]) && !(opts[k] instanceof Uint8Array)) throw _err("cmp/bad-input", "opts." + k + " must be a Buffer / Uint8Array");
-      });
+      var f = {
+        // Recorded in `made` the instant it is copied. Only the byte form: a string secret is a
+        // JavaScript string, immutable and interned wherever the caller created it, so there is nothing
+        // here to wipe -- a caller who needs the secret gone from memory passes it as bytes.
+        sharedSecret: _fixSecret(opts.sharedSecret, made),
+        signerCert: _fixByteish(opts.signerCert, "signerCert"),
+        trustAnchors: _fixCertList(opts.trustAnchors, "trustAnchors"),
+        intermediates: _fixCertList(opts.intermediates, "intermediates"),
+        time: _fixTime(opts.time),
+        transactionID: _fixByteish(opts.transactionID, "transactionID"),
+        expectRecipNonce: _fixByteish(opts.expectRecipNonce, "expectRecipNonce"),
+        revocationChecker: opts.revocationChecker,
+        maxIterations: opts.maxIterations
+      };
+      _assertEchoBytes(f.transactionID, "transactionID");
+      _assertEchoBytes(f.expectRecipNonce, "expectRecipNonce");
+      return f;
+    }
+    async function _verify(message, opts) {
       if (_engine == null) throw _err("cmp/bad-input", "the cmp-verify signature engine is not initialized (require pki before use)");
       var m = _coerce(message);
       var protectionAlg = m.header.protectionAlg;
@@ -19466,7 +20592,7 @@ var require_cms_sign = __commonJS({
       });
     }
     function _timeValue(when) {
-      var d = when instanceof Date ? when : /* @__PURE__ */ new Date();
+      var d = guard.time.isDate(when) ? when : /* @__PURE__ */ new Date();
       return d.getUTCFullYear() < 2050 ? b.utcTime(d) : b.generalizedTime(d);
     }
     function _keyOnlyCertStandIn(spkiDer) {
@@ -19537,8 +20663,7 @@ var require_cms_sign = __commonJS({
       ], _sign);
     }
     function _sign(content, signers, opts) {
-      opts = opts || {};
-      if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("cms/bad-input", "pki.cms.sign options must be an object");
+      opts = guard.identifier.optionsObject(opts, _err, "cms/bad-input", "pki.cms.sign options");
       guard.identifier.assertKnownKeys(opts, KNOWN_SIGN_OPTS, _err, "cms/bad-input", "unknown opts field ");
       var contentBuf = _toBuf(content, "content");
       var list = Array.isArray(signers) ? signers : [signers];
@@ -19734,8 +20859,7 @@ var require_cms_sign = __commonJS({
       ], _countersign);
     }
     function _countersign(cmsInput, signers, opts) {
-      opts = opts || {};
-      if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("cms/bad-input", "pki.cms.countersign options must be an object");
+      opts = guard.identifier.optionsObject(opts, _err, "cms/bad-input", "pki.cms.countersign options");
       guard.identifier.assertKnownKeys(opts, KNOWN_COUNTERSIGN_OPTS, _err, "cms/bad-input", "unknown opts field ");
       var list = Array.isArray(signers) ? signers : [signers];
       if (!list.length) throw _err("cms/bad-input", "pki.cms.countersign requires at least one countersigner");
@@ -21476,8 +22600,7 @@ var require_cms_verify = __commonJS({
       });
     }
     function _verify(input, opts) {
-      opts = opts || {};
-      if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("cms/bad-input", "pki.cms.verify options must be an object");
+      opts = guard.identifier.optionsObject(opts, _err, "cms/bad-input", "pki.cms.verify options");
       guard.identifier.assertKnownKeys(opts, _VERIFY_OPTS, _err, "cms/bad-input", "pki.cms.verify has an unknown option ");
       var parsed = guard.parsed.acceptDerived(input, "cms", function(bytes) {
         return cms.parse(_snapshotIfBytes(bytes, "pki.cms.verify"));
@@ -21533,7 +22656,7 @@ var require_cms_verify = __commonJS({
         return _snapshotIfBytes(v, "opts.trustAnchors[]");
       }
       if (v === null || typeof v !== "object") return v;
-      if (v instanceof Date) return new Date(v.getTime());
+      if (guard.time.isDate(v)) return new Date(guard.time.instantOf(v));
       if (depth >= _ANCHOR_CLONE_DEPTH) {
         throw _err("cms/bad-input", "an opts.trustAnchors entry nests deeper than " + _ANCHOR_CLONE_DEPTH + " levels, so it cannot be copied before the chain is walked; pass the anchor as certificate DER or a { name, publicKey, algorithm } tuple");
       }
@@ -21557,7 +22680,7 @@ var require_cms_verify = __commonJS({
       }
       return {
         trustAnchors: anchors,
-        time: opts.time instanceof Date ? new Date(opts.time.getTime()) : opts.time,
+        time: guard.time.isDate(opts.time) ? new Date(guard.time.instantOf(opts.time)) : opts.time,
         requiredEku: Array.isArray(opts.requiredEku) ? opts.requiredEku.slice() : opts.requiredEku,
         checkPurpose: opts.checkPurpose
       };
@@ -22527,6 +23650,9 @@ var require_path_validate = __commonJS({
     var ocsp = require_schema_ocsp();
     var ocspVerify = require_ocsp_verify();
     var crlVerify = require_crl_verify();
+    var csrVerify = require_csr_verify();
+    var crmfVerify = require_crmf_verify();
+    var attrcertVerify = require_attrcert_verify();
     var cmpVerify = require_cmp_verify();
     var cmsVerify = require_cms_verify();
     var cmpSession = require_cmp_session();
@@ -23326,8 +24452,34 @@ var require_path_validate = __commonJS({
       }
       return null;
     }
+    var _VALIDATE_OPTS = {
+      checkPurpose: 1,
+      historicalMode: 1,
+      initialAnyPolicyInhibit: 1,
+      initialExcludedSubtrees: 1,
+      initialExplicitPolicy: 1,
+      initialPermittedSubtrees: 1,
+      initialPolicyMappingInhibit: 1,
+      maxPathCerts: 1,
+      maxPolicyNodes: 1,
+      requireRevocation: 1,
+      requiredEku: 1,
+      revocationChecker: 1,
+      softFail: 1,
+      time: 1,
+      trustAnchor: 1,
+      userInitialPolicySet: 1,
+      verifier: 1
+    };
     async function validate(path, opts) {
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, E, "path/bad-input", "validate: opts");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _VALIDATE_OPTS,
+        E,
+        "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");
       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 + ")");
@@ -23401,12 +24553,12 @@ var require_path_validate = __commonJS({
           checks.push({ name: "kemKeyUsage", ok: kku.ok, code: kku.ok ? void 0 : kku.code });
           if (!kku.ok) failed = true;
         }
-        var t = opts.time;
+        var t = guard.time.instantOf(opts.time);
         var vOk = true, vCode;
-        if (t < cert.validity.notBefore) {
+        if (t < guard.time.instantOf(cert.validity.notBefore)) {
           vOk = false;
           vCode = "path/not-yet-valid";
-        } else if (t > cert.validity.notAfter) {
+        } else if (t > guard.time.instantOf(cert.validity.notAfter)) {
           vOk = false;
           vCode = "path/expired";
         }
@@ -23528,7 +24680,7 @@ var require_path_validate = __commonJS({
           var distrustDate = assertAnchorConstraints(ta, checkPurpose);
           if (distrustDate != null) {
             anchorDistrustApplied = true;
-            if (cert.validity.notBefore > distrustDate) {
+            if (guard.time.instantOf(cert.validity.notBefore) > guard.time.instantOf(distrustDate)) {
               checks.push({ name: "distrustAfter", ok: false, code: "path/distrusted-after" });
               failed = true;
             }
@@ -23789,7 +24941,7 @@ var require_path_validate = __commonJS({
           best = c;
           continue;
         }
-        var t = c.crl.thisUpdate.getTime(), bt = best.crl.thisUpdate.getTime();
+        var t = guard.time.instantOf(c.crl.thisUpdate), bt = guard.time.instantOf(best.crl.thisUpdate);
         if (t > bt) {
           best = c;
           continue;
@@ -23903,8 +25055,8 @@ var require_path_validate = __commonJS({
                 }
               }
             }
-            if (theCrl.thisUpdate > time) return null;
-            if (!theCrl.nextUpdate || theCrl.nextUpdate < time) return null;
+            if (guard.time.instantOf(theCrl.thisUpdate) > guard.time.instantOf(time)) return null;
+            if (!theCrl.nextUpdate || guard.time.instantOf(theCrl.nextUpdate) < guard.time.instantOf(time)) return null;
             var sigOk = await crlVerify.verifyCrlSignature(theCrl, issuer.workingPublicKey);
             if (!sigOk) return null;
             void sawIdp;
@@ -23914,7 +25066,7 @@ var require_path_validate = __commonJS({
             for (var r = 0; r < theCrl.revokedCertificates.length; r++) {
               var entry = theCrl.revokedCertificates[r];
               if (entry.serialNumberHex !== cert.serialNumberHex) continue;
-              if (historical && entry.revocationDate instanceof Date && entry.revocationDate.getTime() > time.getTime()) continue;
+              if (historical && guard.time.isDate(entry.revocationDate) && guard.time.instantOf(entry.revocationDate) > guard.time.instantOf(time)) continue;
               var rc = crlEntryReason(entry);
               return rc === null ? 0 : rc;
             }
@@ -24013,6 +25165,9 @@ var require_path_validate = __commonJS({
       });
     }
     crlVerify.setEngine(_verifyWithSpki);
+    csrVerify.setEngine(_verifyWithSpki);
+    crmfVerify.setEngine(_verifyWithSpki);
+    attrcertVerify.setEngine(_verifyWithSpki);
     var ocspCore = ocspVerify.makeOcspVerify({
       verifyWithSpki: _verifyWithSpki,
       decodeExt,
@@ -24105,7 +25260,7 @@ var require_path_validate = __commonJS({
     }
     function _verifyOcspParsed(parsedResponse, cert, issuerCert, time, opts) {
       opts = opts || {};
-      if (!(time instanceof Date) || isNaN(time.getTime())) {
+      if (!guard.time.isDate(time) || isNaN(guard.time.instantOf(time))) {
         return Promise.reject(E("path/bad-input", "verifyOcspResponse: time must be a valid Date (the currency + responder-validity check date)"));
       }
       function unbound(reason) {
@@ -24252,7 +25407,7 @@ var require_path_validate = __commonJS({
       var ku = softDecode(cand, OID.keyUsage);
       if (ku && ku.value && ku.value.keyCertSign === true) score += 10;
       var v = cand.validity;
-      if (v && v.notBefore instanceof Date && v.notAfter instanceof Date && v.notBefore.getTime() <= time.getTime() && time.getTime() <= v.notAfter.getTime()) score += 5;
+      if (v && guard.time.isDate(v.notBefore) && guard.time.isDate(v.notAfter) && guard.time.instantOf(v.notBefore) <= guard.time.instantOf(time) && guard.time.instantOf(time) <= guard.time.instantOf(v.notAfter)) score += 5;
       return score;
     }
     function _pushCandidates(frame, scored, stack, counter) {
@@ -24352,9 +25507,39 @@ var require_path_validate = __commonJS({
       }
       return out;
     }
+    var _BUILD_OPTS = (function() {
+      var o = {
+        aiaTimeout: 1,
+        candidates: 1,
+        fetchAia: 1,
+        intermediates: 1,
+        maxAiaFetches: 1,
+        maxAiaPerCert: 1,
+        maxCandidatesConsidered: 1,
+        maxDepth: 1,
+        maxPathCerts: 1,
+        maxResponseBytes: 1,
+        time: 1,
+        tls: 1,
+        transport: 1,
+        trustAnchors: 1,
+        validate: 1
+      };
+      Object.keys(_VALIDATE_OPTS).forEach(function(k) {
+        o[k] = 1;
+      });
+      delete o.trustAnchor;
+      return o;
+    })();
     async function build(leaf, opts) {
-      opts = opts || {};
-      if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw E("path/bad-input", "build: opts must be an object");
+      opts = guard.identifier.optionsObject(opts, E, "path/bad-input", "build: opts");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _BUILD_OPTS,
+        E,
+        "path/bad-input",
+        "pki.path.build has an unknown option. The anchors here are `trustAnchors`, plural; pki.path.validate takes `trustAnchor`. The unknown option was: "
+      );
       var leafCert;
       try {
         leafCert = coerceCert(leaf);
@@ -24429,12 +25614,13 @@ var require_path_validate = __commonJS({
         aiaTimeout: 1,
         maxResponseBytes: 1
       };
-      var forwarded = {};
-      Object.keys(opts).forEach(function(k) {
-        if (!BUILD_ONLY_OPT[k]) forwarded[k] = opts[k];
+      var forwarded = /* @__PURE__ */ Object.create(null);
+      Object.keys(_VALIDATE_OPTS).forEach(function(k) {
+        if (Object.prototype.hasOwnProperty.call(BUILD_ONLY_OPT, k)) return;
+        if (k in opts) forwarded[k] = opts[k];
       });
       function validateOpts(anchor) {
-        var vo = {};
+        var vo = /* @__PURE__ */ Object.create(null);
         Object.keys(forwarded).forEach(function(f) {
           vo[f] = forwarded[f];
         });
@@ -26351,10 +27537,8 @@ var require_cmc_verify = __commonJS({
       return input;
     }
     function _copyAnyBytes(v) {
-      if (Buffer.isBuffer(v) || v instanceof Uint8Array) return guard.bytes.snapshot(v, CmcError, "cmc/bad-input", "a byte field of the request");
-      if (ArrayBuffer.isView(v)) return Buffer.from(new Uint8Array(v.buffer, v.byteOffset, v.byteLength));
-      if (v instanceof ArrayBuffer) return Buffer.from(new Uint8Array(v));
-      return v;
+      if (!guard.bytes.isByteSource(v)) return v;
+      return guard.bytes.snapshotSource(v, CmcError, "cmc/bad-input", "a byte field of the request");
     }
     function _snapshotSent(sent) {
       var out = {}, k;
@@ -26616,7 +27800,7 @@ var require_tsp_sign = __commonJS({
       if (!NODE_DIGEST[certHashAlg]) throw _err("tsp/unsupported-algorithm", "unsupported certHashAlgorithm " + JSON.stringify(certHashAlg));
       var imprint = b.sequence([_hashAlgId(mi.hashAlgorithm), b.octetString(Buffer.from(mi.hashedMessage))]);
       if (opts.genTime != null) guard.time.assertValid(opts.genTime, _err, "tsp/bad-input", "genTime");
-      var genTime = opts.genTime instanceof Date ? opts.genTime : /* @__PURE__ */ new Date();
+      var genTime = guard.time.isDate(opts.genTime) ? opts.genTime : /* @__PURE__ */ new Date();
       var serial = guard.range.authoredInteger(opts.serialNumber, _err, "tsp/bad-input", "serialNumber");
       var fields = [b.integer(1n), _policy(opts.policy), imprint, b.integer(serial), b.generalizedTime(genTime)];
       if (opts.accuracy) fields.push(_accuracy(opts.accuracy));
@@ -26947,7 +28131,7 @@ var require_tsp_sign = __commonJS({
       if (opts.trustAnchor) {
         var pathRes = null;
         var floorT = tst.genTime;
-        var ceilT = tst.genTimeFraction != null && /[1-9]/.test(tst.genTimeFraction.slice(3)) ? new Date(floorT.getTime() + 1) : floorT;
+        var ceilT = tst.genTimeFraction != null && /[1-9]/.test(tst.genTimeFraction.slice(3)) ? new Date(guard.time.instantOf(floorT) + 1) : floorT;
         try {
           var pool = (parsed.certificates || []).filter(function(c) {
             return c.tagClass === "universal";
@@ -27120,8 +28304,23 @@ var require_ocsp = __commonJS({
         [opts, "pki.ocsp.buildRequest options"]
       ], _buildRequest);
     }
+    var _BUILD_REQUEST_OPTS = {
+      hashAlgorithm: 1,
+      nonce: 1,
+      pem: 1,
+      profile: 1,
+      requestorName: 1,
+      signer: 1
+    };
     function _buildRequest(query, opts) {
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, _err, "ocsp/bad-input", "pki.ocsp.buildRequest options");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _BUILD_REQUEST_OPTS,
+        _err,
+        "ocsp/bad-input",
+        "pki.ocsp.buildRequest has an unknown option (the anti-replay nonce is `nonce`): "
+      );
       var lightweight = opts.profile === "lightweight";
       var hashName = opts.hashAlgorithm || "sha1";
       if (lightweight && hashName !== "sha1") throw _err("ocsp/bad-input", "the lightweight profile requires a SHA-1 CertID (RFC 5019 sec. 2.1.1)");
@@ -27195,8 +28394,16 @@ var require_ocsp = __commonJS({
         [opts, "pki.ocsp.sign options"]
       ], _sign);
     }
+    var _SIGN_OPTS = { embedCert: 1, extendedRevoke: 1, nonce: 1, pem: 1 };
     function _sign(responseData, responder, opts) {
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, _err, "ocsp/bad-input", "pki.ocsp.sign options");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _SIGN_OPTS,
+        _err,
+        "ocsp/bad-input",
+        "pki.ocsp.sign has an unknown option (the nonce to echo back is `nonce`): "
+      );
       responseData = responseData || {};
       if (!responder || responder.cert == null || responder.key == null) throw _err("ocsp/bad-input", "a responder must be { cert, key }");
       var respCertDer = _normCertDer(responder.cert, "the responder certificate");
@@ -27254,8 +28461,8 @@ var require_ocsp = __commonJS({
     }
     function _asDate(d) {
       if (d == null) return null;
-      var dt = d instanceof Date ? d : new Date(d);
-      if (isNaN(dt.getTime())) throw _err("ocsp/bad-input", "an invalid date value " + JSON.stringify(d));
+      var dt = guard.time.isDate(d) ? d : new Date(d);
+      if (isNaN(guard.time.instantOf(dt))) throw _err("ocsp/bad-input", "an invalid date value " + JSON.stringify(d));
       return dt;
     }
     function _snapshotSignerKey(key, owned) {
@@ -27313,8 +28520,20 @@ var require_ocsp = __commonJS({
       if (code == null) throw _err("ocsp/bad-input", "an error responseStatus must be one of " + Object.keys(ERROR_STATUS).join(" / "));
       return b.sequence([b.enumerated(BigInt(code))]);
     }
+    var _VERIFY_OPTS = { cert: 1, historicalMode: 1, issuer: 1, requestNonce: 1, time: 1 };
     function verify(response, opts) {
-      opts = opts || {};
+      try {
+        opts = guard.identifier.optionsObject(opts, _err, "ocsp/bad-input", "pki.ocsp.verify options");
+        guard.identifier.assertKnownKeys(
+          opts,
+          _VERIFY_OPTS,
+          _err,
+          "ocsp/bad-input",
+          "pki.ocsp.verify has an unknown option (the request nonce to bind against is `requestNonce`): "
+        );
+      } catch (e) {
+        return Promise.reject(e);
+      }
       if (opts.cert == null || opts.issuer == null) return Promise.reject(_err("ocsp/bad-input", "verify requires opts.cert and opts.issuer"));
       var parsed, cert, issuerCert, time;
       try {
@@ -27592,7 +28811,7 @@ var require_x509_sign = __commonJS({
       var serialTlv = _serialInteger(spec.serialNumber);
       guard.time.assertValid(spec.notBefore, _err, "x509/bad-input", "notBefore");
       guard.time.assertValid(spec.notAfter, _err, "x509/bad-input", "notAfter");
-      if (spec.notBefore.getTime() > spec.notAfter.getTime()) throw _err("x509/bad-input", "notBefore must not be after notAfter (RFC 5280 sec. 4.1.2.5)");
+      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)) {
@@ -27649,6 +28868,8 @@ var require_csr_sign = __commonJS({
     var pkiBuild = require_pki_build();
     var frameworkError = require_framework_error();
     var guard = require_guard_all();
+    require_path_validate();
+    var csrVerify = require_csr_verify();
     var CsrError = frameworkError.CsrError;
     var KNOWN_SPEC_KEYS = { subject: 1, subjectPublicKey: 1, extensionRequest: 1, challengePassword: 1, attributes: 1 };
     var b = asn1.build;
@@ -27744,7 +28965,27 @@ var require_csr_sign = __commonJS({
         throw _err("csr/bad-input", "signing the certification request failed -- the signing key does not match the subject public key or is invalid", e);
       });
     }
-    module2.exports = { sign };
+    function _coerceCsr(request) {
+      return guard.parsed.acceptDerived(request, "csr", csr.parse, _err, "csr/bad-input", "the certification request");
+    }
+    function verify(request) {
+      return guard.async.deferred(function() {
+        return _verify(request);
+      });
+    }
+    function _verify(request) {
+      var parsed = _coerceCsr(request);
+      return Promise.resolve(csrVerify.verifyCsrSignature(parsed)).then(function(ok) {
+        return {
+          verified: ok === true,
+          subject: parsed.subject,
+          subjectPublicKeyInfo: parsed.subjectPublicKeyInfo,
+          attributes: parsed.attributes,
+          certificationRequestInfoBytes: parsed.certificationRequestInfoBytes
+        };
+      });
+    }
+    module2.exports = { sign, verify };
   }
 });
 
@@ -27759,6 +29000,9 @@ var require_attrcert_sign = __commonJS({
     var signScheme = require_sign_scheme();
     var guard = require_guard_all();
     var pkix = require_schema_pkix();
+    var schema = require_schema_engine();
+    require_path_validate();
+    var attrcertVerify = require_attrcert_verify();
     var pkiBuild = require_pki_build();
     var frameworkError = require_framework_error();
     var AttrCertError = frameworkError.AttrCertError;
@@ -27886,7 +29130,7 @@ var require_attrcert_sign = __commonJS({
     function _encodeValidity(notBefore, notAfter) {
       guard.time.assertValid(notBefore, _err, "attrcert/bad-input", "notBeforeTime");
       guard.time.assertValid(notAfter, _err, "attrcert/bad-input", "notAfterTime");
-      if (notBefore.getTime() > notAfter.getTime()) throw _err("attrcert/bad-input", "notBeforeTime must not be after notAfterTime (RFC 5755 sec. 4.2.6)");
+      if (guard.time.instantOf(notBefore) > guard.time.instantOf(notAfter)) throw _err("attrcert/bad-input", "notBeforeTime must not be after notAfterTime (RFC 5755 sec. 4.2.6)");
       return b.sequence([b.generalizedTime(notBefore), b.generalizedTime(notAfter)]);
     }
     function _encodeRole(role) {
@@ -28085,6 +29329,15 @@ var require_attrcert_sign = __commonJS({
       if (!attrs.length) throw _err("attrcert/bad-attributes", "attributes must carry at least one Attribute (RFC 5755 sec. 4.2.7)");
       return b.sequence(attrs);
     }
+    function _assertRevocationSchemesExclusive(seen) {
+      if (!Object.prototype.hasOwnProperty.call(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])) {
+          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)");
+        }
+      }
+    }
     function _buildExtensions(extSpec, aaSpki) {
       if (extSpec == null) return null;
       if (Array.isArray(extSpec)) {
@@ -28111,6 +29364,7 @@ var require_attrcert_sign = __commonJS({
           }
           return b.raw(der);
         });
+        _assertRevocationSchemesExclusive(seenA);
         return b.sequence(exts);
       }
       if (typeof extSpec !== "object") throw _err("attrcert/bad-input", "extensions must be an object or an array of pre-encoded Extension DER");
@@ -28125,6 +29379,7 @@ var require_attrcert_sign = __commonJS({
         seen[eOid] = true;
         out.push(_b.ext(eOid, meta.critical, _extensionValue(k, extSpec[k], aaSpki)));
       });
+      _assertRevocationSchemesExclusive(seen);
       if (!out.length) return null;
       return b.sequence(out);
     }
@@ -28180,7 +29435,284 @@ var require_attrcert_sign = __commonJS({
         throw _err("attrcert/bad-input", "signing the attribute certificate failed -- the signing key does not match the resolved algorithm or is invalid", e);
       });
     }
-    module2.exports = { sign };
+    var KNOWN_VERIFY_OPTS = { time: 1, target: 1, revocationStatus: 1 };
+    var REVOCATION_STATUS = /* @__PURE__ */ Object.create(null);
+    REVOCATION_STATUS.notRevoked = 1;
+    REVOCATION_STATUS.revoked = 1;
+    var _NAME_SCHEMA = pkix.name(NS);
+    function _readName(der, what) {
+      try {
+        return schema.walk(_NAME_SCHEMA, asn1.decode(der), NS).result;
+      } catch (e) {
+        if (e instanceof AttrCertError) throw e;
+        throw _err("attrcert/bad-input", what + " is not a readable distinguished name", e);
+      }
+    }
+    function _acIssuerName(parsed) {
+      var node = asn1.decode(parsed.issuer.v2Form.issuerName.names[0].bytes);
+      if (!node.children || node.children.length !== 1) {
+        throw _err("attrcert/bad-issuer-name", "the AC issuerName directoryName does not wrap exactly one Name");
+      }
+      return _readName(node.children[0].bytes, "the AC issuer name");
+    }
+    function _coerceAc(input) {
+      return guard.parsed.acceptDerived(
+        input,
+        "attributeCertificate",
+        attrcert.parse,
+        _err,
+        "attrcert/bad-input",
+        "the attribute certificate"
+      );
+    }
+    function _resolveIssuer(issuer) {
+      if (issuer == null || typeof issuer !== "object" || Buffer.isBuffer(issuer)) {
+        throw _err("attrcert/bad-input", "an issuer { name, publicKey } is required -- RFC 5755 sec. 5 item 4 makes trusting an AC issuer the verifier's own configuration");
+      }
+      guard.identifier.assertKnownKeys(
+        issuer,
+        { name: 1, publicKey: 1 },
+        _err,
+        "attrcert/bad-input",
+        "the issuer has an unknown key "
+      );
+      if (issuer.publicKey == null) throw _err("attrcert/bad-input", "issuer.publicKey (the AC issuer's SubjectPublicKeyInfo DER) is required");
+      if (issuer.name == null) {
+        throw _err("attrcert/bad-input", "issuer.name (the distinguished name this verifier trusts as an AC issuer) is required");
+      }
+      var trustedDer;
+      try {
+        trustedDer = _b.encodeName(issuer.name);
+      } catch (e) {
+        if (e instanceof AttrCertError) throw e;
+        throw _err("attrcert/bad-input", "issuer.name is not a distinguished name", e);
+      }
+      var rdns = _readName(trustedDer, "issuer.name").rdns;
+      if (!rdns.length) {
+        throw _err("attrcert/bad-input", "issuer.name is an empty distinguished name, which names no AC issuer (RFC 5755 sec. 4.2.3)");
+      }
+      return {
+        rdns,
+        // Copied, never viewed. Signature verification suspends this call, and the signature engine
+        // holds this buffer across that suspension -- a composite arm keeps slices of it and imports
+        // them only after its digest settles. A view would leave the trust key writable for that whole
+        // window, so a caller could hand in an unrelated key of the same length, overwrite it with the
+        // real issuer's while the digest ran, and be told the certificate verified under the key they
+        // named. The verdict answers for the key the call was made with.
+        spki: guard.bytes.snapshot(issuer.publicKey, AttrCertError, "attrcert/bad-input", "issuer.publicKey")
+      };
+    }
+    function _callerTarget(target) {
+      return attrcert.readGeneralName(_b.encodeGeneralName(target), "attrcert/bad-input");
+    }
+    function _mailboxEqual(a, bx) {
+      var i = a.lastIndexOf("@"), j = bx.lastIndexOf("@");
+      if (i < 0 || j < 0) return a === bx;
+      return a.slice(0, i) === bx.slice(0, j) && a.slice(i + 1).toLowerCase() === bx.slice(j + 1).toLowerCase();
+    }
+    function _generalNameMatches(entry, want) {
+      if (!entry || entry.tagNumber !== want.tagNumber) return false;
+      switch (entry.tagNumber) {
+        // RFC 5280 sec. 7.2: "When comparing DNS names for equality, conforming implementations MUST
+        // perform a case-insensitive exact match on the entire DNS name."
+        case 2:
+          return String(entry.value).toLowerCase() === String(want.value).toLowerCase();
+        // sec. 7.5, as above.
+        case 1:
+          return _mailboxEqual(String(entry.value), String(want.value));
+        // A directoryName is a distinguished name, and sec. 7.1 identity is not string equality, so it
+        // goes through the one DN comparator rather than comparing the printed form.
+        case 4:
+          return !!(entry.value && want.value) && guard.name.dnEqual(entry.value.rdns, want.value.rdns, _err, "attrcert/bad-input", "the target name");
+        // sec. 7.4 makes a URI comparison a full RFC 3987 normalization: percent-encoding, path
+        // segments and scheme-based rules, not merely lowercasing the scheme and host. A partial
+        // normalization would be a guess that could match a URI it should not, so the encoded value is
+        // compared as it stands. Re-open condition: an RFC 3987 normalizer in the toolkit.
+        default:
+          if (Buffer.isBuffer(entry.value) && Buffer.isBuffer(want.value)) return entry.value.equals(want.value);
+          if (typeof entry.value === "string" && typeof want.value === "string") return entry.value === want.value;
+          return null;
+      }
+    }
+    function _checkTargeting(ac, want) {
+      var ext = null;
+      for (var i = 0; i < ac.extensions.length; i++) {
+        if (ac.extensions[i].name === "targetInformation") ext = ac.extensions[i];
+      }
+      if (!ext) return { checked: true, ok: true };
+      if (want === void 0) {
+        return {
+          checked: false,
+          ok: false,
+          reason: "this attribute certificate is targeted, and no opts.target names this verifier (RFC 5755 sec. 4.3.2)"
+        };
+      }
+      var groups = ext.decoded || [];
+      for (var g0 = 0; g0 < groups.length; g0++) {
+        for (var t0 = 0; t0 < groups[g0].length; t0++) {
+          if (groups[g0][t0].kind !== "targetCert") continue;
+          return {
+            checked: false,
+            ok: false,
+            reason: "this attribute certificate carries a targetCert target, which RFC 5755 sec. 4.3.2 says MUST NOT be used, so the targeting check did not run"
+          };
+        }
+      }
+      var uncomparable = null;
+      for (var g = 0; g < groups.length; g++) {
+        for (var t = 0; t < groups[g].length; t++) {
+          var entry = groups[g][t];
+          if (entry.kind !== "targetName" && entry.kind !== "targetGroup") continue;
+          var m = _generalNameMatches(entry.name, want);
+          if (m === true) return { checked: true, ok: true };
+          if (m === null) uncomparable = entry.name && entry.name.tagNumber;
+        }
+      }
+      if (uncomparable !== null) {
+        return {
+          checked: false,
+          ok: false,
+          reason: "this attribute certificate names a target in a GeneralName form ([" + uncomparable + "]) this verifier does not compare, so the RFC 5755 sec. 4.3.2 check did not run"
+        };
+      }
+      return {
+        checked: true,
+        ok: false,
+        reason: "this attribute certificate does not name this verifier among its targets (RFC 5755 sec. 4.3.2)"
+      };
+    }
+    var SUPPORTED_CRITICAL = {};
+    SUPPORTED_CRITICAL[O("targetInformation")] = 1;
+    SUPPORTED_CRITICAL[O("acAuditIdentity")] = 1;
+    function _unsupportedCritical(ac) {
+      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 (e.decoded === null || e.decoded === void 0 || e.decoded.opaque === true) return e.oid;
+      }
+      return null;
+    }
+    function verify(ac, issuer, opts) {
+      return guard.async.deferred(function() {
+        return _verify(ac, issuer, opts);
+      });
+    }
+    function _fixVerifyOptions(opts) {
+      var o = guard.identifier.optionsObject(opts, _err, "attrcert/bad-input", "pki.attrcert.verify options");
+      guard.identifier.assertKnownKeys(
+        o,
+        KNOWN_VERIFY_OPTS,
+        _err,
+        "attrcert/bad-input",
+        "pki.attrcert.verify has an unknown option "
+      );
+      var at = null;
+      if (o.time !== void 0) {
+        guard.time.assertValid(o.time, _err, "attrcert/bad-input", "pki.attrcert.verify opts.time");
+        at = guard.time.instantOf(o.time);
+      }
+      var revocationStatus = null;
+      if (o.revocationStatus !== void 0) {
+        if (typeof o.revocationStatus !== "string" || !Object.prototype.hasOwnProperty.call(REVOCATION_STATUS, o.revocationStatus)) {
+          throw _err("attrcert/bad-input", 'pki.attrcert.verify opts.revocationStatus must be "notRevoked" or "revoked"');
+        }
+        revocationStatus = o.revocationStatus;
+      }
+      return {
+        at,
+        revocationStatus,
+        target: o.target === void 0 ? void 0 : _callerTarget(o.target)
+      };
+    }
+    var REVOCATION_POINTERS = /* @__PURE__ */ Object.create(null);
+    REVOCATION_POINTERS[O("cRLDistributionPoints")] = "crlDistributionPoints";
+    REVOCATION_POINTERS[O("authorityInfoAccess")] = "authorityInfoAccess";
+    function _revocationScheme(ac) {
+      var out = { noRevAvail: false, pointer: null };
+      for (var i = 0; i < ac.extensions.length; i++) {
+        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;
+      }
+      return out;
+    }
+    function _verify(ac, issuer, opts) {
+      var fixed = _fixVerifyOptions(opts);
+      var parsed = _coerceAc(ac);
+      var trust = _resolveIssuer(issuer);
+      var acIssuer = _acIssuerName(parsed);
+      var result = {
+        holder: parsed.holder,
+        issuer: acIssuer,
+        attributes: parsed.attributes,
+        // Carried so a caller can act on what rode along: sec. 4.3.1 asks that an audit identity be
+        // used for audit and logging, which it cannot be if the verdict drops it.
+        extensions: parsed.extensions,
+        notBefore: parsed.validity.notBeforeTime,
+        notAfter: parsed.validity.notAfterTime,
+        serialNumberHex: parsed.serialNumberHex,
+        signatureValid: false,
+        validityChecked: false,
+        targetingChecked: false,
+        revocationChecked: false,
+        noRevAvail: false,
+        holderBindingChecked: false,
+        // item 1 needs the holder's certificate, which this verb is not given
+        issuerPathChecked: false,
+        // items 2 and 3 need the issuer's chain, likewise
+        verified: false,
+        reason: void 0
+      };
+      return Promise.resolve(attrcertVerify.verifyAcSignature(parsed, trust.spki)).then(function(sigOk) {
+        result.signatureValid = sigOk === true;
+        var fail = function(reason) {
+          result.reason = reason;
+          return result;
+        };
+        if (!result.signatureValid) return fail("the signature does not verify under the issuer public key");
+        if (!guard.name.dnEqual(
+          acIssuer.rdns,
+          trust.rdns,
+          _err,
+          "attrcert/bad-input",
+          "the AC issuer"
+        )) {
+          return fail("this attribute certificate names issuer " + JSON.stringify(acIssuer.dn) + ", which is not the AC issuer this verifier trusts");
+        }
+        var badExt = _unsupportedCritical(parsed);
+        if (badExt) return fail("this attribute certificate carries an unsupported critical extension (" + badExt + "), which RFC 5755 sec. 5 item 7 requires be rejected");
+        var targeting = _checkTargeting(parsed, fixed.target);
+        result.targetingChecked = targeting.checked;
+        if (!targeting.ok) return fail(targeting.reason);
+        if (fixed.at === null) {
+          return fail("no opts.time was supplied, so RFC 5755 sec. 5 item 5 (the evaluation instant lies within the validity) went unasked");
+        }
+        result.validityChecked = true;
+        if (fixed.at < guard.time.instantOf(result.notBefore) || fixed.at > guard.time.instantOf(result.notAfter)) {
+          return fail("the evaluation instant lies outside this attribute certificate's validity");
+        }
+        var scheme = _revocationScheme(parsed);
+        result.noRevAvail = scheme.noRevAvail;
+        if (scheme.noRevAvail && scheme.pointer) {
+          return fail("this attribute certificate carries both noRevAvail and a " + scheme.pointer + " revocation pointer, which RFC 5755 sec. 6 says an AC MUST NOT do");
+        }
+        if (fixed.revocationStatus !== null) {
+          result.revocationChecked = true;
+          if (fixed.revocationStatus === "revoked") {
+            return fail("this attribute certificate is revoked, as opts.revocationStatus reports");
+          }
+        } else if (result.noRevAvail) {
+          result.revocationChecked = true;
+        } else {
+          return fail("this attribute certificate carries no noRevAvail extension, so its issuer supports revocation status checks and RFC 5755 sec. 6 requires one; establish the status from the certificate's own pointers and pass it as opts.revocationStatus");
+        }
+        result.verified = true;
+        return result;
+      });
+    }
+    module2.exports = { sign, verify };
   }
 });
 
@@ -28550,7 +30082,7 @@ var require_crl_sign = __commonJS({
       var nextU = null;
       if (spec.nextUpdate != null) {
         nextU = _timeDer(spec.nextUpdate, "nextUpdate");
-        if (spec.nextUpdate.getTime() < spec.thisUpdate.getTime()) throw _err("crl/bad-input", "nextUpdate must not be before thisUpdate (RFC 5280 sec. 5.1.2.5)");
+        if (guard.time.instantOf(spec.nextUpdate) < guard.time.instantOf(spec.thisUpdate)) throw _err("crl/bad-input", "nextUpdate must not be before thisUpdate (RFC 5280 sec. 5.1.2.5)");
       }
       var extResult = _buildCrlExtensions(spec, { issuerCert, issuerSpki });
       var crlExts = extResult.exts;
@@ -28642,9 +30174,33 @@ var require_crl_sign = __commonJS({
       if (v <= 0n) throw _err("crl/bad-input", "serialNumber must be a positive integer");
       return asn1.decode(b.integer(v)).content.toString("hex");
     }
-    function isRevoked(crl, serialNumber) {
+    var KNOWN_IS_REVOKED_KEYS = { time: 1, historicalMode: 1 };
+    function isRevoked(crl, serialNumber, opts) {
+      var o = guard.identifier.optionsObject(opts, _err, "crl/bad-input", "pki.crl.isRevoked options");
+      guard.identifier.assertKnownKeys(o, KNOWN_IS_REVOKED_KEYS, _err, "crl/bad-input", function(k) {
+        return "pki.crl.isRevoked has an unknown option " + JSON.stringify(k) + "; it takes `time` and `historicalMode`";
+      });
+      if (o.historicalMode !== void 0 && o.time === void 0) {
+        throw _err("crl/bad-input", "pki.crl.isRevoked opts.historicalMode says how to read an entry against the instant asked about, so it needs opts.time as well");
+      }
+      if (o.historicalMode !== void 0 && typeof o.historicalMode !== "boolean") {
+        throw _err("crl/bad-input", "pki.crl.isRevoked opts.historicalMode must be a boolean");
+      }
       var parsed = _coerceCrl(crl);
       var hex = _serialHexOf(serialNumber);
+      if (o.time !== void 0) {
+        guard.time.assertValid(o.time, _err, "crl/bad-input", "pki.crl.isRevoked opts.time");
+        var at = guard.time.instantOf(o.time);
+        if (at < guard.time.instantOf(parsed.thisUpdate)) {
+          throw _err("crl/not-current", "this CRL takes effect at " + parsed.thisUpdate.toISOString() + ", after the time asked about, so it says nothing about the certificate then");
+        }
+        if (!parsed.nextUpdate) {
+          throw _err("crl/not-current", "this CRL carries no nextUpdate, so it states no window it speaks for and a replayed copy cannot be told from a current one (RFC 5280 sec. 5.1.2.5 requires one of a conforming CA); ask pki.path.crlChecker, which decides currency against the material it fetched");
+        }
+        if (at > guard.time.instantOf(parsed.nextUpdate)) {
+          throw _err("crl/not-current", "this CRL was superseded after " + parsed.nextUpdate.toISOString() + "; a serial missing from it says nothing about the certificate at the time asked about, since the issuer promised a further list by then");
+        }
+      }
       if (_findExtOid(parsed.crlExtensions, "deltaCRLIndicator")) {
         throw _err("crl/delta-not-authoritative", "this is a delta CRL: it lists changes since a base CRL, so a serial appearing in it may be RELEASED rather than revoked. Merge it with its base -- pki.path.crlChecker does -- rather than reading a revocation status out of the delta alone");
       }
@@ -28656,7 +30212,9 @@ var require_crl_sign = __commonJS({
         }
       }
       for (var j = 0; j < parsed.revokedCertificates.length; j++) {
-        if (parsed.revokedCertificates[j].serialNumberHex === hex) return parsed.revokedCertificates[j];
+        if (parsed.revokedCertificates[j].serialNumberHex !== hex) continue;
+        if (o.historicalMode === true && guard.time.instantOf(parsed.revokedCertificates[j].revocationDate) > guard.time.instantOf(o.time)) continue;
+        return parsed.revokedCertificates[j];
       }
       return null;
     }
@@ -28751,8 +30309,16 @@ var require_key = __commonJS({
       }
       return pkix.coerceToDer(input, { pemLabel: "PRIVATE KEY", PemError, ErrorClass: KeyError, prefix: "key" });
     }
+    var _ENCRYPT_OPTS = { cipher: 1, iterations: 1, pem: 1, prf: 1, salt: 1 };
     async function encrypt(privateKey, password, opts) {
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.encrypt options");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _ENCRYPT_OPTS,
+        _err,
+        "key/bad-input",
+        "pki.key.encrypt has an unknown option (the PBKDF2 count here is `iterations`; `maxIterations` is the decrypt-side cap): "
+      );
       var der = await _toPrivateKeyDer(privateKey);
       try {
         pkcs8.parse(der);
@@ -28783,8 +30349,16 @@ var require_key = __commonJS({
         guard.secret.zeroize(dk, KeyError, "key/bad-input", "the password-derived encryption key");
       }
     }
+    var _DECRYPT_OPTS = { maxIterations: 1, pem: 1 };
     async function decrypt(encrypted, password, opts) {
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.decrypt options");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _DECRYPT_OPTS,
+        _err,
+        "key/bad-input",
+        "pki.key.decrypt has an unknown option (the PBKDF2 cap here is `maxIterations`; `iterations` is the encrypt-side count): "
+      );
       if (opts.maxIterations != null && (typeof opts.maxIterations !== "number" || !isFinite(opts.maxIterations) || opts.maxIterations < 1 || Math.floor(opts.maxIterations) !== opts.maxIterations)) {
         throw _err("key/bad-input", "maxIterations must be a positive integer");
       }
@@ -28815,8 +30389,16 @@ var require_key = __commonJS({
       }
       return plaintext;
     }
+    var _EXPORT_OPTS = { format: 1, label: 1 };
     async function export_(key, opts) {
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.export options");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _EXPORT_OPTS,
+        _err,
+        "key/bad-input",
+        "pki.key.export has an unknown option. It serializes only. To protect a private key, call pki.key.encrypt(key, password) first and export its result. The unknown option was: "
+      );
       if (!_isCryptoKey(key)) throw _err("key/bad-input", "export expects a WebCrypto CryptoKey");
       var defaultLabel;
       if (key.type === "private") defaultLabel = "PRIVATE KEY";
@@ -28828,8 +30410,16 @@ var require_key = __commonJS({
       if (fmt === "pem") return pkix.pemEncode(der, opts.label || defaultLabel, PemError);
       throw _err("key/bad-input", "unsupported format " + JSON.stringify(opts.format) + " (der / pem)");
     }
+    var _IMPORT_OPTS = { algorithm: 1, extractable: 1, password: 1, usages: 1 };
     async function import_(input, opts) {
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.import options");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _IMPORT_OPTS,
+        _err,
+        "key/bad-input",
+        "pki.key.import has an unknown option: "
+      );
       var detected = _detectKeyInput(input);
       if (detected.format === "encrypted") {
         if (opts.password == null) throw _err("key/bad-input", "an ENCRYPTED PRIVATE KEY requires opts.password to import");
@@ -28846,8 +30436,16 @@ var require_key = __commonJS({
         throw _err("key/bad-input", "importKey failed", e);
       }
     }
+    var _GENERATE_OPTS = { extractable: 1, usages: 1 };
     async function generate(algorithm, opts) {
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.generate options");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _GENERATE_OPTS,
+        _err,
+        "key/bad-input",
+        "pki.key.generate has an unknown option (the WebCrypto spelling is `extractable`): "
+      );
       var extractable = opts.extractable != null ? opts.extractable : true;
       var usages = opts.usages || _generateUsages(_algName(algorithm));
       var pair;
@@ -28860,8 +30458,16 @@ var require_key = __commonJS({
       if (!pair || !pair.privateKey || !pair.publicKey) throw _err("key/bad-input", "the algorithm does not generate an asymmetric key pair");
       return { privateKey: pair.privateKey, publicKey: pair.publicKey };
     }
+    var _PUBLIC_FROM_PRIVATE_OPTS = { pem: 1 };
     async function publicFromPrivate(privateKey, opts) {
-      opts = opts || {};
+      opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.publicFromPrivate options");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _PUBLIC_FROM_PRIVATE_OPTS,
+        _err,
+        "key/bad-input",
+        "pki.key.publicFromPrivate has an unknown option: "
+      );
       var der = await _toPrivateKeyDer(privateKey);
       var spki;
       try {
@@ -30884,8 +32490,8 @@ var require_sigstore = __commonJS({
     function _toMs(x) {
       if (x == null) return null;
       if (typeof x === "number") return Number.isFinite(x) ? x : null;
-      if (x instanceof Date) {
-        var d = x.getTime();
+      if (guard.time.isDate(x)) {
+        var d = guard.time.instantOf(x);
         return isNaN(d) ? null : d;
       }
       if (typeof x === "string") {
@@ -31198,7 +32804,7 @@ var require_sigstore = __commonJS({
         }
       }
       if (integratedTime === null) throw lastErr;
-      var checkTime = opts.time instanceof Date ? opts.time.getTime() : C.TIME.seconds(integratedTime);
+      var checkTime = guard.time.isDate(opts.time) ? guard.time.instantOf(opts.time) : C.TIME.seconds(integratedTime);
       await _verifyChain(leaf, _chainDers(vm), fulcioRoots, checkTime);
       var identity = _identity(leaf);
       var identityChecked = _checkIdentity(identity, opts.identity);
@@ -31944,8 +33550,8 @@ var require_est = __commonJS({
       return asn1.build.sequence([asn1.build.oid(typeOid), asn1.build.set(valueNodes)]);
     }
     function challengePasswordFromTlsUnique(channelBinding) {
-      if (!Buffer.isBuffer(channelBinding) || channelBinding.length === 0) throw E("est/bad-input", "challengePasswordFromTlsUnique requires the channel-binding bytes");
-      var b64 = channelBinding.toString("base64");
+      if (!Buffer.isBuffer(channelBinding) || guard.bytes.lengthOf(channelBinding) === 0) throw E("est/bad-input", "challengePasswordFromTlsUnique requires the channel-binding bytes");
+      var b64 = guard.bytes.view(channelBinding, EstError, "est/bad-input", "the channel-binding bytes").toString("base64");
       if (b64.length > 255) throw E("est/tls-unique-too-long", "the base64 tls-unique value exceeds 255 octets (RFC 7030 sec. 3.5)");
       return _attr(OID_CHALLENGE_PASSWORD, [asn1.build.printable(b64)]);
     }
@@ -32125,7 +33731,7 @@ var require_est = __commonJS({
       function step() {
         return transport({ method, url: url.href, headers: _headersFor(url), body, tls: _tlsFor(url), timeout: budgets.timeout, maxResponseBytes: budgets.maxResponseBytes }).then(function(res) {
           res = res || {};
-          var blen = Buffer.isBuffer(res.body) ? res.body.length : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
+          var blen = Buffer.isBuffer(res.body) ? guard.bytes.lengthOf(res.body) : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
           if (blen > budgets.maxResponseBytes) throw E("est/response-too-large", "the response body (" + blen + " bytes) exceeds the " + budgets.maxResponseBytes + "-byte cap (RFC 7030 sec. 6)");
           var h = {
             location: _ciHeader(res.headers, "location"),
@@ -32221,7 +33827,7 @@ var require_est = __commonJS({
         return { retry: true, retryAfterSeconds: verdict.retryAfterSeconds, retryAfterDate: verdict.retryAfterDate };
       }
       if (verdict.status !== "ok") throw E("est/http-error", "an EST " + op + " response must be HTTP 200 or 202 (RFC 7030 sec. 4.1.3 / 4.2.3), got " + res.status);
-      var bodyLen = Buffer.isBuffer(res.body) ? res.body.length : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
+      var bodyLen = Buffer.isBuffer(res.body) ? guard.bytes.lengthOf(res.body) : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
       if (bodyLen === 0) throw E("est/empty-body", "a 200 " + op + " response carried an empty body (RFC 7030 sec. 4.1.3 / 4.2.3)");
       var parsed = parseCertsOnly(transferDecode(res.body));
       if (op === "cacerts") return { certificates: parsed.certificates, crls: parsed.crls };
@@ -32381,10 +33987,8 @@ var require_est = __commonJS({
       };
     }
     function _copyBytes(v) {
-      if (Buffer.isBuffer(v) || v instanceof Uint8Array) return guard.bytes.snapshot(v, EstError, "est/bad-input", "a byte field of the request");
-      if (ArrayBuffer.isView(v)) return Buffer.from(new Uint8Array(v.buffer, v.byteOffset, v.byteLength));
-      if (v instanceof ArrayBuffer) return Buffer.from(new Uint8Array(v));
-      return v;
+      if (!guard.bytes.isByteSource(v)) return v;
+      return guard.bytes.snapshotSource(v, EstError, "est/bad-input", "a byte field of the request");
     }
     function _requestBinding(der) {
       var out = {
@@ -32526,7 +34130,7 @@ var require_est = __commonJS({
           "an EST /fullcmc response must be HTTP 200 or 202 (RFC 7030 sec. 4.3.2), got " + res.status
         );
       }
-      var bodyLen = Buffer.isBuffer(res.body) ? res.body.length : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
+      var bodyLen = Buffer.isBuffer(res.body) ? guard.bytes.lengthOf(res.body) : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
       if (bodyLen === 0) throw E("est/empty-body", "a 200 /fullcmc response carried an empty body (RFC 7030 sec. 4.3.2)");
       var der = transferDecode(res.body);
       var pt200 = _partMediaType(_ciHeader(res.headers, "content-type"));
@@ -32694,7 +34298,7 @@ var require_est = __commonJS({
       var verdict = classifyResponse(res.status, res.headers, res.body, { op: "serverkeygen", now: opts.now });
       if (verdict.status === "retry") return { retry: true, retryAfterSeconds: verdict.retryAfterSeconds, retryAfterDate: verdict.retryAfterDate };
       if (verdict.status !== "ok") throw E("est/http-error", "an EST serverkeygen response must be HTTP 200 or 202 (RFC 7030 sec. 4.4.2), got " + res.status);
-      var bodyLen = Buffer.isBuffer(res.body) ? res.body.length : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
+      var bodyLen = Buffer.isBuffer(res.body) ? guard.bytes.lengthOf(res.body) : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
       if (bodyLen === 0) throw E("est/empty-body", "a 200 serverkeygen response carried an empty body (RFC 7030 sec. 4.4.2)");
       _assertConfidentialCipher(res);
       var out = parseServerKeygenResponse(res.body, _ciHeader(res.headers, "content-type"), {
@@ -32749,7 +34353,7 @@ var require_est = __commonJS({
       if (verdict.status === "none-available") return { available: false, attrs: null };
       if (verdict.status === "retry") throw E("est/http-error", "a /csrattrs response must be HTTP 200, 204, or 404, not 202 (RFC 7030 sec. 4.5.2)");
       if (verdict.status !== "ok") throw E("est/http-error", "an EST csrattrs response must be HTTP 200 / 204 / 404 (RFC 7030 sec. 4.5.2), got " + res.status);
-      var bodyLen = Buffer.isBuffer(res.body) ? res.body.length : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
+      var bodyLen = Buffer.isBuffer(res.body) ? guard.bytes.lengthOf(res.body) : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
       if (bodyLen === 0) throw E("est/empty-body", "a 200 csrattrs response carried an empty body (RFC 7030 sec. 4.5.2)");
       var attrs = csrattrsFmt.parse(transferDecode(res.body));
       return { available: true, attrs, plan: buildEnrollAttributes(attrs) };
@@ -34191,7 +35795,7 @@ var require_acme = __commonJS({
           Object.keys(res.headers || {}).forEach(function(k) {
             h[k.toLowerCase()] = res.headers[k];
           });
-          var blen = Buffer.isBuffer(res.body) ? res.body.length : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
+          var blen = Buffer.isBuffer(res.body) ? guard.bytes.lengthOf(res.body) : Buffer.byteLength(String(res.body == null ? "" : res.body), "utf8");
           if (blen > budgets.maxResponseBytes) throw E("acme/response-too-large", "the response body (" + blen + " bytes) exceeds the " + budgets.maxResponseBytes + "-byte cap");
           if ((method === "GET" || method === "HEAD") && res.status >= 300 && res.status < 400) {
             if (redirects >= budgets.maxRedirects) throw E("acme/too-many-redirects", "the redirect budget of " + budgets.maxRedirects + " was exceeded");
@@ -34517,7 +36121,7 @@ var require_acme = __commonJS({
           if (typeof t !== "number" || !isFinite(t)) throw E("acme/bad-input", "the renewalInfo clock returned a non-finite value");
           return t;
         }
-        var notAfterMs = x509.parse(certDer).validity.notAfter.getTime();
+        var notAfterMs = guard.time.instantOf(x509.parse(certDer).validity.notAfter);
         if (clk() > notAfterMs) throw E("acme/certificate-expired", "the certificate is already past its notAfter; a client MUST NOT check RenewalInfo after it has expired (RFC 9773 sec. 4.3)");
         var certId = ariCertId(certDer);
         return _resource("renewalInfo").then(function(base) {
@@ -34558,12 +36162,12 @@ var require_acme = __commonJS({
           }
           var notAfter = x509.parse(certDer).validity.notAfter;
           var now = clk();
-          if (now > notAfter.getTime()) throw E("acme/certificate-expired", "the certificate is already past its notAfter; there is nothing to renew (RFC 9773 sec. 4.3)");
+          if (now > guard.time.instantOf(notAfter)) throw E("acme/certificate-expired", "the certificate is already past its notAfter; there is nothing to renew (RFC 9773 sec. 4.3)");
           if (o.replaced === true) throw E("acme/certificate-replaced", "the caller asserts this certificate has already been replaced (RFC 9773 sec. 4.3)");
           return _renewalInfo(certDer, clk, RENEWAL_RETRY_MAX_SECONDS).then(function(ri) {
             var w = ri.renewalInfo.suggestedWindow;
             var startMs = Date.parse(w.start), endMs = Date.parse(w.end);
-            var notAfterMs = notAfter.getTime();
+            var notAfterMs = guard.time.instantOf(notAfter);
             var effEnd = Math.min(endMs, notAfterMs), effStart = Math.min(startMs, effEnd);
             var pw = o.previous && _isObject(o.previous.suggestedWindow) ? o.previous.suggestedWindow : null;
             var selectedMs;
@@ -34904,7 +36508,7 @@ var require_trust = __commonJS({
       var out = {};
       if (!src || typeof src !== "object") return out;
       Object.keys(src).forEach(function(k) {
-        out[k] = src[k] instanceof Date ? new Date(src[k].getTime()) : src[k];
+        out[k] = guard.time.isDate(src[k]) ? new Date(guard.time.instantOf(src[k])) : src[k];
       });
       return out;
     }
@@ -34923,7 +36527,7 @@ var require_trust = __commonJS({
       var kx = Object.keys(x).sort(), ky = Object.keys(y).sort();
       if (kx.join(",") !== ky.join(",")) return false;
       return kx.every(function(k) {
-        return x[k].getTime() === y[k].getTime();
+        return guard.time.instantOf(x[k]) === guard.time.instantOf(y[k]);
       });
     }
     function _purposesEqual(x, y) {
@@ -35276,8 +36880,9 @@ var require_inspect = __commonJS({
       return (n < 10 ? "0" : "") + n;
     }
     function _date(iso) {
-      var d = iso instanceof Date ? iso : new Date(iso);
-      if (isNaN(d.getTime())) return String(iso);
+      var held = guard.time.isDate(iso) ? guard.time.instantOf(iso) : Date.parse(String(iso));
+      if (isNaN(held)) return String(iso);
+      var d = new Date(held);
       var day = d.getUTCDate(), dd = (day < 10 ? " " : "") + day;
       return MONTHS[d.getUTCMonth()] + " " + dd + " " + _two(d.getUTCHours()) + ":" + _two(d.getUTCMinutes()) + ":" + _two(d.getUTCSeconds()) + " " + d.getUTCFullYear() + " GMT";
     }
@@ -35756,7 +37361,7 @@ var require_inspect = __commonJS({
       var inner = pad + "    ";
       if (ext.oid === OID_CRL_NUMBER && typeof ext.value === "bigint") return header + "\n" + inner + String(ext.value);
       if (ext.oid === OID_REASON_CODE && typeof ext.value === "number") return header + "\n" + inner + (NAMES.CRL_REASON[ext.value] || String(ext.value));
-      if (ext.oid === OID_INVALIDITY_DATE && ext.value instanceof Date) return header + "\n" + inner + _date(ext.value);
+      if (ext.oid === OID_INVALIDITY_DATE && guard.time.isDate(ext.value)) return header + "\n" + inner + _date(ext.value);
       if (ext.oid === OID_DELTA_CRL_INDICATOR && Buffer.isBuffer(ext.value)) {
         try {
           return header + "\n" + inner + "BaseCRLNumber: " + String(asn1.read.integer(asn1.decode(ext.value)));
@@ -36098,7 +37703,7 @@ var require_lint = __commonJS({
     function _effective(rule, cert) {
       if (!rule.effectiveDate) return true;
       var nb = cert.validity && cert.validity.notBefore;
-      return nb instanceof Date && nb.getTime() >= rule.effectiveDate.getTime();
+      return guard.time.isDate(nb) && guard.time.instantOf(nb) >= guard.time.instantOf(rule.effectiveDate);
     }
     function _runLints(rules2, cert, ctx) {
       var findings = [], counts = { fatal: 0, error: 0, warn: 0, notice: 0, pass: 0, na: 0, ne: 0 }, ran = [];
@@ -36275,7 +37880,7 @@ var require_lint = __commonJS({
         message: "the certificate notBefore must not be later than notAfter",
         check: function(cert) {
           var v = cert.validity;
-          return v.notBefore instanceof Date && v.notAfter instanceof Date && v.notBefore.getTime() > v.notAfter.getTime() ? true : null;
+          return guard.time.isDate(v.notBefore) && guard.time.isDate(v.notAfter) && guard.time.instantOf(v.notBefore) > guard.time.instantOf(v.notAfter) ? true : null;
         }
       },
       {
@@ -36567,7 +38172,7 @@ var require_lint = __commonJS({
     var VALIDITY_SCHEDULE_START = VALIDITY_SCHEDULE[VALIDITY_SCHEDULE.length - 1].from;
     function _validityCeilingDays(notBefore) {
       for (var i = 0; i < VALIDITY_SCHEDULE.length; i++) {
-        if (notBefore.getTime() >= VALIDITY_SCHEDULE[i].from.getTime()) return VALIDITY_SCHEDULE[i].maxDays;
+        if (guard.time.instantOf(notBefore) >= guard.time.instantOf(VALIDITY_SCHEDULE[i].from)) return VALIDITY_SCHEDULE[i].maxDays;
       }
       return VALIDITY_SCHEDULE[VALIDITY_SCHEDULE.length - 1].maxDays;
     }
@@ -36666,9 +38271,9 @@ var require_lint = __commonJS({
         effectiveDate: VALIDITY_SCHEDULE_START,
         check: function(cert) {
           var v = cert.validity;
-          if (!(v.notBefore instanceof Date) || !(v.notAfter instanceof Date)) return null;
+          if (!guard.time.isDate(v.notBefore) || !guard.time.isDate(v.notAfter)) return null;
           var maxDays = _validityCeilingDays(v.notBefore);
-          var days = (v.notAfter.getTime() - v.notBefore.getTime()) / MS_PER_DAY;
+          var days = (guard.time.instantOf(v.notAfter) - guard.time.instantOf(v.notBefore)) / MS_PER_DAY;
           return days > maxDays ? { context: { days: Math.round(days), maxDays } } : null;
         }
       }
@@ -36729,9 +38334,16 @@ var require_lint = __commonJS({
         return (SEVERITY[f.severity] || 0) >= floor;
       });
     }
+    var _CERTIFICATE_OPTS = { profile: 1, severity: 1 };
     function certificate(input, opts) {
-      opts = opts || {};
-      if (typeof opts !== "object") throw _cfg("lint/bad-input", "pki.lint options must be an object");
+      opts = guard.identifier.optionsObject(opts, _cfg, "lint/bad-input", "pki.lint options");
+      guard.identifier.assertKnownKeys(
+        opts,
+        _CERTIFICATE_OPTS,
+        _cfg,
+        "lint/bad-input",
+        "pki.lint.certificate has an unknown option: "
+      );
       if (opts.severity != null && VALID_SEVERITY.indexOf(opts.severity) === -1) {
         throw _cfg("lint/bad-severity", 'unknown severity threshold "' + opts.severity + '" (known: ' + VALID_SEVERITY.join(", ") + ")");
       }
@@ -37116,11 +38728,11 @@ var require_webauthn_mds = __commonJS({
         "webauthn/bad-metadata-blob",
         "the metadata BLOB nextUpdate"
       );
-      return d.getTime() + constants.TIME.days(1);
+      return guard.time.instantOf(d) + constants.TIME.days(1);
     }
     function assertFresh(metadata, at, label) {
       if (!metadata || metadata.allowStale === true || typeof metadata.nextUpdate !== "string") return;
-      var atMs = at instanceof Date ? at.getTime() : NaN;
+      var atMs = guard.time.isDate(at) ? guard.time.instantOf(at) : NaN;
       var limit = _staleAfter(metadata.nextUpdate);
       if (!isFinite(atMs) || !isFinite(limit)) return;
       if (atMs >= limit) {
@@ -37151,7 +38763,7 @@ var require_webauthn_mds = __commonJS({
         throw _err("webauthn/metadata-rollback", "the metadata BLOB no " + payload.no + " does not exceed the previously held " + opts.previousNo);
       }
       var staleAfter = _staleAfter(payload.nextUpdate);
-      var atMs = at.getTime();
+      var atMs = guard.time.instantOf(at);
       if (!isFinite(atMs) || !isFinite(staleAfter)) {
         throw _err("webauthn/bad-input", "the metadata freshness comparison has no usable instant");
       }
@@ -37323,7 +38935,7 @@ var require_webauthn_mds = __commonJS({
         "webauthn/bad-metadata-blob",
         "a status report effectiveDate"
       );
-      return d.getTime() <= atMs;
+      return guard.time.instantOf(d) <= atMs;
     }
     function statusDenied(entry, metadata, leaf, at) {
       var policy = metadata && metadata.statusPolicy || "any";
@@ -37335,7 +38947,7 @@ var require_webauthn_mds = __commonJS({
       var isDated = function(r) {
         return r && typeof r.effectiveDate === "string" && rfc3339.isValidDate(r.effectiveDate);
       };
-      var atMs = at instanceof Date && isFinite(at.getTime()) ? at.getTime() : null;
+      var atMs = guard.time.isDate(at) && isFinite(guard.time.instantOf(at)) ? guard.time.instantOf(at) : null;
       if (atMs !== null) {
         reports = reports.filter(function(r) {
           return !isDated(r) || _reportInForceAt(r, atMs);