@blamejs/core 0.18.53 → 0.18.54

package/lib/vendor/blamejs-pki.cjs

@@ -1,4 +1,4 @@
-// @blamejs/pki v0.5.28 — vendored (Apache-2.0). Zero-dep pure CJS.
+// @blamejs/pki v0.5.30 — 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.28",
+      version: "0.5.30",
       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",
@@ -1957,6 +1957,41 @@ var require_oid = __commonJS({
       // The arc is RSA-dedicated, so a consumer can classify the whole family by its prefix; one member is
       // registered here so that prefix can be derived from the registry rather than a dotted-decimal literal.
       teletrustRsaSig: { base: [1, 3, 36, 3, 3, 1], of: { "rsaSignatureWithripemd160": 2 } },
+      // TeleTrusT (BSI) signatureScheme arc (1.3.36.3.4) -- the ISO/IEC 9796-2 RSA signatures giving message
+      // recovery (schemes 1/2/3: two deterministic, one randomized). ISO/IEC 9796-2 is titled "integer
+      // factorization based mechanisms", so EVERY scheme it defines is RSA and the standard has no non-RSA
+      // member; each node is registered so a consumer can name it -- e.g. the CMP keySpec RSA exclusion, which
+      // must recognize RSA wherever it is standardized. ISO/IEC 9796-2 assigns no algorithm OIDs of its own;
+      // this registrant tree is the de-facto registry. The .2 (deterministic) and .3 (randomized) sub-arcs are
+      // RSA-dedicated in full -- every descendant is RSA -- so a consumer prefix-matches each to catch a hash
+      // variant added later; the per-hash leaves are registered for readability. The `...Withrsa-even-exp`
+      // nodes (.2.1 / .3.1) are the even-public-exponent RSA variants the registrant marks "not used"; they are
+      // RSA (the registrant names them `sigS_ISO9796-2Withrsa_even-exp`), so the sub-arc prefix classifies them
+      // correctly, not wrongly. .1 is ISO/IEC 9796-1, also RSA, on the same arc. The PARENT node (.4) is generic
+      // "signatureScheme" and the sibling authentication arc (.5) is mixed (its .5.3 children are ECC), so
+      // neither is RSA-dedicated -- a consumer must not prefix-match the parent or .5.
+      teletrustSigScheme: { base: [1, 3, 36, 3, 4], of: {
+        "sigS-ISO9796-1": 1,
+        "sigS-ISO9796-1-DFUE": [1, 1],
+        "sigS-ISO9796-2": 2,
+        "sigS-ISO9796-2Withrsa-even-exp": [2, 1],
+        "sigS-ISO9796-2Withrsa": [2, 2],
+        "sigS-ISO9796-2Withrsa-sha1": [2, 2, 1],
+        "sigS-ISO9796-2Withrsa-ripemd160": [2, 2, 2],
+        "sigS-ISO9796-2Withrsa-sha224": [2, 2, 3],
+        "sigS-ISO9796-2Withrsa-sha256": [2, 2, 4],
+        "sigS-ISO9796-2Withrsa-sha384": [2, 2, 5],
+        "sigS-ISO9796-2Withrsa-sha512": [2, 2, 6],
+        "sigS-ISO9796-2rnd": 3,
+        "sigS-ISO9796-2rndWithrsa-even-exp": [3, 1],
+        "sigS-ISO9796-2rndWithrsa": [3, 2],
+        "sigS-ISO9796-2rndWithrsa-sha1": [3, 2, 1],
+        "sigS-ISO9796-2rndWithrsa-ripemd160": [3, 2, 2],
+        "sigS-ISO9796-2rndWithrsa-sha224": [3, 2, 3],
+        "sigS-ISO9796-2rndWithrsa-sha256": [3, 2, 4],
+        "sigS-ISO9796-2rndWithrsa-sha384": [3, 2, 5],
+        "sigS-ISO9796-2rndWithrsa-sha512": [3, 2, 6]
+      } },
       // X.509 directory encryptionAlgorithm arc (2.5.8.1). id-ea-rsa (.1) is the X.509 `rsa` public-key
       // identifier, distinct from PKCS#1 rsaEncryption. Registered so a consumer can name it -- e.g. the
       // CMP keySpec RSA exclusion, which must recognize RSA wherever it is standardized.
@@ -24151,7 +24186,14 @@ var require_cmp_session = __commonJS({
       crlUpdate: { name: "crlUpdate", requestOid: "crlStatusList", responseOid: "crls", value: "crlStatus", read: "readCrls" }
     });
     var KNOWN_REVOKE_KEYS = { certificate: 1, certDetails: 1, reason: 1 };
-    var RSA_ARCS = ["rsaEncryption", "rsaSignatureWithripemd160", "id-TA-RSA-v1-5-SHA-256"].map(function(n) {
+    var RSA_ARCS = [
+      "rsaEncryption",
+      "rsaSignatureWithripemd160",
+      "id-TA-RSA-v1-5-SHA-256",
+      "sigS-ISO9796-1-DFUE",
+      "sigS-ISO9796-2Withrsa",
+      "sigS-ISO9796-2rndWithrsa"
+    ].map(function(n) {
       return oid.toArcs(oid.byName(n)).slice(0, -1);
     });
     var RSA_OFF_ARC = /* @__PURE__ */ Object.create(null);
@@ -24179,8 +24221,13 @@ var require_cmp_session = __commonJS({
       "sqMod-nWithRSA",
       "mdc2WithRSA",
       // the X.500 directory signatureAlgorithm RSA OIDs (2.5.8.3.1, 2.5.8.3.100)
-      "sm3WithRSAEncryption"
+      "sm3WithRSAEncryption",
       // the Chinese GM/T RSA-with-SM3 signature (1.2.156.10197.1.504)
+      // The TeleTrusT signatureScheme (ISO/IEC 9796-2) sub-arcs are prefix-matched in RSA_ARCS, but the strict-
+      // descendant match skips each arc NODE itself, so the three bare nodes are named here (1.3.36.3.4.1/.2/.3).
+      "sigS-ISO9796-1",
+      "sigS-ISO9796-2",
+      "sigS-ISO9796-2rnd"
     ].forEach(function(n) {
       var d = oid.byName(n);
       if (d) RSA_OFF_ARC[d] = 1;
@@ -25298,6 +25345,7 @@ var require_path_validate = __commonJS({
     }
     var NS = pkix.makeNS("path", PathError, oid);
     var EXT_DECODERS = pkix.certExtensionDecoders(NS).byOid;
+    var ANCHOR_SPKI_SCHEMA = pkix.spki(NS);
     var subtle = webcrypto.webcrypto.subtle;
     var OID = {
       basicConstraints: oid.byName("basicConstraints"),
@@ -25781,7 +25829,7 @@ var require_path_validate = __commonJS({
         return { tag: st.tag, base: st.base };
       });
     }
-    function initialize(certs, params, seeds) {
+    function initialize(certs, params, seeds, anchor) {
       var n = certs.length;
       return {
         validPolicyTree: rootNode(),
@@ -25794,10 +25842,10 @@ var require_path_validate = __commonJS({
         explicitPolicy: params.initialExplicitPolicy ? 0 : n + 1,
         inhibitAnyPolicy: params.initialAnyPolicyInhibit ? 0 : n + 1,
         policyMapping: params.initialPolicyMappingInhibit ? 0 : n + 1,
-        workingPublicKeyAlgorithm: params.trustAnchor.algorithm,
-        workingPublicKey: params.trustAnchor.publicKey,
-        workingPublicKeyParameters: params.trustAnchor.parameters || null,
-        workingIssuerName: params.trustAnchor.name,
+        workingPublicKeyAlgorithm: anchor.algorithm,
+        workingPublicKey: anchor.publicKey,
+        workingPublicKeyParameters: anchor.parameters || null,
+        workingIssuerName: anchor.name,
         maxPathLength: n,
         userInitialPolicySet: params.userInitialPolicySet || [OID.anyPolicy],
         results: []
@@ -26110,6 +26158,7 @@ var require_path_validate = __commonJS({
       var n = certs.length;
       if (n < 1) throw E("path/empty-path", "validate: the certification path is empty");
       if (!opts.trustAnchor) throw E("path/bad-input", "validate: a trustAnchor is required");
+      var anchor = toAnchor(opts.trustAnchor, "validate");
       guard.time.assertValid(opts.time, E, "path/bad-input", "validate: opts.time (the always-on validity-window check date)");
       guard.limits.cap(opts.maxPolicyNodes, "validate: opts.maxPolicyNodes", void 0, { E, code: "path/bad-input", min: 1 });
       if (opts.userInitialPolicySet !== void 0) {
@@ -26128,7 +26177,7 @@ var require_path_validate = __commonJS({
       var purposeOpts = resolvePurposeOpts(opts);
       var requiredEku = purposeOpts.requiredEku;
       var checkPurpose = purposeOpts.checkPurpose;
-      var state = initialize(certs, opts, seeds);
+      var state = initialize(certs, opts, seeds, anchor);
       state._n = n;
       state.requiredEku = requiredEku;
       var verifier = opts.verifier || null;
@@ -26138,7 +26187,7 @@ var require_path_validate = __commonJS({
       var failed = false;
       var revocationRan = false, revocationWaived = false, revocationUndetermined = false;
       var anchorDistrustApplied = false, anchorPurposeApplied = false;
-      if (!checkPurpose && opts.trustAnchor && _hasPurposeScopedMetadata(opts.trustAnchor)) {
+      if (!checkPurpose && _hasPurposeScopedMetadata(anchor)) {
         throw E("path/bad-input", "validate: the trust anchor carries purpose-scoped metadata (distrustAfter / purposes), which is keyed by key purpose -- supply opts.checkPurpose to say which purpose this validation is for, or the constraint cannot be applied");
       }
       for (var idx = 0; idx < n; idx++) {
@@ -26295,7 +26344,7 @@ var require_path_validate = __commonJS({
           }
           if (requireCriticalExt(liap, "inhibitAnyPolicy", checks)) failed = true;
           if (requiredEku && ekuPurposeFails(cert, requiredEku, checks)) failed = true;
-          var ta = opts.trustAnchor;
+          var ta = anchor;
           var distrustDate = assertAnchorConstraints(ta, checkPurpose);
           if (distrustDate != null) {
             anchorDistrustApplied = true;
@@ -26936,11 +26985,13 @@ var require_path_validate = __commonJS({
       if (!ta || typeof ta !== "object") return false;
       return guard.list.anyMatches(["distrustAfter", "purposes"], function(k) {
         var m = ta[k];
-        return !!m && typeof m === "object" && Object.keys(m).length > 0;
+        return !!m && typeof m === "object" && intrinsic.getOwnPropertyNames(m).length > 0;
       });
     }
     function assertAnchorConstraints(ta, checkPurpose) {
-      var d = checkPurpose && ta && ta.distrustAfter && intrinsic.hasOwn(ta.distrustAfter, checkPurpose) ? ta.distrustAfter[checkPurpose] : null;
+      if (!checkPurpose || !ta) return null;
+      var da = ta.distrustAfter;
+      var d = da && intrinsic.hasOwn(da, checkPurpose) ? da[checkPurpose] : null;
       if (d == null) return null;
       return guard.time.assertValid(d, E, "path/bad-input", "trustAnchor.distrustAfter." + checkPurpose);
     }
@@ -26973,22 +27024,191 @@ var require_path_validate = __commonJS({
       }
       return { requiredEku, checkPurpose };
     }
-    function toAnchor(entry) {
-      if (entry && typeof entry === "object" && !Buffer.isBuffer(entry) && entry.name && entry.publicKey && entry.algorithm) {
-        if (!intrinsic.isArray(entry.name.rdns) || !Buffer.isBuffer(entry.publicKey) || typeof entry.algorithm !== "string") {
-          throw E("path/bad-input", "build: a trustAnchor tuple must be { name: { rdns: [...] }, publicKey: Buffer, algorithm: OID string }");
+    function _snapshotConstraintMap(m, E2, code, who) {
+      var out = {};
+      var proto = intrinsic.getPrototypeOf(m);
+      if (proto !== null && proto !== intrinsic.ObjectProto) throw E2(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);
+      if (intrinsic.ownKeys(m).length !== keys.length) throw E2(code, who + ": a trustAnchor constraint map must not have symbol-keyed entries");
+      for (var i = 0; i < keys.length; i++) {
+        if (keys[i] === "__proto__") throw E2(code, who + ": a trustAnchor constraint map must not have an own __proto__ entry");
+        var d = intrinsic.getOwnPropertyDescriptor(m, keys[i]);
+        if (!d || !intrinsic.hasOwn(d, "value")) throw E2(code, who + ": a trustAnchor constraint-map entry must be a data property, not an accessor");
+        var v = d.value;
+        if (intrinsic.types.isDate(v)) v = new intrinsic.Date(guard.time.instantOf(v));
+        intrinsic.defineProperty(out, keys[i], { value: v, enumerable: true, configurable: true, writable: true });
+      }
+      return out;
+    }
+    function _normalizeConstraintField(v, E2, code, who) {
+      if (v === null || v === void 0) return v;
+      if (typeof v !== "object" || intrinsic.isBuffer(v)) throw E2(code, who + ": a trustAnchor constraint map must be a plain object");
+      return _snapshotConstraintMap(v, E2, code, who);
+    }
+    function _captureConstraintMap(entry, key, E2, code, who) {
+      var d = intrinsic.getOwnPropertyDescriptor(entry, key);
+      if (d === void 0) {
+        if (key in entry) throw E2(code, who + ": a trustAnchor " + key + " must be an own data property, not inherited");
+        return void 0;
+      }
+      if (!intrinsic.hasOwn(d, "value")) throw E2(code, who + ": a trustAnchor " + key + " must be a data property, not an accessor");
+      if (intrinsic.types.isProxy(d.value)) throw E2(code, who + ": a trustAnchor " + key + " map must not be a Proxy");
+      return d.value;
+    }
+    function _captureOwnData(entry, key) {
+      var d = intrinsic.getOwnPropertyDescriptor(entry, key);
+      return d && intrinsic.hasOwn(d, "value") ? d.value : void 0;
+    }
+    function _copyAtv(atv) {
+      var out = {};
+      var t = atv.type;
+      if (t !== void 0) intrinsic.defineProperty(out, "type", { value: t, enumerable: true, configurable: true, writable: true });
+      var v = atv.value;
+      if (v !== void 0) intrinsic.defineProperty(out, "value", { value: v, enumerable: true, configurable: true, writable: true });
+      var nm = atv.name;
+      if (nm !== void 0) intrinsic.defineProperty(out, "name", { value: nm, enumerable: true, configurable: true, writable: true });
+      return out;
+    }
+    function _copyRdnsDeep(rdns) {
+      if (!intrinsic.isArray(rdns)) return rdns;
+      var out = [];
+      out.length = rdns.length;
+      for (var i = 0; i < rdns.length; i++) {
+        if (!intrinsic.hasOwn(rdns, i)) continue;
+        var rdn = rdns[i], val;
+        if (intrinsic.isArray(rdn)) {
+          var rdnOut = [];
+          rdnOut.length = rdn.length;
+          for (var j = 0; j < rdn.length; j++) {
+            if (!intrinsic.hasOwn(rdn, j)) continue;
+            var atv = rdn[j] !== null && typeof rdn[j] === "object" ? _copyAtv(rdn[j]) : rdn[j];
+            intrinsic.defineProperty(rdnOut, j, { value: atv, enumerable: true, configurable: true, writable: true });
+          }
+          val = rdnOut;
+        } else {
+          val = rdn;
+        }
+        intrinsic.defineProperty(out, i, { value: val, enumerable: true, configurable: true, writable: true });
+      }
+      return out;
+    }
+    function toAnchor(entry, verb) {
+      var who = verb || "build";
+      var isTuple = false, alg = null, pubRaw = null, nameRaw = null, pk = null, purposesSnap, distrustSnap;
+      var subjectDerRaw, labelRaw, mozRaw;
+      if (intrinsic.types.isProxy(entry)) {
+        throw E("path/bad-input", who + ": a trustAnchor must not be a Proxy");
+      }
+      if (entry !== null && typeof entry === "object") {
+        var proto = intrinsic.getPrototypeOf(entry);
+        while (proto !== null) {
+          if (intrinsic.types.isProxy(proto)) throw E("path/bad-input", who + ": a trustAnchor must not inherit from a Proxy");
+          proto = intrinsic.getPrototypeOf(proto);
+        }
+      }
+      try {
+        if (entry && typeof entry === "object" && !Buffer.isBuffer(entry) && !guard.parsed.isRecorded(entry)) {
+          var pRaw = _captureConstraintMap(entry, "purposes", E, "path/bad-input", who);
+          purposesSnap = _normalizeConstraintField(pRaw, E, "path/bad-input", who);
+          var dRaw = _captureConstraintMap(entry, "distrustAfter", E, "path/bad-input", who);
+          distrustSnap = _normalizeConstraintField(dRaw, E, "path/bad-input", who);
+          subjectDerRaw = _captureOwnData(entry, "subjectDer");
+          labelRaw = _captureOwnData(entry, "label");
+          mozRaw = _captureOwnData(entry, "mozillaCaPolicy");
+          pubRaw = entry.publicKey;
+          if (guard.bytes.isByteSource(pubRaw)) {
+            pk = guard.bytes.snapshot(pubRaw, PathError, "path/bad-input", who + ": trustAnchor publicKey");
+          }
+          nameRaw = entry.name;
+          alg = entry.algorithm;
+          isTuple = !!(nameRaw && pubRaw && alg);
         }
-        return entry;
+      } catch (e) {
+        throw E("path/bad-input", who + ": a trustAnchor accessor threw", e);
+      }
+      if (isTuple) {
+        var algStr;
+        try {
+          if (typeof alg === "string") {
+            algStr = alg;
+          } else if (alg !== null && typeof alg === "object") {
+            if (intrinsic.types.isProxy(alg)) throw E("path/bad-input", who + ": a trustAnchor algorithm must not be a Proxy");
+            var algOidD = intrinsic.getOwnPropertyDescriptor(alg, "oid");
+            if (algOidD && !intrinsic.hasOwn(algOidD, "value")) throw E("path/bad-input", who + ": a trustAnchor algorithm.oid must be a data property, not an accessor");
+            var algOid = algOidD ? algOidD.value : void 0;
+            algStr = typeof algOid === "string" ? algOid : null;
+          } else {
+            algStr = null;
+          }
+        } catch (e) {
+          throw E("path/bad-input", who + ": a trustAnchor algorithm.oid accessor threw", e);
+        }
+        var nameOut = {};
+        try {
+          var nsrc = nameRaw !== null && typeof nameRaw === "object" ? nameRaw : null;
+          if (nsrc !== null && intrinsic.types.isProxy(nsrc)) throw E("path/bad-input", who + ": a trustAnchor name must not be a Proxy");
+          var rdnsD = nsrc ? intrinsic.getOwnPropertyDescriptor(nsrc, "rdns") : void 0;
+          if (rdnsD && !intrinsic.hasOwn(rdnsD, "value")) throw E("path/bad-input", who + ": a trustAnchor name.rdns must be a data property, not an accessor");
+          var rdnsVal = rdnsD ? rdnsD.value : void 0;
+          if (rdnsVal !== void 0) {
+            intrinsic.defineProperty(nameOut, "rdns", { value: _copyRdnsDeep(rdnsVal), enumerable: true, configurable: true, writable: true });
+          }
+          var bytesD = nsrc ? intrinsic.getOwnPropertyDescriptor(nsrc, "bytes") : void 0;
+          if (bytesD && !intrinsic.hasOwn(bytesD, "value")) throw E("path/bad-input", who + ": a trustAnchor name.bytes must be a data property, not an accessor");
+          var nBytes = bytesD ? bytesD.value : void 0;
+          if (nBytes !== void 0) {
+            intrinsic.defineProperty(nameOut, "bytes", { value: nBytes, enumerable: true, configurable: true, writable: true });
+          }
+          var dnD = nsrc ? intrinsic.getOwnPropertyDescriptor(nsrc, "dn") : void 0;
+          if (dnD && !intrinsic.hasOwn(dnD, "value")) throw E("path/bad-input", who + ": a trustAnchor name.dn must be a data property, not an accessor");
+          var nDn = dnD ? dnD.value : void 0;
+          if (typeof nDn === "string") {
+            intrinsic.defineProperty(nameOut, "dn", { value: nDn, enumerable: true, configurable: true, writable: true });
+          }
+        } catch (e) {
+          throw E("path/bad-input", who + ": trustAnchor name could not be materialized", e);
+        }
+        var nameHasRdns = intrinsic.hasOwn(nameOut, "rdns") && intrinsic.isArray(nameOut.rdns);
+        if (!nameHasRdns || !Buffer.isBuffer(pubRaw) || algStr === null) {
+          throw E("path/bad-input", who + ": a trustAnchor tuple must be { name: { rdns: [...] }, publicKey: Buffer, algorithm: an OID string or a SubjectPublicKeyInfo algorithm carrying an oid }");
+        }
+        guard.identifier.assertCanonicalOid(algStr, E, "path/bad-input", who + ": trustAnchor algorithm " + algStr);
+        var spkiAlg;
+        try {
+          spkiAlg = schema.walk(ANCHOR_SPKI_SCHEMA, asn1.decode(pk), NS).result.algorithm;
+        } catch (e) {
+          throw E("path/bad-input", who + ": trustAnchor publicKey is not a valid SubjectPublicKeyInfo", e);
+        }
+        if (spkiAlg.oid !== algStr) {
+          throw E("path/bad-input", who + ": trustAnchor algorithm " + algStr + " does not match its publicKey key algorithm " + spkiAlg.oid);
+        }
+        var flat = {};
+        intrinsic.defineProperty(flat, "name", { value: nameOut, enumerable: true, configurable: true, writable: true });
+        if (purposesSnap !== void 0) intrinsic.defineProperty(flat, "purposes", { value: purposesSnap, enumerable: true, configurable: true, writable: true });
+        if (distrustSnap !== void 0) intrinsic.defineProperty(flat, "distrustAfter", { value: distrustSnap, enumerable: true, configurable: true, writable: true });
+        if (subjectDerRaw !== void 0) intrinsic.defineProperty(flat, "subjectDer", { value: subjectDerRaw, enumerable: true, configurable: true, writable: true });
+        if (labelRaw !== void 0) intrinsic.defineProperty(flat, "label", { value: labelRaw, enumerable: true, configurable: true, writable: true });
+        if (mozRaw !== void 0) intrinsic.defineProperty(flat, "mozillaCaPolicy", { value: mozRaw, enumerable: true, configurable: true, writable: true });
+        intrinsic.defineProperty(flat, "publicKey", { value: pk, enumerable: true, configurable: true, writable: true });
+        intrinsic.defineProperty(flat, "algorithm", { value: spkiAlg.oid, enumerable: true, configurable: true, writable: true });
+        intrinsic.defineProperty(flat, "parameters", { value: spkiAlg.parameters, enumerable: true, configurable: true, writable: true });
+        return flat;
+      }
+      if (entry && typeof entry === "object" && ("purposes" in entry || "distrustAfter" in entry)) {
+        throw E("path/bad-input", who + ": a trustAnchor certificate must not carry purposes / distrustAfter -- put per-purpose constraints on a { name, publicKey, algorithm, purposes, distrustAfter } tuple (or a pki.trust anchor), not on a parsed certificate");
       }
       var cert;
       try {
         cert = coerceCert(entry);
       } catch (e) {
-        throw E("path/bad-input", "build: a trustAnchor entry must be a { name, publicKey, algorithm } tuple or a certificate", e);
+        throw E("path/bad-input", who + ": a trustAnchor entry must be a { name, publicKey, algorithm } tuple or a certificate", e);
       }
       var spki = cert.subjectPublicKeyInfo;
       return { name: cert.subject, publicKey: spki.bytes, algorithm: spki.algorithm.oid, parameters: spki.algorithm.parameters, subjectDer: cert.subject.bytes };
     }
+    function anchorFromCert(cert) {
+      return toAnchor(cert, "anchorFromCert");
+    }
     function identityKey(cert) {
       var san = findExt(cert, OID.subjectAltName);
       return cert.subject.bytes.toString("hex") + "|" + (san ? san.value.toString("hex") : "") + "|" + cert.subjectPublicKeyInfo.bytes.toString("hex");
@@ -27170,7 +27390,9 @@ var require_path_validate = __commonJS({
       var poolDerKeys = /* @__PURE__ */ new Set();
       for (var pdk = 0; pdk < pool.length; pdk++) intrinsic.setAdd(poolDerKeys, certDerKey(pool[pdk]));
       if (!intrinsic.isArray(opts.trustAnchors) || opts.trustAnchors.length === 0) throw E("path/bad-input", "build: opts.trustAnchors must be a non-empty array of anchor tuples or root certificates");
-      var anchors = opts.trustAnchors.map(toAnchor);
+      var anchors = opts.trustAnchors.map(function(a) {
+        return toAnchor(a, "build");
+      });
       guard.time.assertValid(opts.time, E, "path/bad-input", "build: opts.time (the validity-window check date, forwarded to validate)");
       var effectiveMaxCerts = guard.limits.cap(opts.maxPathCerts, "build: opts.maxPathCerts", constants.LIMITS.PATH_MAX_CERTS, { E, code: "path/bad-input", min: 1 });
       var depthCeiling = effectiveMaxCerts - 1;
@@ -27325,6 +27547,7 @@ var require_path_validate = __commonJS({
     module2.exports = {
       validate,
       build,
+      anchorFromCert,
       crlChecker,
       ocspChecker,
       verifyOcspResponse,
@@ -37384,6 +37607,19 @@ var require_acme = __commonJS({
       sleep: 1,
       clock: 1
     };
+    var _METHOD_OPTS = {
+      finalize: { csr: 1, identifiers: 1 },
+      poll: { maxPolls: 1, maxTotalWait: 1, onRetryAfter: 1 },
+      download: { expectedSpki: 1, identifiers: 1, requireBinding: 1, selectChain: 1, maxAlternates: 1 },
+      revoke: { certAlg: 1, certJwk: 1, certKey: 1, certificate: 1, reason: 1 },
+      keyChange: { newAlg: 1, newJwk: 1, newKey: 1 },
+      renewalWindow: { random: 1, clock: 1, replaced: 1, previous: 1 }
+    };
+    function _gateOpts(bag, whitelist, name) {
+      bag = guard.identifier.optionsObject(bag, E, "acme/bad-input", "pki.acme " + name + " options");
+      guard.identifier.assertKnownKeys(bag, whitelist, E, "acme/bad-input", "unknown " + name + " option ");
+      return bag;
+    }
     function client(directoryUrl, opts) {
       opts = guard.identifier.optionsObject(opts, E, "acme/bad-input", "pki.acme.client options");
       guard.identifier.assertKnownKeys(opts, _CLIENT_OPTS, E, "acme/bad-input", "unknown pki.acme.client option ");
@@ -37638,7 +37874,7 @@ var require_acme = __commonJS({
         });
       }
       function _finalizeBody(order, o) {
-        o = o || {};
+        o = _gateOpts(o, _METHOD_OPTS.finalize, "finalize");
         if (!_isObject(order) || !_isString(order.finalize)) throw E("acme/bad-input", "finalize requires the order object with its finalize URL");
         if (!Array.isArray(order.identifiers)) throw E("acme/bad-input", "finalize requires the order's identifiers to enforce the RFC 8555 sec. 7.4 CSR-set match");
         return _post(_clientUrl(order.finalize), finalize, { csr: o.csr, identifiers: order.identifiers, accountJwk }, "kid").then(function(res) {
@@ -37646,9 +37882,9 @@ var require_acme = __commonJS({
         });
       }
       function _poll(kind, url, budget) {
-        budget = budget || {};
         var capPolls, capWait;
         try {
+          budget = _gateOpts(budget, _METHOD_OPTS.poll, "poll");
           capPolls = budget.maxPolls != null ? guard.limits.cap(budget.maxPolls, "maxPolls", maxPolls, { E, code: "acme/bad-input", min: 1, max: 1e3 }) : maxPolls;
           capWait = budget.maxTotalWait != null ? guard.limits.cap(budget.maxTotalWait, "maxTotalWait", maxTotalWait, { E, code: "acme/bad-input", min: 0, max: retryAfter.MAX_RETRY_AFTER_SECONDS }) : maxTotalWait;
           url = _clientUrl(url);
@@ -37747,8 +37983,8 @@ var require_acme = __commonJS({
         }
       }
       function _downloadCertificate(url, opts2) {
-        opts2 = opts2 || {};
         return Promise.resolve().then(function() {
+          opts2 = _gateOpts(opts2, _METHOD_OPTS.download, "downloadCertificate");
           var select = opts2.selectChain;
           if (select !== void 0 && typeof select !== "function") throw E("acme/bad-input", "downloadCertificate opts.selectChain must be a function");
           var maxAlt = guard.limits.cap(opts2.maxAlternates, "maxAlternates", DEFAULT_MAX_ALTERNATES, { E, code: "acme/bad-input", min: 0, max: 64 });
@@ -37797,22 +38033,24 @@ var require_acme = __commonJS({
         });
       }
       function _revokeCert(o) {
-        o = o || {};
-        if (!Buffer.isBuffer(o.certificate)) return Promise.reject(E("acme/bad-input", "revokeCert requires a DER certificate Buffer (opts.certificate)"));
-        var certKeyMode = o.certKey != null || _isObject(o.certJwk) || o.certAlg != null;
-        if (certKeyMode && !(o.certKey != null && _isObject(o.certJwk) && _isString(o.certAlg))) return Promise.reject(E("acme/bad-input", "revokeCert certificate-key mode requires certKey, certJwk, AND certAlg together, or none (RFC 8555 sec. 7.6)"));
-        var extra = { certificate: o.certificate };
-        if (o.reason !== void 0) extra.reason = o.reason;
-        return _resource("revokeCert").then(function(url) {
-          if (certKeyMode) {
-            return _postJws(url, function(nonce) {
-              return revokeCert(Object.assign({}, extra, { key: o.certKey, alg: o.certAlg, nonce, url, jwk: o.certJwk }));
-            }).then(function() {
+        return _promised(function() {
+          o = _gateOpts(o, _METHOD_OPTS.revoke, "revokeCert");
+          if (!Buffer.isBuffer(o.certificate)) throw E("acme/bad-input", "revokeCert requires a DER certificate Buffer (opts.certificate)");
+          var certKeyMode = o.certKey != null || _isObject(o.certJwk) || o.certAlg != null;
+          if (certKeyMode && !(o.certKey != null && _isObject(o.certJwk) && _isString(o.certAlg))) throw E("acme/bad-input", "revokeCert certificate-key mode requires certKey, certJwk, AND certAlg together, or none (RFC 8555 sec. 7.6)");
+          var extra = { certificate: o.certificate };
+          if (o.reason !== void 0) extra.reason = o.reason;
+          return _resource("revokeCert").then(function(url) {
+            if (certKeyMode) {
+              return _postJws(url, function(nonce) {
+                return revokeCert(Object.assign({}, extra, { key: o.certKey, alg: o.certAlg, nonce, url, jwk: o.certJwk }));
+              }).then(function() {
+                return true;
+              });
+            }
+            return _post(url, revokeCert, extra, "kid").then(function() {
               return true;
             });
-          }
-          return _post(url, revokeCert, extra, "kid").then(function() {
-            return true;
           });
         });
       }
@@ -37836,7 +38074,7 @@ var require_acme = __commonJS({
         });
       }
       function _keyChangeBody(o) {
-        o = o || {};
+        o = _gateOpts(o, _METHOD_OPTS.keyChange, "keyChange");
         if (!o.newKey || !_isObject(o.newJwk) || !_isString(o.newAlg)) throw E("acme/bad-input", "keyChange requires newKey, newJwk, and newAlg");
         var account = _requireKid();
         return _resource("keyChange").then(function(url) {
@@ -37895,8 +38133,8 @@ var require_acme = __commonJS({
         });
       }
       function _renewalWindow(certDer, o) {
-        o = o || {};
         return Promise.resolve().then(function() {
+          o = _gateOpts(o, _METHOD_OPTS.renewalWindow, "renewalWindow");
           if (!Buffer.isBuffer(certDer)) throw E("acme/bad-input", "renewalWindow requires a DER certificate Buffer");
           if (o.random !== void 0 && typeof o.random !== "function") throw E("acme/bad-input", "renewalWindow opts.random must be a function returning a number in [0, 1]");
           if (o.clock !== void 0 && typeof o.clock !== "function") throw E("acme/bad-input", "renewalWindow opts.clock must be a function returning epoch milliseconds");

package/lib/yaml-lex.js

@@ -96,7 +96,44 @@ function _isVerbatimLine(line, indent) {
   return false;
 }
 
+// maskNonStructural(text) → the mask alone, which is what most callers want.
 function maskNonStructural(text) {
+  return lexLines(text).masked;
+}
+
+// lexLines(text) → { masked, nodeStarts }.
+//
+// `nodeStarts` is a byte per source character, 1 where a NODE may begin: the
+// first content character of a key, a value, or a flow-collection item. It
+// answers the question the mask cannot, because the mask blanks a key's own text
+// along with a comment's, and a screen that deliberately reports shapes which
+// are not valid structure needs them apart.
+//
+// A byte array rather than a sparse one keyed by offset. Sparse indices this
+// large put V8's array into dictionary mode, which measured ~200 bytes for each
+// node in the document: a 1.7 MB file of short keys allocated 71 MB, a 40x
+// amplification an attacker picks by choosing the shape of the input. A byte per
+// character is 1x, flat, and known before the scan starts.
+//
+// The merge-key screen is that kind of screen. `<<:*d` with no space after the
+// colon is not a mapping entry, and is reported anyway, because a parser variant
+// may read it as a merge and that is the shape being smuggled. So its test
+// cannot be "is this well-formed structure?" — it has to be "could a node begin
+// here at all?", which is false inside a comment, a quoted body, a block
+// scalar's body, and a plain scalar's continuation line, and true for both
+// `<<: *b` and `<<:*b`.
+//
+// Enumerating those regions instead was tried and is the wrong shape: a first
+// version excluded block-scalar bodies and quoted bodies and still reported a
+// merge key written in a comment, on a plain scalar's continuation line, and
+// after a document marker. There are more ways to be inside literal text than
+// anyone lists from memory, and the lexer is already tracking the one property
+// that separates them.
+//
+// Both come out of ONE pass. A second function walking the same grammar is how
+// two answers to one question start disagreeing, which is the defect this
+// module was written to end.
+function lexLines(text) {
   var src = String(text == null ? "" : text);
   // Split on the newline ALONE, keeping any `\r` with the line it terminates.
   // `codepointClass.splitLines` strips it, and rejoining those with "\n" drops
@@ -106,6 +143,13 @@ function maskNonStructural(text) {
   // mask, because the locations it reports are confidently wrong.
   var lines = src.split("\n");
   var out = [];
+  var nodeStarts = new Uint8Array(src.length);
+  // The absolute offset line `li` begins at. Derived at the TOP of each
+  // iteration from the PREVIOUS line's raw length, rather than advanced at the
+  // bottom, because the loop body leaves by a dozen different `continue`s and
+  // any one of them forgetting to advance would silently shift every offset
+  // after it.
+  var lineBase = 0;
   // A block scalar's body indentation is DETECTED from its first content line,
   // which is what YAML specifies and the only thing that works. Two fixed
   // columns were tried and each failed the other's case: measuring from the
@@ -149,6 +193,7 @@ function maskNonStructural(text) {
   var plainFromDash = false;
 
   for (var li = 0; li < lines.length; li += 1) {
+    if (li > 0) lineBase += lines[li - 1].length + 1;   // + the "\n" that ended it
     var raw = lines[li];
     // The carriage return of a CRLF pair is a line TERMINATOR, not content, so
     // it is held aside and put back verbatim. Letting it into the scan would
@@ -283,6 +328,14 @@ function maskNonStructural(text) {
       var jsonKeyBefore = prevWasJsonKey;
       prevWasJsonKey = false;
 
+      // The first content character of a node position. Whitespace carries the
+      // flag rather than clearing it, so this lands on the character that
+      // actually starts the node, and a `#` here opens a comment instead — no
+      // node begins inside one.
+      if (atNodeStart && !_isPlainSpace(ch) && ch !== "#") {
+        nodeStarts[lineBase + i] = 1;
+      }
+
       // A comment opens on `#` at the start of the content or after whitespace,
       // and runs to the end of the line. Its text is not YAML, whatever it
       // says: `x: 1 # note !bang` names no tag.
@@ -478,7 +531,7 @@ function maskNonStructural(text) {
     }
     out.push(masked + (cr ? "\r" : ""));
   }
-  return out.join("\n");
+  return { masked: out.join("\n"), nodeStarts: nodeStarts };
 }
 
 // A line kept for its structure, with any comment on it masked. Used for the
@@ -530,4 +583,5 @@ function _blanked(s) {
 
 module.exports = {
   maskNonStructural: maskNonStructural,
+  lexLines:          lexLines,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.18.53",
+  "version": "0.18.54",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:f52f2ee6-253b-4bf4-9915-22d453a4407a",
+  "serialNumber": "urn:uuid:df56ad31-5a1c-4fe3-91c9-28416a675962",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-08-24T12:08:00.505Z",
+    "timestamp": "2026-08-25T01:22:53.297Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.18.53",
+      "bom-ref": "@blamejs/core@0.18.54",
       "type": "application",
       "name": "blamejs",
-      "version": "0.18.53",
+      "version": "0.18.54",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.18.53",
+      "purl": "pkg:npm/%40blamejs/core@0.18.54",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.18.53",
+      "ref": "@blamejs/core@0.18.54",
       "dependsOn": []
     }
   ]