@blamejs/pki 0.6.40 → 0.6.42

package/lib/jose.js

@@ -129,7 +129,7 @@ function parseJson(input) {
 }
 
 
-var SIG_ALGS = {
+var SIG_ALGS = intrinsic.assign(intrinsic.create(null), {
   ES256: { kty: "EC", crv: "P-256", hash: "SHA-256", subtle: "ECDSA", sigBytes: 64 },
   ES384: { kty: "EC", crv: "P-384", hash: "SHA-384", subtle: "ECDSA", sigBytes: 96 },
   ES512: { kty: "EC", crv: "P-521", hash: "SHA-512", subtle: "ECDSA", sigBytes: 132 },
@@ -139,26 +139,26 @@ var SIG_ALGS = {
   PS256: { kty: "RSA", hash: "SHA-256", subtle: "RSA-PSS", saltLength: 32 },
   PS384: { kty: "RSA", hash: "SHA-384", subtle: "RSA-PSS", saltLength: 48 },
   PS512: { kty: "RSA", hash: "SHA-512", subtle: "RSA-PSS", saltLength: 64 },
-  EdDSA: { kty: "OKP", subtle: "EdDSA", sigBytesByCrv: { Ed25519: 64, Ed448: 114 } },
+  EdDSA: { kty: "OKP", subtle: "EdDSA", sigBytesByCrv: intrinsic.assign(intrinsic.create(null), { Ed25519: 64, Ed448: 114 }) },
   "ML-DSA-44": { kty: "AKP", subtle: "ML-DSA-44", sigBytes: 2420 },
   "ML-DSA-65": { kty: "AKP", subtle: "ML-DSA-65", sigBytes: 3309 },
   "ML-DSA-87": { kty: "AKP", subtle: "ML-DSA-87", sigBytes: 4627 },
-};
+});
 
-var MAC_ALGS = {
+var MAC_ALGS = intrinsic.assign(intrinsic.create(null), {
   HS256: { kty: "oct", hash: "SHA-256", sigBytes: 32 },
   HS384: { kty: "oct", hash: "SHA-384", sigBytes: 48 },
   HS512: { kty: "oct", hash: "SHA-512", sigBytes: 64 },
-};
+});
 
-var UNDERSTOOD_HEADER = { alg: 1, nonce: 1, url: 1, jwk: 1, kid: 1, crit: 1 };
+var UNDERSTOOD_HEADER = intrinsic.assign(intrinsic.create(null), { alg: 1, nonce: 1, url: 1, jwk: 1, kid: 1, crit: 1 });
 
 
-var PROFILES = {
+var PROFILES = intrinsic.assign(intrinsic.create(null), {
   "acme-outer":     { algs: SIG_ALGS, nonce: "required",  keyId: "one-of", requireUrl: true },
   "eab-inner":      { algs: MAC_ALGS, nonce: "forbidden", keyId: "kid",    requireUrl: true },
   "keychange-inner": { algs: SIG_ALGS, nonce: "forbidden", keyId: "jwk",    requireUrl: true },
-};
+});
 
 function _checkHeader(header, profileName) {
   var profile = PROFILES[profileName];
@@ -192,7 +192,7 @@ function _checkHeader(header, profileName) {
   if (_hasOwn(header, "crit")) {
     var crit = header.crit;
     if (!_isArray(crit) || crit.length === 0) throw E("jose/bad-crit", "crit must be a non-empty array");
-    var seen = {};
+    var seen = intrinsic.create(null);
     for (var c = 0; c < crit.length; c++) {
       var name = crit[c];
       if (typeof name !== "string") throw E("jose/bad-crit", "crit entries must be strings");
@@ -315,7 +315,7 @@ function assertPublicJwk(jwk) {
  *   var v = await pki.jose.verify(jws, { profile: "acme-outer", key: accountJwk });
  *   v.header.alg;   // -> "ES256"
  */
-var _VERIFY_KEYS = { key: 1, profile: 1 };
+var _VERIFY_KEYS = intrinsic.assign(intrinsic.create(null), { key: 1, profile: 1 });
 async function verify(jws, opts) {
   opts = opts || {};
   guard.identifier.assertKnownKeys(opts, _VERIFY_KEYS, E, "jose/bad-input", "unknown pki.jose.verify option ");
@@ -395,8 +395,8 @@ async function verify(jws, opts) {
  *     nonce: "oFvnlFP1wIhRlYS2jTaXbA", url: "https://ca.example/acme/new-acct" };
  *   var jws = await pki.jose.sign({ protected: hdr, payload: Buffer.from("{}"), key: priv });
  */
-var _SIGN_KEYS = { protected: 1, payload: 1, key: 1, jwk: 1, profile: 1 };
-var _SIGN_KEYS_EMBEDDED_JWK = { protected: 1, payload: 1, key: 1, profile: 1 };
+var _SIGN_KEYS = intrinsic.assign(intrinsic.create(null), { protected: 1, payload: 1, key: 1, jwk: 1, profile: 1 });
+var _SIGN_KEYS_EMBEDDED_JWK = intrinsic.assign(intrinsic.create(null), { protected: 1, payload: 1, key: 1, profile: 1 });
 async function sign(opts) {
   opts = opts || {};
   guard.identifier.assertKnownKeys(opts, _SIGN_KEYS, E, "jose/bad-input", "unknown pki.jose.sign option ");
@@ -442,13 +442,13 @@ async function sign(opts) {
 }
 
 
-var THUMBPRINT_MEMBERS = {
+var THUMBPRINT_MEMBERS = intrinsic.assign(intrinsic.create(null), {
   EC: ["crv", "kty", "x", "y"],
   RSA: ["e", "kty", "n"],
   oct: ["k", "kty"],
   OKP: ["crv", "kty", "x"],
   AKP: ["alg", "kty", "pub"],
-};
+});
 
 /**
  * @primitive  pki.jose.thumbprint

package/lib/key.js

@@ -38,7 +38,7 @@ function _err(code, msg, cause) { return new KeyError(code, msg, cause); }
 
 var CIPHER_NAME = Object.assign(Object.create(null), { "aes-128-cbc": "aes128-CBC", "aes-192-cbc": "aes192-CBC", "aes-256-cbc": "aes256-CBC" });
 
-var INFER_ALG = {};
+var INFER_ALG = Object.create(null);
 ["Ed25519", "Ed448", "X25519", "X448"].forEach(function (n) { INFER_ALG[O(n)] = { name: n }; });
 [["id-ml-dsa-44", "ML-DSA-44"], ["id-ml-dsa-65", "ML-DSA-65"], ["id-ml-dsa-87", "ML-DSA-87"],
  ["id-ml-kem-512", "ML-KEM-512"], ["id-ml-kem-768", "ML-KEM-768"], ["id-ml-kem-1024", "ML-KEM-1024"]
@@ -88,7 +88,7 @@ async function _toPrivateKeyDer(input) {
  *   var enc = await pki.key.encrypt(der, "s3cr3t", { pem: true });
  *   var back = await pki.key.decrypt(enc, "s3cr3t");
  */
-var _ENCRYPT_OPTS = { cipher: 1, iterations: 1, pem: 1, prf: 1, salt: 1 };
+var _ENCRYPT_OPTS = Object.assign(Object.create(null), { cipher: 1, iterations: 1, pem: 1, prf: 1, salt: 1 });
 
 async function encrypt(privateKey, password, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.encrypt options");
@@ -147,7 +147,7 @@ async function encrypt(privateKey, password, opts) {
  *   var enc = await pki.key.encrypt(await pki.key.export(pair.privateKey), "s3cr3t", { pem: true });
  *   var der = await pki.key.decrypt(enc, "s3cr3t");
  */
-var _DECRYPT_OPTS = { maxIterations: 1, pem: 1 };
+var _DECRYPT_OPTS = Object.assign(Object.create(null), { maxIterations: 1, pem: 1 });
 
 async function decrypt(encrypted, password, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.decrypt options");
@@ -203,7 +203,7 @@ function _decryptPbes2(encAlg, ciphertext, password, opts) {
  *   var pair = await pki.key.generate("Ed25519");
  *   var spkiPem = await pki.key.export(pair.publicKey, { format: "pem" });
  */
-var _EXPORT_OPTS = { format: 1, label: 1 };
+var _EXPORT_OPTS = Object.assign(Object.create(null), { format: 1, label: 1 });
 
 async function export_(key, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.export options");
@@ -246,7 +246,7 @@ async function export_(key, opts) {
  *   var spki = await pki.key.export(pair.publicKey);
  *   var pub = await pki.key.import(spki);                       // Ed25519 -- algorithm inferred
  */
-var _IMPORT_OPTS = { algorithm: 1, extractable: 1, password: 1, usages: 1 };
+var _IMPORT_OPTS = Object.assign(Object.create(null), { algorithm: 1, extractable: 1, password: 1, usages: 1 });
 
 async function import_(input, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.import options");
@@ -290,7 +290,7 @@ async function import_(input, opts) {
  *   var pair = await pki.key.generate("Ed25519");
  *   var pkcs8 = await pki.key.export(pair.privateKey);
  */
-var _GENERATE_OPTS = { extractable: 1, usages: 1 };
+var _GENERATE_OPTS = Object.assign(Object.create(null), { extractable: 1, usages: 1 });
 
 async function generate(algorithm, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.generate options");
@@ -325,7 +325,7 @@ async function generate(algorithm, opts) {
  *   var pair = await pki.key.generate("Ed25519");
  *   var spki = await pki.key.publicFromPrivate(await pki.key.export(pair.privateKey));
  */
-var _PUBLIC_FROM_PRIVATE_OPTS = { pem: 1 };
+var _PUBLIC_FROM_PRIVATE_OPTS = Object.assign(Object.create(null), { pem: 1 });
 
 async function publicFromPrivate(privateKey, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.publicFromPrivate options");

package/lib/lint.js

@@ -129,7 +129,8 @@ function _effective(rule, cert) {
 }
 
 function _runLints(rules, cert, ctx) {
-  var findings = [], counts = { fatal: 0, error: 0, warn: 0, notice: 0, pass: 0, na: 0, ne: 0 }, ran = [];
+  var findings = [], ran = [];
+  var counts = Object.assign(Object.create(null), { fatal: 0, error: 0, warn: 0, notice: 0, pass: 0, na: 0, ne: 0 });
   rules.forEach(function (rule) {
     if (rule.appliesTo && !rule.appliesTo(cert, ctx)) { counts.na++; return; }
     if (!_effective(rule, cert)) { counts.ne++; return; }
@@ -172,7 +173,7 @@ function _subjectCNs(cert) {
   return out;
 }
 
-var _CRITICAL_LEGIT = {};
+var _CRITICAL_LEGIT = Object.create(null);
 _CRITICAL_LEGIT[oid.byName("precertificatePoison")] = true;
 function _isUnknownExtension(extOid) {
   if (path.PROCESSED_EXTENSIONS[extOid] !== true) return _CRITICAL_LEGIT[extOid] !== true;
@@ -560,7 +561,7 @@ function _applyThreshold(report, severity) {
  *   report.worst;                              // "notice" | "error" | ...
  *   report.findings.map(function (f) { return f.id; });
  */
-var _CERTIFICATE_OPTS = { profile: 1, severity: 1 };
+var _CERTIFICATE_OPTS = Object.assign(Object.create(null), { profile: 1, severity: 1 });
 
 function certificate(input, opts) {
   opts = guard.identifier.optionsObject(opts, _cfg, "lint/bad-input", "pki.lint options");
@@ -573,7 +574,8 @@ function certificate(input, opts) {
   var ingested = _ingest(input);
   var report;
   if (ingested.fatal) {
-    report = { findings: [ingested.fatal], counts: { fatal: 1, error: 0, warn: 0, notice: 0, pass: 0, na: 0, ne: 0 }, ran: [] };
+    report = { findings: [ingested.fatal], ran: [],
+      counts: Object.assign(Object.create(null), { fatal: 1, error: 0, warn: 0, notice: 0, pass: 0, na: 0, ne: 0 }) };
   } else {
     var ctx = _makeCtx(ingested.cert, opts.profile);
     report = _runLints(rules, ingested.cert, ctx);

package/lib/merkle.js

@@ -180,7 +180,7 @@ function emptyRootHash() {
  *   var lh = pki.merkle.leafHash(Buffer.from([0]));
  *   pki.merkle.verifyInclusion({ leafIndex: 0, treeSize: 1, leafHash: lh, proof: [], rootHash: lh }); // -> true
  */
-var _INCLUSION_KEYS = { leafIndex: 1, treeSize: 1, leafHash: 1, rootHash: 1, proof: 1 };
+var _INCLUSION_KEYS = Object.assign(Object.create(null), { leafIndex: 1, treeSize: 1, leafHash: 1, rootHash: 1, proof: 1 });
 function verifyInclusion(opts) {
   opts = opts || {};
   guard.identifier.assertKnownKeys(opts, _INCLUSION_KEYS, function (c, m) { return new MerkleError(c, m); },
@@ -252,7 +252,7 @@ function verifyInclusion(opts) {
  *   var r = pki.merkle.leafHash(Buffer.from([0]));
  *   pki.merkle.verifyConsistency({ oldSize: 1, newSize: 1, oldRoot: r, newRoot: r, proof: [] }); // -> true
  */
-var _CONSISTENCY_KEYS = { oldSize: 1, newSize: 1, oldRoot: 1, newRoot: 1, proof: 1 };
+var _CONSISTENCY_KEYS = Object.assign(Object.create(null), { oldSize: 1, newSize: 1, oldRoot: 1, newRoot: 1, proof: 1 });
 function verifyConsistency(opts) {
   opts = opts || {};
   guard.identifier.assertKnownKeys(opts, _CONSISTENCY_KEYS, function (c, m) { return new MerkleError(c, m); },

package/lib/mime.js

@@ -68,7 +68,7 @@ function _unfoldHeaders(headerText) {
 function _parseStructured(headerValue) {
   var parts = _splitSemicolons(headerValue);
   var type = _stripComments(parts[0]).trim().toLowerCase();
-  var params = {};
+  var params = Object.create(null);
   for (var i = 1; i < parts.length; i++) {
     var p = _stripComments(parts[i]);
     var eq = p.indexOf("=");
@@ -131,7 +131,7 @@ function parse(input, E, code) {
   var cte = (header("content-transfer-encoding") || "").trim().toLowerCase() || "7bit";
   return {
     headers: headers, header: header,
-    contentType: ctv != null ? _parseStructured(ctv) : { value: "text/plain", type: "text/plain", params: {} },
+    contentType: ctv != null ? _parseStructured(ctv) : { value: "text/plain", type: "text/plain", params: Object.create(null) },
     cte: cte,
     headerBytes: headerBytes, bodyBytes: bodyBytes, body: bodyBytes, bytes: bytes,
   };

package/lib/ocsp-verify.js

@@ -12,7 +12,7 @@ var compositeSig = require("./composite-sig");
 var webcrypto = require("./webcrypto");
 var subtle = webcrypto.webcrypto.subtle;
 
-var OCSP_CERTID_HASHES = {};
+var OCSP_CERTID_HASHES = intrinsic.create(null);
 OCSP_CERTID_HASHES[oid.byName("sha1")] = "SHA-1";
 OCSP_CERTID_HASHES[oid.byName("sha256")] = "SHA-256";
 OCSP_CERTID_HASHES[oid.byName("sha384")] = "SHA-384";

package/lib/ocsp.js

@@ -139,9 +139,9 @@ function buildRequest(query, opts) {
   ], _buildRequest);
 }
 
-var _BUILD_REQUEST_OPTS = {
+var _BUILD_REQUEST_OPTS = Object.assign(Object.create(null), {
   hashAlgorithm: 1, nonce: 1, pem: 1, profile: 1, requestorName: 1, signer: 1
-};
+});
 
 function _buildRequest(query, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "ocsp/bad-input", "pki.ocsp.buildRequest options");
@@ -250,7 +250,7 @@ function sign(responseData, responder, opts) {
   ], _sign);
 }
 
-var _SIGN_OPTS = { embedCert: 1, extendedRevoke: 1, nonce: 1, pem: 1 };
+var _SIGN_OPTS = Object.assign(Object.create(null), { embedCert: 1, extendedRevoke: 1, nonce: 1, pem: 1 });
 
 function _sign(responseData, responder, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "ocsp/bad-input", "pki.ocsp.sign options");
@@ -425,7 +425,7 @@ function buildErrorResponse(status) {
  *   var res = await pki.ocsp.verify(responseDer, { cert: leafDer, issuer: caDer });
  *   res.status;   // "good" | "revoked" | "unknown"
  */
-var _VERIFY_OPTS = { cert: 1, historicalMode: 1, issuer: 1, requestNonce: 1, time: 1 };
+var _VERIFY_OPTS = Object.assign(Object.create(null), { cert: 1, historicalMode: 1, issuer: 1, requestNonce: 1, time: 1 });
 
 function verify(response, opts) {
   try {
@@ -465,7 +465,7 @@ function _responseNonce(parsed) {
   return null;
 }
 
-var _VERIFY_REQUEST_OPTS = { certs: 1 };
+var _VERIFY_REQUEST_OPTS = Object.assign(Object.create(null), { certs: 1 });
 function _requestFromBytes(request) {
   if (guard.bytes.isByteSource(request)) request = guard.bytes.snapshotSource(request, OcspError, "ocsp/bad-input", "the OCSP request");
   return ocspSchema.parseRequest(request);

package/lib/oid.js

@@ -42,7 +42,7 @@ var OidError = frameworkError.OidError;
 
 function _oidError(c, m) { return new OidError(c, m); }
 
-var FAMILIES = {
+var FAMILIES = Object.assign(Object.create(null), {
   attributeType: { base: [2, 5, 4], of: {
     commonName: 3, surname: 4, serialNumber: 5, countryName: 6,
     localityName: 7, stateOrProvinceName: 8, streetAddress: 9,
@@ -335,7 +335,7 @@ var FAMILIES = {
     scepMessageType: 2, scepPkiStatus: 3, scepFailInfo: 4,
     scepSenderNonce: 5, scepRecipientNonce: 6, scepTransactionId: 7 } },
   scep: { base: [1, 3, 6, 1, 5, 5, 7, 24], of: { scepFailInfoText: 1 } },
-};
+});
 
 var _byOid = new Map();
 var _byName = new Map();
@@ -483,7 +483,7 @@ function registerFamily(base, members) {
 }
 
 function all() {
-  var out = {};
+  var out = Object.create(null);
   _byOid.forEach(function (v, k) { out[k] = v; });
   return out;
 }

package/lib/path-validate.js

@@ -80,7 +80,7 @@ var ANCHOR_SPKI_SCHEMA = pkix.spki(NS);
 
 var subtle = webcrypto.webcrypto.subtle;
 
-var OID = {
+var OID = intrinsic.assign(intrinsic.create(null), {
   basicConstraints: oid.byName("basicConstraints"),
   keyUsage: oid.byName("keyUsage"),
   nameConstraints: oid.byName("nameConstraints"),
@@ -98,9 +98,9 @@ var OID = {
   authorityKeyIdentifier: oid.byName("authorityKeyIdentifier"),
   authorityInfoAccess: oid.byName("authorityInfoAccess"),
   caIssuers: oid.byName("caIssuers"),
-};
+});
 
-var PROCESSED_EXTENSIONS = {};
+var PROCESSED_EXTENSIONS = intrinsic.create(null);
 [OID.basicConstraints, OID.keyUsage, OID.nameConstraints, OID.certificatePolicies,
  OID.policyMappings, OID.policyConstraints, OID.inhibitAnyPolicy, OID.subjectAltName,
  OID.extKeyUsage, OID.cRLDistributionPoints].
@@ -137,7 +137,7 @@ _sig("id-ml-dsa-87", { name: "ML-DSA-87" }, { name: "ML-DSA-87" }, "absent", fal
 
 var OID_RSA_PSS = oid.byName("rsassaPss");
 var OID_MGF1 = oid.byName("mgf1");
-var HASH_BY_OID = {};
+var HASH_BY_OID = intrinsic.create(null);
 HASH_BY_OID[oid.byName("sha256")] = "SHA-256";
 HASH_BY_OID[oid.byName("sha384")] = "SHA-384";
 HASH_BY_OID[oid.byName("sha512")] = "SHA-512";
@@ -244,7 +244,7 @@ function compositeKeyUsageCheck(cert) {
   return { ok: true };
 }
 
-var ML_KEM_OIDS = {};
+var ML_KEM_OIDS = intrinsic.create(null);
 ["id-ml-kem-512", "id-ml-kem-768", "id-ml-kem-1024"].forEach(function (n) { ML_KEM_OIDS[oid.byName(n)] = true; });
 
 function kemKeyUsageCheck(cert) {
@@ -323,12 +323,7 @@ function requireCriticalExt(ext, name, checks) {
 }
 
 
-function splitMailbox(addr) {
-  var first = addr.indexOf("@");
-  if (first === -1) return null;
-  if (first !== addr.lastIndexOf("@")) return "ambiguous";
-  return [addr.slice(0, first), addr.slice(first + 1)];
-}
+var splitMailbox = guard.name.splitMailbox;
 
 function emailMatch(constraint, mailbox) {
   var mb = splitMailbox(mailbox);
@@ -346,7 +341,7 @@ function emailMatch(constraint, mailbox) {
   return host === c;
 }
 
-function stripTrailingDot(s) { return s.charAt(s.length - 1) === "." ? s.slice(0, -1) : s; }
+var stripTrailingDot = guard.name.stripTrailingDot;
 
 function hostConstraintMatch(constraint, host) {
   var c = stripTrailingDot(constraint.toLowerCase()), h = stripTrailingDot(host.toLowerCase());
@@ -356,13 +351,6 @@ function hostConstraintMatch(constraint, host) {
 }
 
 function _charTable(chars) { var t = []; for (var i = 0; i < chars.length; i++) t[_charCodeAt(chars, i)] = true; return t; }
-var _FQDN_TABLE = _charTable("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-");
-var _DIGDOT_TABLE = _charTable("0123456789.");
-function _allCharsIn(s, table) {
-  if (s.length === 0) return false;
-  for (var i = 0; i < s.length; i++) if (!table[_charCodeAt(s, i)]) return false;
-  return true;
-}
 function _startsWithDigit(s) { if (s.length === 0) return false; var c = _charCodeAt(s, 0); return c >= 48 && c <= 57; }
 
 var _SCHEME_TABLE = _charTable("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+.-");
@@ -389,13 +377,7 @@ function _stripBrackets(s) {
   return (n >= 2 && _charCodeAt(s, 0) === 91 && _charCodeAt(s, n - 1) === 93) ? s.slice(1, n - 1) : s;
 }
 
-function isFqdnHost(host) {
-  var h = stripTrailingDot(host);
-  if (h === "" || h.indexOf(".") === -1) return false;
-  if (!_allCharsIn(h, _FQDN_TABLE)) return false;
-  if (_allCharsIn(h, _DIGDOT_TABLE)) return false;
-  return true;
-}
+var isFqdnHost = guard.name.isFqdnHost;
 
 function uriMatch(constraint, uri) {
   var host = uriHost(uri);
@@ -544,7 +526,7 @@ function treeIsEmpty(tree) { return tree.children.length === 0; }
 
 function isSubtreeBaseValid(tag, base) {
   switch (tag) {
-    case 1: case 2: case 6: return typeof base === "string";
+    case 1: case 2: case 6: return guard.name.constraintBaseRefusal(tag, base) === null;
     case 7: return Buffer.isBuffer(base) && (base.length === 8 || base.length === 32);
     case 4: return base !== null && typeof base === "object" && !!base.rdns && intrinsic.isArray(base.rdns);
     default: return base !== undefined;
@@ -806,7 +788,7 @@ function prepareNext(state, cert, i, checks) {
 function applyPolicyMappings(state, mappings, i) {
   var depth = i;
   if (state.policyMapping > 0) {
-    var mappedFrom = {};
+    var mappedFrom = intrinsic.create(null);
     mappings.forEach(function (m) { guard.list.append(mappedFrom[m.issuerDomainPolicy] = mappedFrom[m.issuerDomainPolicy] || [], m.subjectDomainPolicy); });
     var depthI = leavesAt(state.validPolicyTree, depth);
     var anyNodes = depthI.filter(function (nd) { return nd.validPolicy === OID.anyPolicy; });
@@ -821,7 +803,7 @@ function applyPolicyMappings(state, mappings, i) {
       }
     });
   } else {
-    var mappedSet = {};
+    var mappedSet = intrinsic.create(null);
     mappings.forEach(function (m) { mappedSet[m.issuerDomainPolicy] = true; });
     if (!state.validPolicyTree) return;
     leavesAt(state.validPolicyTree, depth).forEach(function (node) {
@@ -835,7 +817,7 @@ function applyPolicyMappings(state, mappings, i) {
   }
 }
 
-var TARGET_UNPROCESSED_IF_CRITICAL = {};
+var TARGET_UNPROCESSED_IF_CRITICAL = intrinsic.create(null);
 TARGET_UNPROCESSED_IF_CRITICAL[OID.policyMappings] = true;
 Object.freeze(TARGET_UNPROCESSED_IF_CRITICAL);
 
@@ -923,7 +905,13 @@ function validateCriticalExtensionStructure(cert) {
  * intermediate's own `nameConstraints` extension intersects with them and a leaf
  * must satisfy both. They are a separate generation from
  * `opts.initialPermittedSubtrees`, so those two intersect as well. A mis-shaped
- * subtree is refused with `path/bad-input` rather than left inert.
+ * subtree is refused with `path/bad-input` rather than left inert, and so is one
+ * whose base is outside the form its tag names: a host name for tags 2 and 6, a
+ * mailbox or host name for tag 1, at least one relative name with object
+ * identifier types and string values for tag 4, and 8 or 32 bytes for tag 7. An
+ * anchor whose `nameConstraints` names no subtree at all is refused the same way.
+ * A certificate's own `nameConstraints` extension is compared as the certificate
+ * wrote it; this rule is on the subtrees a caller supplies.
  *
  * @example
  *   var pair = await pki.key.generate("Ed25519");
@@ -939,13 +927,13 @@ function validateCriticalExtensionStructure(cert) {
  *   });
  *   res.valid;  // boolean; res.results[0].checks carries the per-check codes
  */
-var _VALIDATE_OPTS = {
+var _VALIDATE_OPTS = intrinsic.assign(intrinsic.create(null), {
   checkPurpose: 1, ctLogList: 1, ctPolicy: 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, trustAnchors: 1,
   userInitialPolicySet: 1, verifier: 1
-};
+});
 
 var OID_SCT_LIST = oid.byName("signedCertificateTimestampList");
 async function ctGateCheck(leaf, certs, anchor, ctLogList, ctPolicy, n, at) {
@@ -1015,7 +1003,7 @@ async function validate(path, opts) {
     var exclRawOnce = opts.initialExcludedSubtrees;
     var singleOpts = function (a) {
       var keys = intrinsic.ownKeys(opts);
-      var o = {};
+      var o = intrinsic.create(null);
       for (var ki = 0; ki < keys.length; ki++) { o[keys[ki]] = opts[keys[ki]]; }
       o.trustAnchors = a;
       if (permRawOnce != null) o.initialPermittedSubtrees = callerPermitted;
@@ -1248,12 +1236,12 @@ function userConstrainedPolicies(state, n) {
   var uips = state.userInitialPolicySet;
   var anyUser = contains(uips, OID.anyPolicy);
   var leaves = leavesAt(state.validPolicyTree, n);
-  var explicit = {}, hasAnyLeaf = false;
+  var explicit = intrinsic.create(null), hasAnyLeaf = false;
   leaves.forEach(function (node) {
     if (node.validPolicy === OID.anyPolicy) hasAnyLeaf = true;
     else explicit[node.validPolicy] = true;
   });
-  var set = {};
+  var set = intrinsic.create(null);
   Object.keys(explicit).forEach(function (p) { if (anyUser || contains(uips, p)) set[p] = true; });
   if (hasAnyLeaf) {
     if (anyUser) set[OID.anyPolicy] = true;
@@ -1941,7 +1929,7 @@ function resolvePurposeOpts(opts) {
 }
 
 function _snapshotConstraintMap(m, E, code, who) {
-  var out = {};
+  var out = intrinsic.create(null);
   var proto = intrinsic.getPrototypeOf(m);
   if (proto !== null && proto !== intrinsic.ObjectProto) throw E(code, who + ": a trustAnchor constraint map must be a plain object (its own entries only), not one with a custom or cross-realm prototype");
   var keys = intrinsic.getOwnPropertyNames(m);
@@ -1996,82 +1984,8 @@ var _ATV_KEYS = ["type", "value", "name"];
  * and nothing deeper, so exactly those levels are walked and a self-referencing array is refused
  * rather than followed.
  */
-function _copyDnRdns(rdns, who) {
-  _assertPlainDnRdns(rdns, who);
-  var out = [];
-  for (var i = 0; i < rdns.length; i++) {
-    var rd = intrinsic.getOwnPropertyDescriptor(rdns, i);
-    if (rd === undefined) throw E("path/bad-input", who + " index " + i + " is a hole or is inherited; every entry must be its own");
-    var rdn = rd.value;
-    if (!intrinsic.isArray(rdn)) throw E("path/bad-input", who + "[" + i + "] must be an array of attributes");
-    var rdnOut = [];
-    for (var j = 0; j < rdn.length; j++) {
-      var ad = intrinsic.getOwnPropertyDescriptor(rdn, j);
-      if (ad === undefined) throw E("path/bad-input", who + "[" + i + "] index " + j + " is a hole or is inherited; every entry must be its own");
-      var atv = ad.value;
-      if (atv === null || typeof atv !== "object") throw E("path/bad-input", who + "[" + i + "][" + j + "] must be an attribute object carrying a type and a value");
-      var atvOut = {};
-      for (var k = 0; k < _ATV_KEYS.length; k++) {
-        var fd = intrinsic.getOwnPropertyDescriptor(atv, _ATV_KEYS[k]);
-        if (fd === undefined) continue;
-        intrinsic.defineProperty(atvOut, _ATV_KEYS[k], { value: fd.value, enumerable: true, configurable: true, writable: true });
-      }
-      if (!intrinsic.hasOwn(atvOut, "type") || !intrinsic.hasOwn(atvOut, "value")) {
-        throw E("path/bad-input", who + "[" + i + "][" + j + "] must carry its type and value as own data properties");
-      }
-      guard.list.append(rdnOut, atvOut);
-    }
-    guard.list.append(out, rdnOut);
-  }
-  return out;
-}
-/**
- * @internal The shape check the copy above relies on: a Proxy answers its own reads and an accessor
- * runs caller code, so either one at any level of the directoryName is refused before it is copied.
- */
-function _assertPlainDnRdns(rdns, who) {
-  if (intrinsic.types.isProxy(rdns)) throw E("path/bad-input", who + " must be a plain array, not a Proxy");
-  for (var i = 0; i < rdns.length; i++) {
-    var rd = intrinsic.getOwnPropertyDescriptor(rdns, i);
-    if (rd === undefined) continue;
-    if (!intrinsic.hasOwn(rd, "value")) throw E("path/bad-input", who + " entry " + i + " must be a data property, not an accessor");
-    var rdn = rd.value;
-    if (!intrinsic.isArray(rdn)) continue;
-    if (intrinsic.types.isProxy(rdn)) throw E("path/bad-input", who + "[" + i + "] must be a plain array, not a Proxy");
-    for (var j = 0; j < rdn.length; j++) {
-      var ad = intrinsic.getOwnPropertyDescriptor(rdn, j);
-      if (ad === undefined) continue;
-      if (!intrinsic.hasOwn(ad, "value")) throw E("path/bad-input", who + "[" + i + "] entry " + j + " must be a data property, not an accessor");
-      var atv = ad.value;
-      if (atv === null || typeof atv !== "object") continue;
-      if (intrinsic.types.isProxy(atv)) throw E("path/bad-input", who + "[" + i + "][" + j + "] must not be a Proxy");
-      if (intrinsic.isArray(atv)) throw E("path/bad-input", who + "[" + i + "][" + j + "] must be an attribute object, not an array");
-      for (var k = 0; k < _ATV_KEYS.length; k++) {
-        var fd = intrinsic.getOwnPropertyDescriptor(atv, _ATV_KEYS[k]);
-        if (fd !== undefined && !intrinsic.hasOwn(fd, "value")) {
-          throw E("path/bad-input", who + "[" + i + "][" + j + "]." + _ATV_KEYS[k] + " must be a data property, not an accessor");
-        }
-      }
-    }
-  }
-}
 function _capturedRdns(base, who) {
-  if (intrinsic.types.isProxy(base)) throw E("path/bad-input", who + ": a trustAnchor nameConstraints directoryName base must not be a Proxy");
-  /** @internal An inherited Proxy answers `in` through its has trap, which is caller code running
-   * inside what is meant to be a getter-free read. */
-  var baseProto = intrinsic.getPrototypeOf(base);
-  while (baseProto !== null) {
-    if (intrinsic.types.isProxy(baseProto)) throw E("path/bad-input", who + ": a trustAnchor nameConstraints directoryName base must not inherit from a Proxy");
-    baseProto = intrinsic.getPrototypeOf(baseProto);
-  }
-  var d = intrinsic.getOwnPropertyDescriptor(base, "rdns");
-  if (d === undefined) {
-    if ("rdns" in base) throw E("path/bad-input", who + ": a trustAnchor nameConstraints directoryName rdns must be an own data property, not inherited");
-    return undefined;
-  }
-  if (!intrinsic.hasOwn(d, "value")) throw E("path/bad-input", who + ": a trustAnchor nameConstraints directoryName rdns must be a data property, not an accessor");
-  if (!intrinsic.isArray(d.value)) return undefined;
-  return _copyDnRdns(d.value, who + ": a trustAnchor nameConstraints directoryName rdns");
+  return guard.name.capturedRdns(base, E, "path/bad-input", who + ": a trustAnchor nameConstraints directoryName base");
 }
 var _NC_SUBTREE_KEYS = ["tag", "base"];
 var _NC_LIST_KEYS = ["permitted", "excluded"];
@@ -2168,6 +2082,12 @@ function _copyAnchorNameConstraints(nc, who) {
     var checkedList = checkedSubtreeSeeds(copiedList, "trustAnchors[].nameConstraints." + key);
     intrinsic.defineProperty(out, key, { value: checkedList, enumerable: true, configurable: true, writable: true });
   }
+  /** @internal An anchor carrying the option but naming no subtree restricts nothing, and reads to
+   * whoever built it as a namespace that has been applied. */
+  if ((out.permitted === undefined || out.permitted.length === 0) &&
+      (out.excluded === undefined || out.excluded.length === 0)) {
+    throw E("path/bad-input", who + ": a trustAnchor nameConstraints must name at least one permitted or excluded subtree");
+  }
   return out;
 }
 
@@ -2468,7 +2388,9 @@ function _aiaParseBody(body, contentType, maxCerts) {
 }
 
 async function _aiaFetchOne(uri, aia) {
-  var res = await aia.transport({ method: "GET", url: uri, tls: aia.tls, timeout: aia.timeout, maxResponseBytes: aia.maxResponseBytes, blockPrivateAddresses: true });
+  var res = await guard.async.invoked(aia.transport,
+    [{ method: "GET", url: uri, tls: aia.tls, timeout: aia.timeout, maxResponseBytes: aia.maxResponseBytes, blockPrivateAddresses: true }],
+    E, "path/bad-input", "opts.transport");
   res = res || {};
   if (res.status !== 200) throw E("path/aia-status", "an AIA fetch returned HTTP " + res.status + " (only 200 is a cert source; no redirect following)");
   var body = guard.bytes.isByteSource(res.body)
@@ -2476,7 +2398,7 @@ async function _aiaFetchOne(uri, aia) {
     : Buffer.from(res.body == null ? "" : String(res.body), "latin1");
   if (body.length === 0) throw E("path/aia-empty", "an AIA fetch returned an empty body");
   if (body.length > aia.maxResponseBytes) throw E("path/aia-too-large", "an AIA response exceeds the " + aia.maxResponseBytes + "-byte cap");
-  var headers = {};
+  var headers = intrinsic.create(null);
   Object.keys(res.headers || {}).forEach(function (k) { headers[k.toLowerCase()] = res.headers[k]; });
   return _aiaParseBody(body, headers["content-type"], aia.maxCertsPerResponse);
 }
@@ -2509,6 +2431,11 @@ async function _fetchAiaIssuers(current, aia) {
     intrinsic.setAdd(aia.fetchedUrls, uris[k]);
     aia.fetches += 1;
     var certs;
+    /** @internal Every failure of a fetch is skipped and the next URL tried, because AIA is a
+     * best-effort source of issuers and one unreachable host must not fail a build that another URL
+     * can complete. A transport that throws where a rejecting one would only reject is the same
+     * failure reported a different way, so the two are treated alike rather than one of them ending
+     * the build. */
     try { certs = await _aiaFetchOne(uris[k], aia); }
     catch (_e2) { continue; }
     for (var c = 0; c < certs.length; c++) {
@@ -2591,11 +2518,11 @@ async function _fetchAiaIssuers(current, aia) {
  *   result.valid;                  // true when a path to a trust anchor was found and validated
  */
 var _BUILD_OPTS = (function () {
-  var o = {
+  var o = intrinsic.assign(intrinsic.create(null), {
     aiaTimeout: 1, candidates: 1, direction: 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; });
   return o;
 })();
@@ -2604,6 +2531,12 @@ async function build(leaf, opts) {
   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 anchor option is `trustAnchors`). The unknown option was: ");
+  /** @internal Checked at the door, before any certificate is parsed, and whether or not AIA
+   * fetching is on: supplying a transport that cannot be called is a wiring fault at the moment it
+   * is written. The checked value is the one used below, since reading the option again would ask a
+   * second time and an accessor can answer differently on each read. */
+  var checkedTransport = guard.identifier.assertCallableOption(opts, "transport", E, "path/bad-input",
+    "build: opts.transport", "(request) -> Promise<{ status, headers, body }>");
   var leafCert;
   try { leafCert = coerceCert(leaf); }
   catch (e) { throw E("path/bad-input", "build: the leaf certificate did not parse", e); }
@@ -2652,13 +2585,10 @@ async function build(leaf, opts) {
 
   var aiaCtx = null;
   if (opts.fetchAia === true) {
-    if (opts.transport !== undefined && typeof opts.transport !== "function") {
-      throw E("path/bad-input", "build: opts.transport must be a transport function (request) -> Promise<{ status, headers, body }>");
-    }
     if (opts.aiaTimeout !== undefined) {
       guard.limits.cap(opts.aiaTimeout, "build: opts.aiaTimeout", 1, { E: E, code: "path/bad-input", min: 1, max: httpTransport.MAX_TIMEOUT });
     }
-    var aiaTransport = opts.transport || httpTransport.https({ E: E, errPrefix: "path" });
+    var aiaTransport = checkedTransport || httpTransport.https({ E: E, errPrefix: "path" });
     aiaCtx = {
       transport: aiaTransport,
       transportGuardsAddresses: aiaTransport.blocksPrivateAddresses === true,