@blamejs/pki 0.6.15 → 0.6.16

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to `@blamejs/pki` are documented here. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v0.6.16 — 2026-09-01
+
+pki.scep.enroll and pki.scep.renew poll a PENDING enrollment to its issued certificate, sending RFC 8894 CertPoll requests until the CA answers or a bounded poll-count and wait budget is exhausted.
+
+### Added
+
+- pki.scep.build and pki.scep.parse now handle the CertPoll (GetCertInitial, messageType 20) request: a pkcsPKIEnvelope carrying an IssuerAndSubject (the CA's subject name and the request's subject name), signed under the transaction attributes with the original transactionID (RFC 8894 sec. 3.3.3).
+- pki.scep.enroll and pki.scep.renew poll a PENDING response to a terminal status. New options bound the loop: pollCount (maximum CertPoll requests, default 5), maxTotalWait (total Retry-After sleep budget in seconds), sleep (an injectable (ms) -> Promise sleeper), and onRetryAfter (an observer of each delay). A budget exhausted with no terminal response throws scep/poll-exhausted carrying the transactionId to resume with. For a deployment whose request is encrypted to a separate RA certificate, issuerCert names the issuing CA the CertPoll must carry (default caCert).
+
+### Changed
+
+- pki.scep.enroll and pki.scep.renew poll by default when the CA answers PENDING: a PENDING enrollment now resolves to the issued certificate or throws, rather than returning { status: "PENDING" } for the caller to retry. Pass pollCount: 0 to restore the single-shot PENDING return and drive the retry yourself.
+
 ## v0.6.15 — 2026-09-01
 
 Verifying a Sigstore bundle no longer matches a pinned identity against a non-text subjectAltName value; the value is surfaced as null so the policy fails closed instead of comparing raw bytes. The library source also ships without its explanatory comments, keeping the JSDoc that generates the API reference and the SPDX license headers.

package/lib/scep.js

@@ -53,6 +53,8 @@ var pkix = require("./schema-pkix");
 var guard = require("./guard-all");
 var C = require("./constants");
 var httpTransport = require("./http-transport");
+var retryAfter = require("./http-retry-after");
+var _defaultSleep = require("./sleep").sleep;
 var nodeCrypto = require("node:crypto");
 
 function _err(code, msg, cause) { return new ScepError(code, msg, cause); }
@@ -66,7 +68,7 @@ var FAIL_INFO = { badAlg: "0", badMessageCheck: "1", badRequest: "2", badTime: "
 function _invert(table) { var o = Object.create(null); for (var k in table) if (Object.prototype.hasOwnProperty.call(table, k)) o[table[k]] = k; return o; }
 var MESSAGE_TYPE_BY_CODE = _invert(MESSAGE_TYPE), PKI_STATUS_BY_CODE = _invert(PKI_STATUS), FAIL_INFO_BY_CODE = _invert(FAIL_INFO);
 
-var _PARSE_SUPPORTED = { PKCSReq: 1, RenewalReq: 1, CertRep: 1 };
+var _PARSE_SUPPORTED = { PKCSReq: 1, RenewalReq: 1, CertRep: 1, CertPoll: 1 };
 
 var ENVELOPE_CIPHER = "aes-128-cbc";
 
@@ -239,23 +241,28 @@ async function build(spec) {
   guard.identifier.assertKnownKeys(spec, _BUILD_KEYS, _err, "scep/bad-input", "pki.scep.build has an unknown option: ");
   var mtCode = MESSAGE_TYPE[spec.messageType];
   if (mtCode == null) throw _err("scep/bad-message-type", "unknown messageType " + JSON.stringify(spec.messageType) + " (RFC 8894 sec. 3.2.1.2)");
-  if (spec.messageType !== "PKCSReq" && spec.messageType !== "RenewalReq") {
-    throw _err("scep/bad-message-type", "pki.scep.build issues a request (PKCSReq / RenewalReq); " + spec.messageType + " is not built in this release");
+  if (spec.messageType !== "PKCSReq" && spec.messageType !== "RenewalReq" && spec.messageType !== "CertPoll") {
+    throw _err("scep/bad-message-type", "pki.scep.build issues a request (PKCSReq / RenewalReq / CertPoll); " + spec.messageType + " is not built in this release");
   }
   if (spec.signer == null || typeof spec.signer !== "object") throw _err("scep/bad-input", "a signer { cert, key } is required");
   var senderNonce = _nonce(spec.senderNonce, "senderNonce");
   var txnId = _transactionId(spec.transactionId);
-  var messageData = guard.bytes.snapshotSource(spec.messageData, ScepError, "scep/bad-input", "messageData");
   var recipient = guard.bytes.snapshotSource(spec.recipient, ScepError, "scep/bad-input", "recipient");
   _assertRsaRecipient(recipient);
   var signerCert = guard.bytes.snapshotSource(spec.signer.cert, ScepError, "scep/bad-input", "signer.cert");
   _assertSigningKeyUsage(signerCert, "signer certificate");
   var signerKey = spec.signer.key;
-  var parsedCsr;
-  try { parsedCsr = schemaCsr.parse(messageData); }
-  catch (e) { throw _err("scep/bad-input", "messageData is not a valid PKCS#10 CertificationRequest (RFC 8894 sec. 3.3.1): " + e.message, e); }
-  if (!(await csrVerify.verifyCsrSignature(parsedCsr))) {
-    throw _err("scep/bad-popo", "the PKCS#10 messageData failed its proof-of-possession: its self-signature does not verify under its own subject public key, so a CA would reject it");
+  var messageData;
+  if (spec.messageType === "CertPoll") {
+    messageData = _buildIssuerAndSubject(recipient, spec.requestSubject, spec.issuer);
+  } else {
+    messageData = guard.bytes.snapshotSource(spec.messageData, ScepError, "scep/bad-input", "messageData");
+    var parsedCsr;
+    try { parsedCsr = schemaCsr.parse(messageData); }
+    catch (e) { throw _err("scep/bad-input", "messageData is not a valid PKCS#10 CertificationRequest (RFC 8894 sec. 3.3.1): " + e.message, e); }
+    if (!(await csrVerify.verifyCsrSignature(parsedCsr))) {
+      throw _err("scep/bad-popo", "the PKCS#10 messageData failed its proof-of-possession: its self-signature does not verify under its own subject public key, so a CA would reject it");
+    }
   }
   var pkcsPKIEnvelope;
   try {
@@ -276,7 +283,26 @@ async function build(spec) {
     throw e;
   }
 }
-var _BUILD_KEYS = { messageType: 1, messageData: 1, recipient: 1, signer: 1, transactionId: 1, senderNonce: 1 };
+var _BUILD_KEYS = { messageType: 1, messageData: 1, recipient: 1, requestSubject: 1, issuer: 1, signer: 1, transactionId: 1, senderNonce: 1 };
+
+function _buildIssuerAndSubject(recipientCertDer, requestSubjectSource, issuerOverride) {
+  var subject = guard.bytes.snapshotSource(requestSubjectSource, ScepError, "scep/bad-input", "requestSubject");
+  var issuer, issuerNode, subjNode;
+  try {
+    issuer = issuerOverride != null
+      ? guard.bytes.snapshotSource(issuerOverride, ScepError, "scep/bad-input", "issuer")
+      : schemaX509.parse(recipientCertDer).subject.bytes;
+    issuerNode = asn1.decode(issuer);
+    subjNode = asn1.decode(subject);
+  } catch (e) {
+    if (e instanceof ScepError) throw e;
+    throw _err("scep/bad-input", "the CertPoll IssuerAndSubject Names are not valid DER (RFC 8894 sec. 3.3.3): " + e.message, e);
+  }
+  if (!pkix.rootSequenceChildren(issuerNode, 0) || !pkix.rootSequenceChildren(subjNode, 0)) {
+    throw _err("scep/bad-input", "the CertPoll issuer and requestSubject must each be a Name (a SEQUENCE) DER (RFC 8894 sec. 3.3.3)");
+  }
+  return b.sequence([issuer, subject]);
+}
 
 /**
  * @primitive  pki.scep.parse
@@ -289,7 +315,7 @@ var _BUILD_KEYS = { messageType: 1, messageData: 1, recipient: 1, signer: 1, tra
  * Disassemble a SCEP pkiMessage (RFC 8894 sec. 3): verify the outer SignedData signature, read the
  * transaction attributes BOUND to the verified signer (never from a separate untrusted parse), and,
  * given the recipient key, decrypt the pkcsPKIEnvelope to recover the messageData. It reads the
- * enrollment message types PKCSReq, RenewalReq, and CertRep; the CertPoll, GetCert, and GetCRL client
+ * enrollment message types PKCSReq, RenewalReq, CertRep, and CertPoll; the GetCert and GetCRL client
  * queries a CA processes are refused (`scep/unsupported-message-type`). The verdict is
  * `{ signatureValid, signerAuthenticated, signerCert, messageType, transactionId, senderNonce,
  * recipientNonce, pkiStatus, failInfo, failInfoText, messageData, certificates, crls }` (fields null
@@ -418,6 +444,14 @@ async function parse(bytes, opts) {
     } else if (messageType === "PKCSReq" || messageType === "RenewalReq") {
       try { schemaCsr.parse(dec.content); }
       catch (e) { throw _err("scep/bad-request-payload", "a " + messageType + " messageData must be a PKCS#10 CertificationRequest (RFC 8894 sec. 3.3.1)", e); }
+    } else if (messageType === "CertPoll") {
+      var ias;
+      try { ias = asn1.decode(dec.content); }
+      catch (e) { throw _err("scep/bad-request-payload", "a CertPoll messageData must be an IssuerAndSubject (RFC 8894 sec. 3.3.3)", e); }
+      var iasCh = pkix.rootSequenceChildren(ias, 2, 2);
+      if (!iasCh || !pkix.rootSequenceChildren(iasCh[0], 0) || !pkix.rootSequenceChildren(iasCh[1], 0)) {
+        throw _err("scep/bad-request-payload", "a CertPoll messageData must be an IssuerAndSubject: a SEQUENCE of two Name values (RFC 8894 sec. 3.3.3)");
+      }
     }
   }
   return out;
@@ -763,6 +797,62 @@ async function getNextCACert(baseUrl, opts) {
 function _defaultTransactionId() {
   return nodeCrypto.randomBytes(16).toString("hex");
 }
+var POLL_COUNT_MAX = 1000;
+
+function _dispatchCertRep(rep, transactionId, spki) {
+  if (rep.messageType !== "CertRep") throw _err("scep/unexpected-message-type", "the SCEP response is a " + rep.messageType + ", not a CertRep");
+  if (rep.transactionId !== transactionId) throw _err("scep/transaction-id-mismatch", "the CertRep transactionID does not match the request (RFC 8894 sec. 3.2.1.1)");
+  if (rep.pkiStatus === "FAILURE") {
+    var failErr = _err("scep/enrollment-failed", "the CA refused the request with failInfo " + JSON.stringify(rep.failInfo) + (rep.failInfoText ? " (" + rep.failInfoText + ")" : ""));
+    failErr.failInfo = rep.failInfo;
+    failErr.failInfoText = rep.failInfoText;
+    throw failErr;
+  }
+  if (rep.pkiStatus === "PENDING") return { pending: true };
+  var repCerts = rep.certificates || [];
+  var issued = findIssuedCert(repCerts, spki.bytes);
+  if (issued == null) throw _err("scep/no-issued-cert", "the SUCCESS CertRep did not carry a certificate matching the request public key");
+  if (findIssuedCert(repCerts.filter(function (c) { return c !== issued; }), spki.bytes) != null) {
+    throw _err("scep/ambiguous-issued-cert", "the SUCCESS CertRep carried more than one certificate matching the request public key; the issued certificate is ambiguous (RFC 8894 sec. 3.3)");
+  }
+  return { pending: false, result: { status: "SUCCESS", certificate: issued, certificates: repCerts, transactionId: rep.transactionId } };
+}
+
+function _pollExhausted(which, transactionId, senderNonce) {
+  var e = _err("scep/poll-exhausted", "the CA kept the request PENDING and " + which + " was exhausted before it resolved (RFC 8894 sec. 4.4); resume the transaction later with this transactionId");
+  e.transactionId = transactionId;
+  e.senderNonce = senderNonce;
+  return e;
+}
+
+async function _pollForIssuance(ctx) {
+  var issuerName;
+  try { issuerName = schemaX509.parse(ctx.issuerCert).subject.bytes; }
+  catch (e) { throw _err("scep/bad-input", "the issuerCert whose subject names the CertPoll issuer is not a parseable certificate (RFC 8894 sec. 3.3.3)", e); }
+  var res = ctx.firstResponse, count = 0, waitedMs = 0, lastNonce = ctx.firstSenderNonce;
+  for (;;) {
+    var delaySec = 1;
+    var ra = _header(res.headers, "retry-after");
+    if (typeof ra === "string" && ra.trim() !== "") {
+      var parsed = retryAfter.parse(ra, { now: Date.now(), E: _err, code: "scep/bad-input", lenient: true });
+      if (parsed.retryAfterSeconds != null) delaySec = parsed.retryAfterSeconds;
+    }
+    count += 1;
+    if (count > ctx.pollCount) throw _pollExhausted("the poll count", ctx.transactionId, lastNonce);
+    waitedMs += delaySec * C.TIME.seconds(1);
+    if (waitedMs > ctx.maxTotalWait * C.TIME.seconds(1)) throw _pollExhausted("the total wait budget", ctx.transactionId, lastNonce);
+    if (ctx.onRetryAfter) ctx.onRetryAfter(delaySec);
+    await ctx.sleep(delaySec * C.TIME.seconds(1));
+    var sn = nodeCrypto.randomBytes(16);
+    lastNonce = sn;
+    var certPoll = await build({ messageType: "CertPoll", requestSubject: ctx.csrSubject, issuer: issuerName, recipient: ctx.caCert, signer: ctx.signer, transactionId: ctx.transactionId, senderNonce: sn });
+    res = await _client("POST", ctx.postUrl, certPoll, { "content-type": CT_PKI_MESSAGE }, ctx.clientOpts);
+    var body = _requireOk(res, [CT_PKI_MESSAGE], "PKIOperation");
+    var rep = await parse(body, { signerCert: ctx.signerCert, expectedSenderNonce: sn, recipientKey: ctx.recipientKey });
+    var d = _dispatchCertRep(rep, ctx.transactionId, ctx.spki);
+    if (!d.pending) return d.result;
+  }
+}
 async function _pkiOperation(messageType, baseUrl, opts, verbName) {
   opts = guard.identifier.optionsObject(opts, _err, "scep/bad-input", "pki.scep." + verbName + " options");
   guard.identifier.assertKnownKeys(opts, _ENROLL_KEYS, _err, "scep/bad-input", "pki.scep." + verbName + " has an unknown option: ");
@@ -772,8 +862,9 @@ async function _pkiOperation(messageType, baseUrl, opts, verbName) {
   if (opts.recipientKey == null || typeof opts.recipientKey !== "object") throw _err("scep/bad-input", "a recipientKey { cert, key } is required to decrypt the CA response");
   var caCert = guard.bytes.snapshotSource(opts.caCert, ScepError, "scep/bad-input", "the caCert");
   var signerCert = opts.responderCert != null ? guard.bytes.snapshotSource(opts.responderCert, ScepError, "scep/bad-input", "the responderCert") : caCert;
+  var issuerCert = opts.issuerCert != null ? guard.bytes.snapshotSource(opts.issuerCert, ScepError, "scep/bad-input", "the issuerCert") : caCert;
   var recipientKey = _captureRecipientKey(opts.recipientKey);
-  var signer = opts.signer;
+  var signer = { cert: guard.bytes.snapshotSource(opts.signer.cert, ScepError, "scep/bad-input", "signer.cert"), key: opts.signer.key };
   var clientOpts = {
     transport: opts.transport,
     tls: opts.tls != null ? Object.assign({}, opts.tls) : opts.tls,
@@ -784,31 +875,28 @@ async function _pkiOperation(messageType, baseUrl, opts, verbName) {
   };
   var postUrl = _scepUrl(baseUrl, "PKIOperation");
   var csrView = guard.bytes.snapshotSource(opts.csr, ScepError, "scep/bad-input", "the csr");
-  var spki;
-  try { spki = schemaCsr.parse(csrView).subjectPublicKeyInfo; }
+  var spki, csrSubject;
+  try { var _pcsr = schemaCsr.parse(csrView); spki = _pcsr.subjectPublicKeyInfo; csrSubject = _pcsr.subject.bytes; }
   catch (e) { throw _err("scep/bad-input", "the csr is not a valid PKCS#10 CertificationRequest", e); }
+  var pollCount = guard.limits.cap(opts.pollCount, "pollCount", 5, { E: _err, code: "scep/bad-input", min: 0, max: POLL_COUNT_MAX });
+  var maxTotalWait = guard.limits.cap(opts.maxTotalWait, "maxTotalWait", retryAfter.MAX_RETRY_AFTER_SECONDS, { E: _err, code: "scep/bad-input", min: 0, max: retryAfter.MAX_RETRY_AFTER_SECONDS });
+  var sleep = typeof opts.sleep === "function" ? opts.sleep : _defaultSleep;
+  var onRetryAfter = typeof opts.onRetryAfter === "function" ? opts.onRetryAfter : null;
   var senderNonce = nodeCrypto.randomBytes(16);
   var transactionId = opts.transactionId != null ? opts.transactionId : _defaultTransactionId();
   var reqMsg = await build({ messageType: messageType, messageData: csrView, recipient: caCert, signer: signer, transactionId: transactionId, senderNonce: senderNonce });
   var res = await _client("POST", postUrl, reqMsg, { "content-type": CT_PKI_MESSAGE }, clientOpts);
   var body = _requireOk(res, [CT_PKI_MESSAGE], "PKIOperation");
   var rep = await parse(body, { signerCert: signerCert, expectedSenderNonce: senderNonce, recipientKey: recipientKey });
-  if (rep.messageType !== "CertRep") throw _err("scep/unexpected-message-type", "the SCEP response is a " + rep.messageType + ", not a CertRep");
-  if (rep.transactionId !== transactionId) throw _err("scep/transaction-id-mismatch", "the CertRep transactionID does not match the request (RFC 8894 sec. 3.2.1.1)");
-  if (rep.pkiStatus === "FAILURE") {
-    var failErr = _err("scep/enrollment-failed", "the CA refused the request with failInfo " + JSON.stringify(rep.failInfo) + (rep.failInfoText ? " (" + rep.failInfoText + ")" : ""));
-    failErr.failInfo = rep.failInfo;
-    failErr.failInfoText = rep.failInfoText;
-    throw failErr;
-  }
-  if (rep.pkiStatus === "PENDING") return { status: "PENDING", transactionId: rep.transactionId, senderNonce: senderNonce };
-  var repCerts = rep.certificates || [];
-  var issued = findIssuedCert(repCerts, spki.bytes);
-  if (issued == null) throw _err("scep/no-issued-cert", "the SUCCESS CertRep did not carry a certificate matching the request public key");
-  if (findIssuedCert(repCerts.filter(function (c) { return c !== issued; }), spki.bytes) != null) {
-    throw _err("scep/ambiguous-issued-cert", "the SUCCESS CertRep carried more than one certificate matching the request public key; the issued certificate is ambiguous (RFC 8894 sec. 3.3)");
-  }
-  return { status: "SUCCESS", certificate: issued, certificates: repCerts, transactionId: rep.transactionId };
+  var d = _dispatchCertRep(rep, transactionId, spki);
+  if (!d.pending) return d.result;
+  if (pollCount <= 0) return { status: "PENDING", transactionId: rep.transactionId, senderNonce: senderNonce };
+  return _pollForIssuance({
+    firstResponse: res, firstSenderNonce: senderNonce, postUrl: postUrl, clientOpts: clientOpts,
+    caCert: caCert, csrSubject: csrSubject, issuerCert: issuerCert, signer: signer, signerCert: signerCert, recipientKey: recipientKey,
+    spki: spki, transactionId: transactionId, pollCount: pollCount, maxTotalWait: maxTotalWait,
+    sleep: sleep, onRetryAfter: onRetryAfter,
+  });
 }
 
 /**
@@ -824,8 +912,13 @@ async function _pkiOperation(messageType, baseUrl, opts, verbName) {
  * the CertRep. The CA response is authenticated against the CA certificate and its `recipientNonce` must
  * echo the request's fresh `senderNonce`. On SUCCESS the issued certificate is selected out of the
  * response by SubjectPublicKeyInfo byte-match against the request; a FAILURE throws
- * `scep/enrollment-failed` carrying the CA's failInfo; a PENDING returns `{ status: "PENDING",
- * transactionId }` for the caller to retry. The content key is transported under RSAES-OAEP, so the CA
+ * `scep/enrollment-failed` carrying the CA's failInfo. A CA that answers PENDING (manual enrollment, RFC
+ * 8894 sec. 2.5) is polled automatically: the client issues CertPoll (GetCertInitial) messages reusing
+ * the transactionID, each authenticated against the CA certificate with a fresh nonce it must echo,
+ * until the CA answers SUCCESS or FAILURE or a `pollCount` / `maxTotalWait` budget is exhausted
+ * (`scep/poll-exhausted`, carrying the `transactionId` to resume). Pass `pollCount: 0` to disable polling
+ * and get the single `{ status: "PENDING", transactionId }` return for a caller that drives the retry
+ * itself. The content key is transported under RSAES-OAEP, so the CA
  * certificate must be an RSA `keyEncipherment` certificate that accepts OAEP; the shared-secret
  * authenticator (RFC 8894 sec. 2.4) is the `challengePassword` the caller placed in the PKCS#10.
  *
@@ -835,14 +928,19 @@ async function _pkiOperation(messageType, baseUrl, opts, verbName) {
  *   - `signer` -- `{ cert, key }`, the outer SignedData signer (for a PKCSReq, a self-signed certificate over the request key).
  *   - `recipientKey` -- `{ cert, key }`, the RSA key the CA encrypts the response to, to decrypt the CertRep.
  *   - `responderCert` -- the certificate to authenticate the CA's response signature against (defaults to `caCert`).
+ *   - `issuerCert` -- the issuing CA certificate whose subject names the CertPoll issuer (defaults to `caCert`; set it when the request is encrypted to a separate RA certificate, RFC 8894 sec. 3.3.3).
  *   - `transactionId` -- a caller-unique PrintableString (defaults to 16 random bytes, hex-encoded, unique per call).
+ *   - `pollCount` -- the maximum number of CertPoll requests on a PENDING response (default 5; `0` disables polling).
+ *   - `maxTotalWait` -- the total Retry-After sleep budget in seconds across all polls (default the Retry-After horizon).
+ *   - `sleep` -- an injectable sleeper `(ms) -> Promise` for the Retry-After wait (default a real timer).
+ *   - `onRetryAfter` -- an optional observer `(delaySeconds) -> void` called before each poll sleep.
  *   - `transport` / `timeout` / `maxResponseBytes` / `maxRedirects` / `tls` / `allowCrossOriginRedirect` -- transport bounds.
  * @example
  *   // requires: scepCsr, caCertDer, clientCertDer, clientKeyPkcs8, scepTransport
  *   var out = await pki.scep.enroll("http://ca.example/scep", { csr: scepCsr, caCert: caCertDer,
  *     signer: { cert: clientCertDer, key: clientKeyPkcs8 },
  *     recipientKey: { cert: clientCertDer, key: clientKeyPkcs8 }, transport: scepTransport });
- *   out.status;   // "SUCCESS", or "PENDING" to retry
+ *   out.status;   // "SUCCESS" (a PENDING request is polled to a terminal status unless pollCount is 0)
  */
 function enroll(baseUrl, opts) { return _pkiOperation("PKCSReq", baseUrl, opts, "enroll"); }
 
@@ -874,7 +972,7 @@ function _withKeys(extra) { var o = {}, k; for (k in _TRANSPORT_KEYS) o[k] = 1;
 var _CACAPS_KEYS = _withKeys({ expectSCEPStandard: 1, requireStrongProfile: 1 });
 var _CACERT_KEYS = _withKeys({ expectedFingerprint: 1, fingerprintAlgorithm: 1 });
 var _NEXTCACERT_KEYS = _withKeys({ caCertificate: 1 });
-var _ENROLL_KEYS = _withKeys({ csr: 1, caCert: 1, signer: 1, recipientKey: 1, responderCert: 1, transactionId: 1 });
+var _ENROLL_KEYS = _withKeys({ csr: 1, caCert: 1, signer: 1, recipientKey: 1, responderCert: 1, issuerCert: 1, transactionId: 1, pollCount: 1, maxTotalWait: 1, sleep: 1, onRetryAfter: 1 });
 
 module.exports = {
   build: build,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.6.15",
+  "version": "0.6.16",
   "description": "Pure-JavaScript PKI toolkit that owns its stack — X.509, ASN.1/DER, CMS, PQC-first.",
   "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:b21c243d-9b6e-49ab-9c19-3427ff43e9bc",
+  "serialNumber": "urn:uuid:e63bdf7d-807a-4e39-8cb7-7eb6a47b5808",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-01T08:58:18.522Z",
+    "timestamp": "2026-09-01T10:42:10.477Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.6.15",
+      "bom-ref": "@blamejs/pki@0.6.16",
       "type": "application",
       "name": "pki",
-      "version": "0.6.15",
+      "version": "0.6.16",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "Pure-JavaScript PKI toolkit that owns its stack — X.509, ASN.1/DER, CMS, PQC-first.",
-      "purl": "pkg:npm/%40blamejs/pki@0.6.15",
+      "purl": "pkg:npm/%40blamejs/pki@0.6.16",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.6.15",
+      "ref": "@blamejs/pki@0.6.16",
       "dependsOn": []
     }
   ]