@blamejs/core 0.18.54 → 0.18.55

package/lib/vendor/blamejs-pki.cjs

@@ -1,4 +1,4 @@
-// @blamejs/pki v0.5.30 — vendored (Apache-2.0). Zero-dep pure CJS.
+// @blamejs/pki v0.5.31 — vendored (Apache-2.0). Zero-dep pure CJS.
 // https://github.com/blamejs/pki  Exports: x509, crl, pkcs12, key, webcrypto, schema, csr, cms, ...
 // Backs lib/mtls-engine-default.js (PQC-capable CA + PKCS#12 engine).
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -141,7 +141,7 @@ var require_package = __commonJS({
   "node_modules/@blamejs/pki/package.json"(exports2, module2) {
     module2.exports = {
       name: "@blamejs/pki",
-      version: "0.5.30",
+      version: "0.5.31",
       description: "Pure-JavaScript PKI toolkit that owns its stack \u2014 X.509, ASN.1/DER, CMS, PQC-first.",
       license: "Apache-2.0",
       author: "blamejs contributors",
@@ -5756,6 +5756,7 @@ var require_asn1_der = __commonJS({
         return _asBuffer(buf, "build.raw");
       }
     };
+    intrinsic.freeze(build);
     function _intContent(v, who) {
       if (Buffer.isBuffer(v)) {
         if (v.length === 0) throw new Asn1Error("asn1/bad-integer", who + ": INTEGER content is empty");
@@ -18413,7 +18414,10 @@ var require_sign_scheme = __commonJS({
     }
     function _assertKeyMatchesScheme(key, imp, E) {
       var ka = key.algorithm || {};
-      if (_toUpperCase(_String(ka.name)) !== _toUpperCase(_String(imp.name))) throw E("bad-input", "the signer CryptoKey algorithm (" + ka.name + ") does not match the certificate's key algorithm (" + imp.name + ")");
+      if (_toUpperCase(_String(ka.name)) !== _toUpperCase(_String(imp.name))) {
+        var hint = _toUpperCase(_String(ka.name)) === "RSA-PSS" && _toUpperCase(_String(imp.name)) === "RSASSA-PKCS1-V1_5" ? "; this CryptoKey is bound to RSASSA-PSS -- pass opts.pss to sign with RSASSA-PSS" : "";
+        throw E("bad-input", "the signer CryptoKey algorithm (" + ka.name + ") does not match the certificate's key algorithm (" + imp.name + ")" + hint);
+      }
       if (imp.hash && (!ka.hash || ka.hash.name !== imp.hash)) throw E("bad-input", "the signer CryptoKey hash (" + (ka.hash && ka.hash.name) + ") does not match the signing digest (" + imp.hash + ")");
       if (imp.namedCurve && ka.namedCurve !== imp.namedCurve) throw E("bad-input", "the signer CryptoKey curve (" + ka.namedCurve + ") does not match the certificate curve (" + imp.namedCurve + ")");
     }
@@ -18436,7 +18440,10 @@ var require_sign_scheme = __commonJS({
       return { mldsa: _normPkcs8(key.mldsa, "the composite ML-DSA component key", E), trad: _normPkcs8(key.trad, "the composite traditional component key", E) };
     }
     function _importKey(key, imp, E) {
-      if (key && typeof key === "object" && !_isBuffer(key) && !_isU8(key) && key.type === "private") {
+      if (key && typeof key === "object" && !_isBuffer(key) && !_isU8(key) && typeof key.type === "string" && key.algorithm != null) {
+        if (key.type !== "private") {
+          throw E("bad-input", "the signing key is a WebCrypto CryptoKey of type " + _stringify(key.type) + '; a signing key must be a private key (type "private")');
+        }
         _assertKeyMatchesScheme(key, imp, E);
         return webcrypto.adoptKey(key, imp, ["sign"], E, "bad-input");
       }
@@ -18452,7 +18459,9 @@ var require_sign_scheme = __commonJS({
           throw E("bad-input", "the signer PEM private key could not be decoded", e);
         }
         owned = true;
-      } else throw E("bad-input", "a signer key must be a CryptoKey, a PKCS#8 DER Buffer, or a PKCS#8 PEM string");
+      } else if (intrinsic.types.isKeyObject(key)) {
+        throw E("bad-input", "the signing key is a node:crypto KeyObject, not a WebCrypto CryptoKey; pass a CryptoKey (e.g. from pki.key.generate) or export it to a PKCS#8 DER Buffer or PEM string");
+      } else throw E("bad-input", "a signer key must be a WebCrypto CryptoKey, a PKCS#8 DER Buffer, or a PKCS#8 PEM string");
       var imported = subtle.importKey("pkcs8", der, imp, false, ["sign"]);
       if (!owned) return imported;
       return imported.then(function(k) {
@@ -18492,35 +18501,101 @@ var require_sign_scheme = __commonJS({
 var require_ip_utils = __commonJS({
   "node_modules/@blamejs/pki/lib/ip-utils.js"(exports2, module2) {
     "use strict";
-    var IPV4_RE = /^(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
+    var intrinsic = require_guard_intrinsic();
+    var _slice = intrinsic.uncurry(String.prototype.slice);
+    var _padStart = intrinsic.uncurry(String.prototype.padStart);
+    var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+    var _lastIndexOf = intrinsic.uncurry(String.prototype.lastIndexOf);
+    var _toLowerCase = intrinsic.toLowerCase;
+    var _indexOf = intrinsic.stringIndexOf;
+    var _numToString = intrinsic.numberToString;
+    var _bufferFrom = intrinsic.bufferFrom;
+    var _bufferAlloc = intrinsic.bufferAlloc;
+    var _defineProperty = intrinsic.defineProperty;
+    var _Number = intrinsic.Number;
+    function _push(arr, v) {
+      _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true });
+    }
+    function _splitOn(str, sep) {
+      var out = [], from = 0, at;
+      while ((at = _indexOf(str, sep, from)) !== -1) {
+        _push(out, _slice(str, from, at));
+        from = at + sep.length;
+      }
+      _push(out, _slice(str, from));
+      return out;
+    }
+    function _isDigitCode(c) {
+      return c >= 48 && c <= 57;
+    }
+    function _isHexCode(c) {
+      return c >= 48 && c <= 57 || c >= 97 && c <= 102 || c >= 65 && c <= 70;
+    }
+    function _isOctet(p) {
+      var n = p.length, i, c;
+      if (n < 1 || n > 3) return false;
+      for (i = 0; i < n; i += 1) {
+        c = _charCodeAt(p, i);
+        if (!_isDigitCode(c)) return false;
+      }
+      if (n > 1 && _charCodeAt(p, 0) === 48) return false;
+      return _Number(p) <= 255;
+    }
     function isIPv4(s) {
-      return typeof s === "string" && IPV4_RE.test(s);
+      if (typeof s !== "string") return false;
+      var parts = _splitOn(s, ".");
+      if (parts.length !== 4) return false;
+      for (var i = 0; i < 4; i += 1) {
+        if (!_isOctet(parts[i])) return false;
+      }
+      return true;
+    }
+    function _isHexGroup(g) {
+      var n = g.length, i;
+      if (n < 1 || n > 4) return false;
+      for (i = 0; i < n; i += 1) {
+        if (!_isHexCode(_charCodeAt(g, i))) return false;
+      }
+      return true;
+    }
+    function _isDottedQuadShape(t) {
+      var q = _splitOn(t, "."), i, p, j;
+      if (q.length !== 4) return false;
+      for (i = 0; i < 4; i += 1) {
+        p = q[i];
+        if (p.length < 1 || p.length > 3) return false;
+        for (j = 0; j < p.length; j += 1) {
+          if (!_isDigitCode(_charCodeAt(p, j))) return false;
+        }
+      }
+      return true;
     }
     var IPV6_TEXT_MAX_LEN = 45;
     function expandIpv6Hex(ip) {
-      if (typeof ip !== "string" || ip.length > IPV6_TEXT_MAX_LEN || ip.indexOf(":") === -1) return null;
-      var dual = ip.match(/^(.*):(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
-      if (dual) {
-        if (!isIPv4(dual[2])) return null;
-        var v4 = dual[2].split(".").map(Number);
-        ip = dual[1] + ":" + (v4[0] << 8 | v4[1]).toString(16) + ":" + (v4[2] << 8 | v4[3]).toString(16);
-      }
-      var dbl = ip.split("::");
+      if (typeof ip !== "string" || ip.length > IPV6_TEXT_MAX_LEN || _indexOf(ip, ":") === -1) return null;
+      var lastColon = _lastIndexOf(ip, ":");
+      var tail = _slice(ip, lastColon + 1);
+      if (_indexOf(tail, ".") !== -1) {
+        if (!_isDottedQuadShape(tail) || !isIPv4(tail)) return null;
+        var q = _splitOn(tail, "."), o0 = _Number(q[0]), o1 = _Number(q[1]), o2 = _Number(q[2]), o3 = _Number(q[3]);
+        ip = _slice(ip, 0, lastColon) + ":" + _numToString(o0 << 8 | o1, 16) + ":" + _numToString(o2 << 8 | o3, 16);
+      }
+      var dbl = _splitOn(ip, "::");
       if (dbl.length > 2) return null;
-      var left = dbl[0] === "" ? [] : dbl[0].split(":");
-      var right = dbl.length === 2 ? dbl[1] === "" ? [] : dbl[1].split(":") : [];
+      var left = dbl[0] === "" ? [] : _splitOn(dbl[0], ":");
+      var right = dbl.length === 2 ? dbl[1] === "" ? [] : _splitOn(dbl[1], ":") : [];
       if (dbl.length === 1 && left.length !== 8) return null;
       var fill = 8 - left.length - right.length;
       if (dbl.length === 2 ? fill < 1 : fill !== 0) return null;
       var groups = left, i;
-      for (i = 0; i < fill; i += 1) groups = groups.concat(["0"]);
-      groups = groups.concat(right);
+      for (i = 0; i < fill; i += 1) _push(groups, "0");
+      for (i = 0; i < right.length; i += 1) _push(groups, right[i]);
       if (groups.length !== 8) return null;
       var hex = "";
       for (i = 0; i < 8; i += 1) {
         var g = groups[i];
-        if (g.length < 1 || g.length > 4 || !/^[0-9a-f]+$/i.test(g)) return null;
-        hex += g.toLowerCase().padStart(4, "0");
+        if (!_isHexGroup(g)) return null;
+        hex += _padStart(_toLowerCase(g), 4, "0");
       }
       return hex;
     }
@@ -18528,11 +18603,15 @@ var require_ip_utils = __commonJS({
       return isIPv4(s) || expandIpv6Hex(s) !== null;
     }
     function packIpLiteral(s) {
-      if (isIPv4(s)) return Buffer.from(s.split(".").map(Number));
+      if (isIPv4(s)) {
+        var parts = _splitOn(s, "."), buf = _bufferAlloc(4), i;
+        for (i = 0; i < 4; i += 1) buf[i] = _Number(parts[i]);
+        return buf;
+      }
       var hex = expandIpv6Hex(s);
-      return hex === null ? null : Buffer.from(hex, "hex");
+      return hex === null ? null : _bufferFrom(hex, "hex");
     }
-    module2.exports = { isIPv4, expandIpv6Hex, isIpLiteral, packIpLiteral, IPV4_RE };
+    module2.exports = { isIPv4, expandIpv6Hex, isIpLiteral, packIpLiteral };
   }
 });
 
@@ -18550,10 +18629,275 @@ var require_pki_build = __commonJS({
     var _bufferEquals = intrinsic.bufferEquals;
     var oid = require_oid();
     var ipUtils = require_ip_utils();
+    var _packIpLiteral = ipUtils.packIpLiteral;
     var nodeCrypto = require("crypto");
     var _keyEquals = intrinsic.uncurry(nodeCrypto.KeyObject.prototype.equals);
+    var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+    var _stringIndexOf = intrinsic.stringIndexOf;
+    var _stringLastIndexOf = intrinsic.uncurry(String.prototype.lastIndexOf);
+    var _sliceStr = intrinsic.uncurry(String.prototype.slice);
+    var _String = intrinsic.String;
+    var _objectKeys = intrinsic.keys;
+    var _isBufferChk = intrinsic.isBuffer;
+    var _stringify = intrinsic.stringify;
+    function _isAlphaCode(c) {
+      return c >= 65 && c <= 90 || c >= 97 && c <= 122;
+    }
+    function _isDigitCode(c) {
+      return c >= 48 && c <= 57;
+    }
+    function _isHexCode(c) {
+      return c >= 48 && c <= 57 || c >= 97 && c <= 102 || c >= 65 && c <= 70;
+    }
+    function _isUnreserved(c) {
+      return _isAlphaCode(c) || _isDigitCode(c) || c === 45 || c === 46 || c === 95 || c === 126;
+    }
+    function _isSubDelim(c) {
+      switch (c) {
+        case 33:
+        case 36:
+        case 38:
+        case 39:
+        case 40:
+        case 41:
+        case 42:
+        case 43:
+        case 44:
+        case 59:
+        case 61:
+          return true;
+        default:
+          return false;
+      }
+    }
+    function _isUserinfoByte(c) {
+      return _isUnreserved(c) || _isSubDelim(c) || c === 58;
+    }
+    function _isUriByte(c) {
+      return _isUnreserved(c) || _isSubDelim(c) || c === 58 || c === 47 || c === 63 || c === 35 || c === 64;
+    }
+    function _isAtextByte(c) {
+      if (_isAlphaCode(c) || _isDigitCode(c)) return true;
+      switch (c) {
+        case 33:
+        case 35:
+        case 36:
+        case 37:
+        case 38:
+        case 39:
+        // ! # $ % & '
+        case 42:
+        case 43:
+        case 45:
+        case 47:
+        case 61:
+        case 63:
+        // * + - / = ?
+        case 94:
+        case 95:
+        case 96:
+        case 123:
+        case 124:
+        case 125:
+        case 126:
+          return true;
+        default:
+          return false;
+      }
+    }
+    function _looksLikeIPv4Shape(s) {
+      var n = s.length, i, c, sawDot = false, atomEmpty = true;
+      if (n === 0) return false;
+      for (i = 0; i < n; i += 1) {
+        c = _charCodeAt(s, i);
+        if (c === 46) {
+          if (atomEmpty) return false;
+          sawDot = true;
+          atomEmpty = true;
+        } else if (_isDigitCode(c)) {
+          atomEmpty = false;
+        } else return false;
+      }
+      return sawDot && !atomEmpty;
+    }
+    function _componentBytesOk(s, from, to, byteOk) {
+      var i = from, c;
+      while (i < to) {
+        c = _charCodeAt(s, i);
+        if (c === 37) {
+          if (i + 2 >= to || !_isHexCode(_charCodeAt(s, i + 1)) || !_isHexCode(_charCodeAt(s, i + 2))) return false;
+          i += 3;
+        } else if (byteOk(c)) {
+          i += 1;
+        } else return false;
+      }
+      return true;
+    }
+    function _validUriHost(s, from, to) {
+      if (to <= from) return false;
+      var host = _sliceStr(s, from, to), len = host.length;
+      if (_looksLikeIPv4Shape(host)) return _packIpLiteral(host) !== null;
+      var end = _charCodeAt(host, len - 1) === 46 ? len - 1 : len;
+      if (end > 253) return false;
+      var firstDot = _stringIndexOf(host, ".", 0);
+      if (firstDot === -1 || firstDot >= end) return false;
+      return _labelsValid(host, 0, len, _isHostLabelRange, true);
+    }
+    function _validUriAuthority(s, from, to) {
+      var i, c, at = -1;
+      for (i = from; i < to; i += 1) {
+        c = _charCodeAt(s, i);
+        if (c === 64) {
+          if (at !== -1) return false;
+          at = i;
+        }
+      }
+      var hostStart = at === -1 ? from : at + 1;
+      if (at !== -1 && !_componentBytesOk(s, from, at, _isUserinfoByte)) return false;
+      var colon = -1;
+      for (i = hostStart; i < to; i += 1) {
+        if (_charCodeAt(s, i) === 58) {
+          colon = i;
+          break;
+        }
+      }
+      var hostEnd = colon === -1 ? to : colon;
+      if (!_validUriHost(s, hostStart, hostEnd)) return false;
+      if (colon !== -1) {
+        for (i = colon + 1; i < to; i += 1) {
+          if (!_isDigitCode(_charCodeAt(s, i))) return false;
+        }
+      }
+      return true;
+    }
+    function _looksLikeUri(s) {
+      var n = s.length, i, c;
+      if (n === 0 || !_isAlphaCode(_charCodeAt(s, 0))) return false;
+      i = 1;
+      while (i < n) {
+        c = _charCodeAt(s, i);
+        if (_isAlphaCode(c) || _isDigitCode(c) || c === 43 || c === 45 || c === 46) i += 1;
+        else break;
+      }
+      if (i + 3 > n || _charCodeAt(s, i) !== 58 || _charCodeAt(s, i + 1) !== 47 || _charCodeAt(s, i + 2) !== 47) return false;
+      i += 3;
+      var authStart = i, authEnd = n;
+      for (; i < n; i += 1) {
+        c = _charCodeAt(s, i);
+        if (c === 47 || c === 63 || c === 35) {
+          authEnd = i;
+          break;
+        }
+      }
+      if (authEnd === authStart) return false;
+      if (!_validUriAuthority(s, authStart, authEnd)) return false;
+      var sawHash = false;
+      i = authEnd;
+      while (i < n) {
+        c = _charCodeAt(s, i);
+        if (c === 37) {
+          if (i + 2 >= n || !_isHexCode(_charCodeAt(s, i + 1)) || !_isHexCode(_charCodeAt(s, i + 2))) return false;
+          i += 3;
+          continue;
+        }
+        if (c === 35) {
+          if (sawHash) return false;
+          sawHash = true;
+        }
+        if (!_isUriByte(c)) return false;
+        i += 1;
+      }
+      return true;
+    }
+    function _isDnsLabelRange(s, from, to) {
+      var len = to - from, i, c;
+      if (len < 1 || len > 63) return false;
+      for (i = from; i < to; i += 1) {
+        c = _charCodeAt(s, i);
+        if (_isAlphaCode(c) || _isDigitCode(c)) continue;
+        if (i === to - 1) return false;
+        if (c === 95) continue;
+        if (c === 45 && i !== from) continue;
+        return false;
+      }
+      return true;
+    }
+    function _isHostLabelRange(s, from, to) {
+      var len = to - from, i, c, edge;
+      if (len < 1 || len > 63) return false;
+      for (i = from; i < to; i += 1) {
+        c = _charCodeAt(s, i);
+        edge = i === from || i === to - 1;
+        if (_isAlphaCode(c) || _isDigitCode(c)) continue;
+        if (c === 45 && !edge) continue;
+        return false;
+      }
+      return true;
+    }
+    function _labelsValid(s, from, to, labelFn, allowRootDot) {
+      if (allowRootDot && to - from >= 1 && _charCodeAt(s, to - 1) === 46) to -= 1;
+      if (to <= from) return false;
+      var start = from, dot;
+      for (; ; ) {
+        dot = _stringIndexOf(s, ".", start);
+        var end = dot === -1 || dot >= to ? to : dot;
+        if (!labelFn(s, start, end)) return false;
+        if (end === to) return true;
+        start = end + 1;
+      }
+    }
+    function _looksLikeDnsName(s) {
+      var n = s.length, start = 0;
+      if (n < 1) return false;
+      var end = _charCodeAt(s, n - 1) === 46 ? n - 1 : n;
+      if (end < 1 || end > 253) return false;
+      if (end >= 2 && _charCodeAt(s, 0) === 42 && _charCodeAt(s, 1) === 46) start = 2;
+      if (start >= end) return false;
+      return _labelsValid(s, start, n, _isDnsLabelRange, true);
+    }
+    function _looksLikeEmail(s) {
+      if (s.length > 254) return false;
+      var at = _stringIndexOf(s, "@", 0);
+      if (at < 1 || at > 64 || _stringLastIndexOf(s, "@") !== at) return false;
+      var i, c, atomEmpty = true;
+      for (i = 0; i < at; i += 1) {
+        c = _charCodeAt(s, i);
+        if (c === 46) {
+          if (atomEmpty) return false;
+          atomEmpty = true;
+        } else if (_isAtextByte(c)) {
+          atomEmpty = false;
+        } else return false;
+      }
+      if (atomEmpty) return false;
+      var dStart = at + 1, dLen = s.length - dStart;
+      if (dLen < 1 || dLen > 253 || _stringIndexOf(s, ".", dStart) === -1) return false;
+      return _labelsValid(s, dStart, s.length, _isHostLabelRange, false);
+    }
+    function _isDottedOid(s) {
+      var n = s.length, i, c, d0, arcs = 0;
+      if (n < 3) return false;
+      c = _charCodeAt(s, 0);
+      if (c < 48 || c > 50) return false;
+      i = 1;
+      while (i < n) {
+        if (_charCodeAt(s, i) !== 46) return false;
+        i += 1;
+        if (i >= n) return false;
+        d0 = _charCodeAt(s, i);
+        if (d0 === 48) {
+          i += 1;
+        } else if (d0 >= 49 && d0 <= 57) {
+          i += 1;
+          while (i < n && _isDigitCode(_charCodeAt(s, i))) i += 1;
+        } else {
+          return false;
+        }
+        arcs += 1;
+      }
+      return arcs >= 1;
+    }
     var b = asn1.build;
-    var DOTTED_OID_RE = /^[0-2](?:\.(?:0|[1-9]\d*))+$/;
     var KU_BIT = {
       digitalSignature: 0,
       nonRepudiation: 1,
@@ -18639,15 +18983,30 @@ var require_pki_build = __commonJS({
         return asn1.decode(nameDer).children.length === 0;
       }
       function ia5Content(s) {
-        s = String(s);
+        s = _String(s);
         for (var i = 0; i < s.length; i++) {
-          if (s.charCodeAt(i) > 127) throw E("bad-input", "value requires 7-bit ASCII (IA5String): " + JSON.stringify(s));
+          if (_charCodeAt(s, i) > 127) throw E("bad-input", "value requires 7-bit ASCII (IA5String): " + _stringify(s));
         }
-        return Buffer.from(s, "latin1");
+        return _bufferFrom(s, "latin1");
+      }
+      function _classifyBareGeneralName(s) {
+        if (_packIpLiteral(s) !== null) return { iPAddress: s };
+        if (_looksLikeIPv4Shape(s)) {
+          throw E("bad-input", "the bare GeneralName string " + _stringify(s) + " looks like an IPv4 address but is not a valid one; pass { iPAddress: ... } for an address or { dNSName: ... } for a name");
+        }
+        if (_looksLikeUri(s)) return { uniformResourceIdentifier: s };
+        if (_looksLikeEmail(s)) return { rfc822Name: s };
+        if (_looksLikeDnsName(s)) return { dNSName: s };
+        var _qs = _stringify(s);
+        throw E("bad-input", "cannot classify the bare GeneralName string " + _qs + " as a dNSName, rfc822Name, iPAddress, or URI; pass an explicit form object, e.g. { dNSName: " + _qs + " }");
       }
       function encodeGeneralName(entry) {
-        if (!entry || typeof entry !== "object" || Buffer.isBuffer(entry)) throw E("bad-input", "a GeneralName must be an object with exactly one name form");
-        var keys = Object.keys(entry);
+        if (typeof entry === "string") {
+          if (entry === "") throw E("bad-input", "an empty GeneralName value is not permitted (RFC 5280 sec. 4.2.1.6)");
+          entry = _classifyBareGeneralName(entry);
+        }
+        if (!entry || typeof entry !== "object" || _isBufferChk(entry)) throw E("bad-input", "a GeneralName must be an object with exactly one name form");
+        var keys = _objectKeys(entry);
         if (keys.length !== 1) throw E("bad-input", "a GeneralName entry must have exactly one form, got " + keys.length);
         var k = keys[0], v = entry[k];
         if (v == null || v === "") throw E("bad-input", "an empty GeneralName value is not permitted (RFC 5280 sec. 4.2.1.6)");
@@ -18662,10 +19021,10 @@ var require_pki_build = __commonJS({
           case "iPAddress":
             var ipBuf = v;
             if (typeof v === "string") {
-              ipBuf = ipUtils.packIpLiteral(v);
-              if (ipBuf === null) throw E("bad-input", "iPAddress string is not a valid IPv4 or IPv6 literal: " + JSON.stringify(v));
+              ipBuf = _packIpLiteral(v);
+              if (ipBuf === null) throw E("bad-input", "iPAddress string is not a valid IPv4 or IPv6 literal: " + _stringify(v));
             }
-            if (!Buffer.isBuffer(ipBuf) || ipBuf.length !== 4 && ipBuf.length !== 16) throw E("bad-input", "iPAddress must be a 4- or 16-octet Buffer or an IPv4/IPv6 string");
+            if (!_isBufferChk(ipBuf) || ipBuf.length !== 4 && ipBuf.length !== 16) throw E("bad-input", "iPAddress must be a 4- or 16-octet Buffer or an IPv4/IPv6 string");
             return b.contextPrimitive(7, ipBuf);
           case "directoryName":
             return b.explicit(4, encodeName(v));
@@ -18700,7 +19059,7 @@ var require_pki_build = __commonJS({
       function _resolveOid(n, label) {
         var dotted = O(n);
         if (dotted != null) return dotted;
-        if (typeof n === "string" && DOTTED_OID_RE.test(n)) {
+        if (typeof n === "string" && _isDottedOid(n)) {
           try {
             b.oid(n);
           } catch (e) {
@@ -30696,7 +31055,7 @@ var require_x509_sign = __commonJS({
         }
       );
       guard.identifier.assertKnownKeys(opts, KNOWN_SIGN_OPTS, _err, "x509/bad-input", "pki.x509.sign has an unknown option ");
-      if (issuer.key == null) throw _err("x509/bad-input", "a signing key (issuer.key, a PKCS#8 private key) is required");
+      if (issuer.key == null) throw _err("x509/bad-input", "a signing key (issuer.key, a WebCrypto CryptoKey or a PKCS#8 private key DER/PEM) is required");
       var spki = _reqDer(spec.subjectPublicKey, "spec.subjectPublicKey (the SPKI DER of the certified key)");
       _assertValidSpki(spki, "spec.subjectPublicKey");
       var subjectDer = _encodeName(spec.subject == null ? [] : spec.subject);
@@ -31308,7 +31667,7 @@ var require_attrcert_sign = __commonJS({
       if (!spec || typeof spec !== "object" || Buffer.isBuffer(spec)) throw _err("attrcert/bad-input", "the attribute-certificate spec must be an object");
       guard.identifier.assertKnownKeys(spec, KNOWN_SPEC_KEYS, _err, "attrcert/bad-input", "unknown spec field ");
       issuer = issuer || {};
-      if (issuer.key == null) throw _err("attrcert/bad-input", "a signing key (issuer.key, the AA's PKCS#8 private key) is required");
+      if (issuer.key == null) throw _err("attrcert/bad-input", "a signing key (issuer.key, the AA's WebCrypto CryptoKey or PKCS#8 private key DER/PEM) is required");
       var issuerDnSpec, aaSpki;
       if (issuer.cert != null) {
         var aaCert = _parseCert(issuer.cert, "issuer.cert");
@@ -32026,7 +32385,7 @@ var require_crl_sign = __commonJS({
         }
       );
       guard.identifier.assertKnownKeys(opts, KNOWN_SIGN_OPTS, _err, "crl/bad-input", "pki.crl.sign has an unknown option ");
-      if (issuer.key == null) throw _err("crl/bad-input", "a signing key (issuer.key, a PKCS#8 private key) is required");
+      if (issuer.key == null) throw _err("crl/bad-input", "a signing key (issuer.key, a WebCrypto CryptoKey or a PKCS#8 private key DER/PEM) is required");
       var issuerDer, issuerSpki, issuerCert = null;
       if (byCert) {
         issuerCert = _parseIssuerCert(issuer.cert);

package/lib/watcher.js

@@ -231,7 +231,7 @@ var AUTO_PROBE_POLL_FSTYPES = new Set([
   "vboxsf",
 ]);
 
-function _detectAutoMode(rootPath) {
+function _detectAutoMode(rootPath, probe) {
   // Sync probe — looks at the kernel's view of the mount carrying the
   // watcher's root and decides whether fs.watch will deliver events.
   // Three signals contribute, in priority order:
@@ -246,7 +246,21 @@ function _detectAutoMode(rootPath) {
   //   3. Otherwise — fs.
   //
   // Returns { mode, reason, fsType, inContainer }.
-  if (process.platform !== "linux") {
+  // Injectable so the branches that only exist on a restricted Linux can be
+  // driven from any host. A rule about what happens when mountinfo cannot be
+  // read is untestable while reaching it requires unmounting /proc.
+  var platform = (probe && probe.platform) || process.platform;
+  var readEntries = (probe && probe.readEntries) ||
+    function () { return safeMountInfo.read(); };
+  // Injected for the same reason as readEntries, and for one more: "/.dockerenv"
+  // is drive-relative on Windows, so a direct probe there asks about C:\.dockerenv
+  // rather than about being in a container. It is only reached below the
+  // non-Linux return, but reaching a POSIX path through the injected reader is
+  // what keeps that ordering from being the only thing holding it up.
+  var exists = (probe && probe.exists) ||
+    function (p) { return nodeFs.existsSync(p); };
+
+  if (platform !== "linux") {
     // macOS + Windows fs.watch backends use FSEvents + ReadDirectoryChangesW
     // respectively, which DO deliver recursive events natively for
     // operator-owned local filesystems. Containerized Linux is the
@@ -255,7 +269,7 @@ function _detectAutoMode(rootPath) {
   }
 
   var inContainer = false;
-  try { inContainer = nodeFs.existsSync("/.dockerenv"); }
+  try { inContainer = exists("/.dockerenv"); }
   catch (_e) { inContainer = false; }
 
   // Route through b.safeMountInfo — single canonical parser that
@@ -263,13 +277,23 @@ function _detectAutoMode(rootPath) {
   // mount check below. Pre-v0.11.6 this parsed inline; centralizing
   // it means future container-escape / sealed-store / sandbox call
   // sites inherit the discipline.
-  var entries = safeMountInfo.read();
+  var entries = readEntries();
+  // Not knowing which filesystem this is resolves toward polling, not toward
+  // fs.watch. On Linux mountinfo is always there, so failing to read it means
+  // /proc is unmounted or restricted — which is the containerized case this
+  // probe exists for, and the one where inotify is least likely to deliver.
+  // The two answers are not symmetric: polling costs stat calls the operator
+  // can see, while fs.watch on a filesystem that does not chain inotify drops
+  // events silently and nothing downstream can tell that it did.
   if (entries === null || entries.length === 0) {
-    return { mode: "fs", reason: "no-mountinfo", fsType: null, inContainer: inContainer };
+    return { mode: "poll", reason: "no-mountinfo", fsType: null, inContainer: inContainer };
   }
   var bestMatch = safeMountInfo.bestMatch(entries, rootPath);
   if (!bestMatch) {
-    return { mode: "fs", reason: "no-mount-match", fsType: null, inContainer: inContainer };
+    // Same reasoning: "/" matches every path on a healthy Linux, so no match
+    // means the mount table did not describe this root and its fstype is
+    // unknown rather than known-good.
+    return { mode: "poll", reason: "no-mount-match", fsType: null, inContainer: inContainer };
   }
   if (AUTO_PROBE_POLL_FSTYPES.has(bestMatch.fstype)) {
     return {
@@ -687,4 +711,5 @@ module.exports = {
   // create() enforces, instead of pinning hand-copied mirror constants.
   MAX_IGNORE_PATTERN_LEN: MAX_IGNORE_PATTERN_LEN,
   MAX_IGNORE_STAR_COUNT:  MAX_IGNORE_STAR_COUNT,
+  _detectAutoModeForTest: _detectAutoMode,
 };

package/lib/ws-client.js

@@ -361,7 +361,12 @@ class WsClient extends EventEmitter {
       allowInternal: opts.allowInternal,
       errorClass:    WsClientError,
     });
-    this._ssrfPinnedIps = probe && probe.ips ? probe.ips : null;
+    // `null` when the gate produced no pin at all, the array when it did —
+    // including an EMPTY one. An empty pin means the gate admitted no address,
+    // so there is nothing to connect to; treating it as "no pin" would hand the
+    // connect back to the ordinary resolver and re-open the rebinding window
+    // the pin exists to close.
+    this._ssrfPinnedIps = probe && Array.isArray(probe.ips) ? probe.ips : null;
     this._dialParsed    = dialParsed;
     this._dialTlsOpts   = dialTlsOpts;
   }
@@ -405,12 +410,22 @@ class WsClient extends EventEmitter {
     // private one between the check and the connect.
     var pinnedIps = self._ssrfPinnedIps || null;
     var lookup = null;
-    if (pinnedIps && pinnedIps.length > 0) {
+    if (pinnedIps) {
       lookup = function (h, lookupOpts, cb) {
         // Node's lookup callback signatures:
         //   (err, address, family) for legacy { all: false } (default)
         //   (err, addresses)        for { all: true }
         if (typeof lookupOpts === "function") { cb = lookupOpts; lookupOpts = {}; }
+        // An empty pin admits no address, so there is nothing to connect to.
+        // Answer the lookup with an error, which fails the dial through the
+        // socket's ordinary error path — reading `pinnedIps[0].address` here
+        // would throw a TypeError out of a lookup callback instead, which is a
+        // crash rather than a refusal.
+        if (pinnedIps.length === 0) {
+          var noneErr = new Error("ws.connect: the SSRF gate admitted no address for " + h);
+          noneErr.code = "ENOTFOUND";
+          return cb(noneErr);
+        }
         var first = pinnedIps[0];
         if (lookupOpts && lookupOpts.all) {
           return cb(null, pinnedIps.map(function (ip) {