@blamejs/core 0.17.24 → 0.18.1

package/lib/self-update.js

@@ -297,6 +297,11 @@ function _matchAsset(name, pattern, fallback) {
   // first asset whose name fits the well-known shape (tarball / zip /
   // .sig). The fallback is documented as best-effort; operators with
   // multi-asset releases should pass a pattern explicitly.
+  // The `: false` arm is unreachable from the public API: every call that
+  // reaches this ternary (a non-string, non-RegExp pattern) passes a truthy
+  // fallback, and the null-fallback call sites only run with a validated
+  // string/RegExp pattern that never reaches the ternary.
+  /* c8 ignore next */
   return fallback ? fallback.test(name) : false;
 }
 
@@ -321,18 +326,82 @@ function _findEntryByName(entries, name) {
   return null;
 }
 
+// Strip the final extension from an asset name so a signature that REPLACES the
+// extension (app.bin -> app.sig) pairs as strongly as one that APPENDS a suffix
+// (app.bin -> app.bin.sig). Returns the name unchanged when there is no leading
+// stem to keep (no extension, or a leading-dot dotfile) so no over-broad stem is
+// derived to match a foreign sidecar against.
+function _assetStem(name) {
+  var dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+
+// _soleArtifactWithStem — is `assetName` the ONLY non-signature artifact in the
+// release whose extension-stripped stem is `stem`? The replace-convention pairing
+// (below) is only unambiguous when it is: with app.bin AND app.exe present, a
+// single app.sig can't be attributed to either.
+function _soleArtifactWithStem(assetName, stem, entries) {
+  for (var i = 0; i < entries.length; i++) {
+    var n = entries[i].name;
+    if (n === assetName) continue;              // the asset itself
+    if (_SIG_SHAPE.test(n)) continue;           // signatures aren't artifacts
+    // Ambiguous when another artifact would derive the SAME `stem + suffix`
+    // signature name: either it shares the extension-stripped stem (its replace
+    // convention), OR its full name IS the stem (its APPEND convention — app.tar's
+    // app.tar.sig is also app.tar.gz's replace-derived app.tar.sig).
+    if (_assetStem(n) === stem || n === stem) return false;
+  }
+  return true;
+}
+
+// _pathsAlias — do two already-realpath-resolved absolute paths refer to the same
+// file? An exact match, or a CASE-ONLY difference: realpathSync does not always
+// canonicalize the final component's case, so on a case-insensitive volume
+// (Windows / default macOS) a backup path can alias the reserved quarantine path
+// with different letter casing. Comparing case-insensitively on every platform is
+// fail-closed here: the quarantine suffix (.rollback-bad) is framework-reserved,
+// so a case-variant of it is only ever the same reserved path, never a distinct
+// operator backup that happens to collide.
+function _pathsAlias(a, b) {
+  return a === b || a.toLowerCase() === b.toLowerCase();
+}
+
+// _derivedSignatureNames — the exact signature names that unambiguously sign
+// `assetName`: the asset name plus each suffix (append convention) and, when the
+// asset has an extension to strip AND is the sole artifact with that stem, the
+// stem plus each suffix (replace convention). Every derived name ends in a
+// signature suffix, so the boundary after the stem is always that suffix's leading
+// delimiter — a bare-prefix look-alike (application.sig for app.bin, stem `app`)
+// never derives. The replace convention is withheld when another artifact shares
+// the stem (app.bin + app.exe), where a lone app.sig is ambiguous.
+function _derivedSignatureNames(assetName, entries) {
+  var stem       = _assetStem(assetName);
+  var stemUnique = stem !== assetName && _soleArtifactWithStem(assetName, stem, entries);
+  var names = [];
+  for (var s = 0; s < _SIG_SUFFIXES.length; s++) {
+    names.push(assetName + _SIG_SUFFIXES[s]);
+    if (stemUnique) names.push(stem + _SIG_SUFFIXES[s]);
+  }
+  return names;
+}
+
 // _selectSignatureFor — pick the detached signature OF `assetName`, not a
 // first-match-wins signature that may sign a DIFFERENT sidecar. Selecting the
 // asset first and DERIVING the expected signature name from it is the pairing
 // contract: a returned { asset, signature } is guaranteed to be an asset and
-// the signature over exactly that asset. Falls back to a lone signature-shaped
-// asset only when the release ships exactly one (the common one-asset-one-sig
-// case); anything ambiguous fails closed (null) rather than pairing a signature
+// the signature over exactly that asset. The derived names cover both common
+// one-asset-one-sig conventions — the suffix APPENDED to the asset name
+// (app.bin -> app.bin.sig) and the extension REPLACED (app.bin -> app.sig).
+// Falls back to a lone signature-shaped asset only when the release ships
+// exactly one AND that sidecar references the full asset name (the common
+// algorithm-suffixed case); anything ambiguous OR a lone sidecar whose name is
+// unrelated to the asset fails closed (null) rather than pairing a signature
 // that may not sign the returned asset.
 function _selectSignatureFor(assetName, entries, signaturePattern) {
-  // (a) Strong pairing: the asset name plus a signature suffix.
-  for (var s = 0; s < _SIG_SUFFIXES.length; s++) {
-    var hit = _findEntryByName(entries, assetName + _SIG_SUFFIXES[s]);
+  // (a) Strong pairing: an exact derived signature name (append or replace).
+  var derived = _derivedSignatureNames(assetName, entries);
+  for (var s = 0; s < derived.length; s++) {
+    var hit = _findEntryByName(entries, derived[s]);
     // When the operator constrained signaturePattern, the derived name must
     // also satisfy it; otherwise the derived name is authoritative.
     if (hit && (signaturePattern === undefined || _matchAsset(hit.name, signaturePattern, null))) {
@@ -348,9 +417,13 @@ function _selectSignatureFor(assetName, entries, signaturePattern) {
     });
     return stemMatches.length === 1 ? _assetObj(stemMatches[0]) : null;
   }
-  // (c) No operator pattern, no derived hit: accept a lone signature-shaped
-  // asset (single-sig release), else null.
-  var sigShaped = entries.filter(function (e) { return _SIG_SHAPE.test(e.name); });
+  // (c) No operator pattern, no derived hit: accept a lone signature-shaped asset
+  // ONLY when it references the asset stem (single-sig release). A lone sidecar
+  // whose name is unrelated to the asset may sign a different object, so it fails
+  // closed (null) — never pair a name-unrelated signature to the asset.
+  var sigShaped = entries.filter(function (e) {
+    return _SIG_SHAPE.test(e.name) && e.name.indexOf(assetName) === 0;
+  });
   return sigShaped.length === 1 ? _assetObj(sigShaped[0]) : null;
 }
 
@@ -445,9 +518,11 @@ async function poll(opts) {
   } catch (e) {
     _safeAuditEmit("selfupdate.poll.checked", "denied", {
       releasesUrl: opts.releasesUrl, reason: "request-failed",
+      /* c8 ignore next -- String(e) fallback: request rejections are always Errors with a message */
       message: (e && e.message) || String(e),
     });
     throw new SelfUpdateError("selfupdate/poll-failed",
+      /* c8 ignore next */
       "selfUpdate.poll: request failed: " + ((e && e.message) || String(e)));
   }
 
@@ -469,6 +544,10 @@ async function poll(opts) {
       "selfUpdate.poll: upstream returned HTTP " + res.statusCode);
   }
 
+  // The non-Buffer arm is defensive: httpClient.request always resolves a
+  // Buffer body (Buffer.alloc(0) for an empty response), so the string/null
+  // normalization never runs on the real transport.
+  /* c8 ignore next 2 */
   var bodyBuf = Buffer.isBuffer(res.body) ? res.body :
     (res.body == null ? Buffer.alloc(0) : Buffer.from(String(res.body), "utf8"));
   var parsed;
@@ -477,9 +556,11 @@ async function poll(opts) {
   } catch (e) {
     _safeAuditEmit("selfupdate.poll.checked", "denied", {
       releasesUrl: opts.releasesUrl, reason: "bad-json",
+      /* c8 ignore next -- String(e) fallback: safeJson.parse throws Errors with a message */
       message: (e && e.message) || String(e),
     });
     throw new SelfUpdateError("selfupdate/bad-json",
+      /* c8 ignore next */
       "selfUpdate.poll: response is not valid JSON: " + ((e && e.message) || String(e)));
   }
 
@@ -676,9 +757,13 @@ async function verify(opts) {
     var code = _mapStandaloneKind(e && e.kind);
     _safeAuditEmit("selfupdate.verify.failed", "denied", {
       assetPath: opts.assetPath, signaturePath: opts.signaturePath,
+      // Fallbacks are defensive: standaloneVerifier throws only via `_svErr`,
+      // which always sets `.kind` and a message, so neither alternate runs.
+      /* c8 ignore next */
       reason: (e && e.kind) || "verify-error", message: (e && e.message) || String(e),
     });
     throw new SelfUpdateError(code,
+      /* c8 ignore next */
       "selfUpdate.verify: " + ((e && e.message) || String(e)));
   }
 
@@ -716,20 +801,20 @@ function _validateSwapOpts(opts, label) {
           "selfUpdate.swap: opts.hashAlgo must be one of " + ALLOWED_HASH_ALGS.join(", "));
       }
     };
-    // swap re-reads the from-bytes to re-hash them (closing the verify->swap
-    // window); its cap must be declarable so it matches the maxBytes an
-    // operator passed to selfUpdate.verify for the same asset — otherwise swap
-    // would refuse a large binary that verify accepted. Optional; defaults to
-    // the same C.BYTES.gib(1) cap the body applies.
-    schema.maxBytes = function (value) {
-      numericBounds.requirePositiveFiniteIntIfPresent(value,
-        "selfUpdate.swap: opts.maxBytes", SelfUpdateError, "selfupdate/bad-max-bytes");
-    };
   }
   schema.to       = { rule: "required-string", code: "selfupdate/bad-to",
                       label: "selfUpdate." + label + ": opts.to" };
   schema.backupTo = { rule: "required-string", code: "selfupdate/bad-backup",
                       label: "selfUpdate." + label + ": opts.backupTo" };
+  // maxBytes is a declared opt for BOTH labels: swap re-reads the from-bytes to
+  // re-hash them (closing the verify->swap window) and rollback reads backupTo to
+  // restore it. Either read must be raisable past atomicFile's 64 MiB default so a
+  // large prior binary (a Node SEA is 100+ MiB) is not refused before it starts.
+  // Optional; each body defaults to the same C.BYTES.gib(1) cap.
+  schema.maxBytes = function (value) {
+    numericBounds.requirePositiveFiniteIntIfPresent(value,
+      "selfUpdate." + label + ": opts.maxBytes", SelfUpdateError, "selfupdate/bad-max-bytes");
+  };
   validateOpts.shape(opts, schema, "selfUpdate." + label, SelfUpdateError, "selfupdate/bad-opts");
 }
 
@@ -745,12 +830,18 @@ async function _relocateFile(src, dst, fileMode) {
     atomicFile.renameWithRetry(src, dst);
     return;
   } catch (e) {
+    // The EXDEV (cross-volume) fall-through needs two filesystems and is not
+    // reachable in a single-volume test; the whole cross-device arm — the
+    // non-EXDEV re-throw guard and the copy+unlink fallback — is ignored for
+    // coverage since its else-branch can't be isolated from the guard.
+    /* c8 ignore start */
     if (!e || e.code !== "EXDEV") throw e;
     // Cross-volume: a rename can't cross the device boundary. Preserve the
     // bytes by copy, then remove the source (best-effort — a locked cross-volume
     // source is the documented limitation of this rare fallback).
     await atomicFile.copy(src, dst, { fileMode: fileMode });
     try { nodeFs.unlinkSync(src); } catch (_u) { /* cross-vol source cleanup — operator-cleanable */ }
+    /* c8 ignore stop */
   }
 }
 
@@ -765,6 +856,13 @@ async function _relocateFile(src, dst, fileMode) {
 // for `rollback_failed` couldn't tell a successful swap-with-rollback from a
 // failed both-binaries-lost scenario). SSDF RV.1.
 async function _safeRollback(backupTo, to, hadOriginal) {
+  // The active-restore path (hadOriginal === true) only runs when the install
+  // write fails AFTER a successful move-aside — a state that can't be forced
+  // through the public API without an fs-layer mock (a move-aside that succeeds
+  // guarantees the subsequent same-directory install write also succeeds). The
+  // whole body is ignored for coverage since the hadOriginal fall-through
+  // branch can't be isolated from the early return.
+  /* c8 ignore start */
   if (!hadOriginal) return null;
   try {
     await _relocateFile(backupTo, to, 0o600);
@@ -778,6 +876,7 @@ async function _safeRollback(backupTo, to, hadOriginal) {
     });
     return err;
   }
+  /* c8 ignore stop */
 }
 
 // Atomic swap of `from` -> `to` with rollback on failure. Steps:
@@ -854,6 +953,7 @@ async function swap(opts) {
   // or re-read would reopen).
   var swapAlg = opts.hashAlgo || DEFAULT_HASH_ALG;
   var fromMode;
+  /* c8 ignore next -- statSync catch is TOCTOU-defensive: existsSync(from) just passed */
   try { fromMode = (nodeFs.statSync(from).mode & 0o777); } catch (_m) { fromMode = 0o600; }
   var fromBytes;
   try {
@@ -864,6 +964,7 @@ async function swap(opts) {
   } catch (e) {
     throw new SelfUpdateError("selfupdate/swap-read-failed",
       "selfUpdate.swap: failed to read from for the integrity re-check (a symlinked source is refused): " +
+      /* c8 ignore next */
       ((e && e.message) || String(e)));
   }
   var actualHash = nodeCrypto.createHash(swapAlg).update(fromBytes).digest("hex");
@@ -892,6 +993,7 @@ async function swap(opts) {
     } catch (e) {
       throw new SelfUpdateError("selfupdate/backup-failed",
         "selfUpdate.swap: failed to move " + to + " aside to " + backupTo + ": " +
+        /* c8 ignore next */
         ((e && e.message) || String(e)));
     }
   }
@@ -909,6 +1011,9 @@ async function swap(opts) {
     await atomicFile.write(to, fromBytes, { fileMode: fromMode, overwrite: true });
   } catch (e) {
     var rbErr = await _safeRollback(backupTo, to, hadOriginal);
+    // The rollback-also-failed arm needs the install write to fail after a
+    // successful move-aside — unforceable without an fs mock (see _safeRollback).
+    /* c8 ignore start */
     if (rbErr) {
       throw new SelfUpdateError("selfupdate/swap-rollback-failed",
         "selfUpdate.swap: install of " + to + " failed AND rollback ALSO failed — " +
@@ -916,12 +1021,16 @@ async function swap(opts) {
         ". install-error=" + ((e && e.message) || String(e)) +
         "; rollback-error=" + rbErr.message);
     }
+    /* c8 ignore stop */
     throw new SelfUpdateError("selfupdate/swap-failed",
+      /* c8 ignore next */
       "selfUpdate.swap: install of " + to + " failed: " + ((e && e.message) || String(e)));
   }
   // Consume the source asset now that the verified bytes are installed
   // (best-effort — the install already succeeded; a leftover temp is
-  // operator-cleanable).
+  // operator-cleanable). The unlink-failure catch is unforceable on the
+  // supported platforms (a readable regular file is always removable here).
+  /* c8 ignore next */
   try { nodeFs.unlinkSync(from); } catch (_u) { /* tmp source leak — operator-cleanable */ }
 
   // Step 4 — fsync directories so the install is durable.
@@ -944,14 +1053,23 @@ async function swap(opts) {
  * @since     0.6.0
  * @related   b.selfUpdate.swap, b.atomicFile.copy
  *
- * Restore `backupTo` → `to` via the same atomic copy used by `swap`.
- * Operators run rollback when a post-swap healthcheck reports the new
- * binary is bad. Throws SelfUpdateError when the backup file is
- * missing or the copy fails.
+ * Restore `backupTo` → `to`. When a bad-binary `to` is present it is first MOVED
+ * ASIDE with a rename — which frees the path even for a locked, running Windows
+ * image (Windows refuses an in-place replace of a mapped executable but allows
+ * the move) — so the restore is a CREATE at the freed path, not a replace of a
+ * locked file; the quarantined bad binary is then removed (best-effort). The
+ * backup read is capped at `maxBytes` (default 1 GiB) so a large prior binary (a
+ * Node SEA is 100+ MiB) restores rather than being refused at atomicFile's 64 MiB
+ * copy default. Operators run rollback when a post-swap healthcheck reports the
+ * new binary is bad. Throws SelfUpdateError when the backup file is missing, the
+ * move-aside fails, or the copy fails; a copy failure after the move-aside
+ * restores the quarantined image back over `to` so a failed rollback never
+ * leaves the target absent.
  *
  * @opts
  *   to:       string,   // required — target path to restore
  *   backupTo: string,   // required — source backup path
+ *   maxBytes: number,   // backup read cap (default 1 GiB)
  *
  * @example
  *   try {
@@ -974,13 +1092,79 @@ async function rollback(opts) {
   }
 
   atomicFile.ensureDir(nodePath.dirname(to));
+
+  // Move the outgoing (bad) `to` ASIDE to a quarantine path via a rename before
+  // restoring — the SAME move-aside swap uses so the restore is a create at a
+  // freed path, not a replace of a possibly-locked running image (Windows refuses
+  // the in-place replace but allows the move). A move-aside failure surfaces as
+  // rollback-failed with the original `to` left intact (fail closed).
+  var quarantine  = to + ".rollback-bad";
+  // Reject a backupTo that aliases the quarantine path: the move-aside would
+  // first unlink the quarantine (deleting the known-good backup), then move the
+  // bad `to` into it, then copy those bad bytes back over `to` — corrupting the
+  // target AND destroying the backup while reporting success. Fail closed before
+  // touching either file. Compare REALPATH-resolved paths, not path.resolve():
+  // path.resolve leaves SYMLINKS unresolved, so a symlinked backupTo (or a
+  // symlinked parent dir) pointing at the quarantine would slip past. backupTo
+  // exists (checked above); the quarantine may not, so realpath its existing
+  // parent dir + append the basename to get its canonical path.
+  var realBackup     = nodeFs.realpathSync(backupTo);
+  var realQuarantine = nodePath.join(nodeFs.realpathSync(nodePath.dirname(quarantine)),
+                                     nodePath.basename(quarantine));
+  if (_pathsAlias(realBackup, realQuarantine)) {
+    throw new SelfUpdateError("selfupdate/rollback-failed",
+      "selfUpdate.rollback: backupTo resolves to the reserved quarantine path " +
+      JSON.stringify(quarantine) + " (it would be overwritten by the move-aside)");
+  }
+  var hadTarget   = nodeFs.existsSync(to);
+  if (hadTarget) {
+    try { nodeFs.unlinkSync(quarantine); } catch (_stale) { /* no stale quarantine (the common case) */ }
+    try {
+      await _relocateFile(to, quarantine, 0o600);
+    } catch (e) {
+      throw new SelfUpdateError("selfupdate/rollback-failed",
+        "selfUpdate.rollback: failed to move current " + to + " aside to " + quarantine +
+        /* c8 ignore next */
+        " before restore: " + ((e && e.message) || String(e)));
+    }
+  }
+
   try {
-    await atomicFile.copy(backupTo, to, { fileMode: 0o600 });
+    await atomicFile.copy(backupTo, to, {
+      fileMode: 0o600,
+      maxBytes: typeof opts.maxBytes === "number" ? opts.maxBytes : C.BYTES.gib(1),
+    });
   } catch (e) {
+    // The copy failed AFTER `to` was moved aside to `quarantine` (exceeds
+    // maxBytes, unreadable source, destination write error), so `to` is now
+    // absent — a failed rollback must not become a next-launch outage with no
+    // binary at all. Restore the quarantined image back over `to` (a rename,
+    // lock-safe) before surfacing the error, so an executable (the pre-rollback
+    // one) still exists — the same fail-closed restore the swap failure path does.
+    if (hadTarget) {
+      try {
+        await _relocateFile(quarantine, to, 0o600);
+      /* c8 ignore start -- restore-failure is the catastrophic both-lost case: renaming an existing quarantine back over the now-absent `to` cannot be forced through the public API without an fs-layer mock */
+      } catch (re) {
+        _safeAuditEmit("selfupdate.rollback.restore_failed", "denied", {
+          to: to, quarantine: quarantine, reason: "rollback-restore-failed",
+          message: (re && re.message) || String(re),
+        });
+      }
+      /* c8 ignore stop */
+    }
     throw new SelfUpdateError("selfupdate/rollback-failed",
       "selfUpdate.rollback: copy " + backupTo + " -> " + to + " failed: " +
+      /* c8 ignore next */
       ((e && e.message) || String(e)));
   }
+  // The known-good backup is restored; drop the quarantined bad binary
+  // (best-effort — a locked / read-only quarantine is operator-cleanable). The
+  // unlink-failure catch is unforceable on the supported platforms.
+  if (hadTarget) {
+    /* c8 ignore next */
+    try { nodeFs.unlinkSync(quarantine); } catch (_q) { /* quarantined bad binary — operator-cleanable */ }
+  }
   atomicFile.fsyncDir(nodePath.dirname(to));
 
   _safeAuditEmit("selfupdate.rollback.completed", "success", {
@@ -1175,6 +1359,7 @@ async function confirmHealthy(opts) {
     } catch (e) {
       throw new SelfUpdateError("selfupdate/probation-confirm-failed",
         "selfUpdate.confirmHealthy: failed to clear probation marker " + markerPath + ": " +
+        /* c8 ignore next */
         ((e && e.message) || String(e)));
     }
   }
@@ -1267,18 +1452,23 @@ async function evaluateOnBoot(opts) {
   try {
     var backupBytes = atomicFile.fdSafeReadSync(backupTo, { maxBytes: C.BYTES.gib(1) });
     var restoreMode;
+    /* c8 ignore next -- statSync catch is TOCTOU-defensive: `to` was just read for the hash check */
     try { restoreMode = (nodeFs.statSync(to).mode & 0o777); } catch (_sm) { restoreMode = 0o600; }
     await atomicFile.write(to, backupBytes, { fileMode: restoreMode, overwrite: true });
   } catch (e) {
     _safeAuditEmit("selfupdate.probation.rollback_failed", "denied", {
       to: to, backupTo: backupTo, markerPath: markerPath,
+      /* c8 ignore next */
       reason: "restore-failed", message: (e && e.message) || String(e),
     });
     throw new SelfUpdateError("selfupdate/probation-rollback-failed",
       "selfUpdate.evaluateOnBoot: probation rollback restore of " + to + " failed: " +
+      /* c8 ignore next */
       ((e && e.message) || String(e)));
   }
   atomicFile.fsyncDir(nodePath.dirname(to));
+  // Marker cleanup is best-effort; the unlink-failure catch is unforceable here.
+  /* c8 ignore next */
   try { nodeFs.unlinkSync(markerPath); } catch (_u) { /* marker cleanup best-effort */ }
 
   _safeAuditEmit("selfupdate.probation.rolled_back", "success", {
@@ -1311,4 +1501,5 @@ module.exports = {
   compareTags:           _compareTags,
   // Internal — exposed for the layer-0 test suite only.
   _compareTags:          _compareTags,
+  _pathsAlias:           _pathsAlias,
 };

package/lib/vendor/MANIFEST.json

@@ -18,7 +18,7 @@
       "hashes": {
         "server": "sha256:2b30a26f728c5349f4c4b47834f862a4f77393b1224fc12b22abe3ce2cfab78f"
       },
-      "refreshedAt": "2026-07-25T17:09:57.034Z"
+      "refreshedAt": "2026-07-27T03:18:03.695Z"
     },
     "@noble/curves": {
       "version": "2.2.0",
@@ -40,7 +40,7 @@
       "hashes": {
         "server": "sha256:2880c288b1285ef51d356d057bee6f0c8a00de36638cf47b47617e8c1faf10d5"
       },
-      "refreshedAt": "2026-07-25T17:09:57.034Z"
+      "refreshedAt": "2026-07-27T03:18:03.695Z"
     },
     "@noble/post-quantum": {
       "version": "0.6.1",
@@ -71,7 +71,7 @@
       "hashes": {
         "server": "sha256:f9c94094b3c10fe73dac5343289da582454ea6053494fab2bf66099d9103d6c3"
       },
-      "refreshedAt": "2026-07-25T17:09:57.034Z"
+      "refreshedAt": "2026-07-27T03:18:03.695Z"
     },
     "@simplewebauthn/server": {
       "version": "13.3.2",
@@ -94,7 +94,7 @@
       "hashes": {
         "server": "sha256:e83195dc9f189385da9c856ef38843f4466f93ea8f3d7fc2efcb1e1b18da6f20"
       },
-      "refreshedAt": "2026-07-25T17:09:57.034Z"
+      "refreshedAt": "2026-07-27T03:18:03.695Z"
     },
     "SecLists-common-passwords-top-10000": {
       "version": "10k-most-common (master)",
@@ -114,7 +114,7 @@
       },
       "runtime_artifact": "lib/vendor/common-passwords-top-10000.data.js",
       "integrity_layers": "sha256 + sha3-512 + SLH-DSA-SHAKE-256f signature + in-payload canary (where applicable)",
-      "refreshedAt": "2026-07-25T17:09:57.034Z"
+      "refreshedAt": "2026-07-27T03:18:03.695Z"
     },
     "bimi-trust-anchors": {
       "version": "operator-managed",
@@ -139,7 +139,7 @@
       },
       "runtime_artifact": "lib/vendor/bimi-trust-anchors.data.js",
       "integrity_layers": "sha256 + sha3-512 + SLH-DSA-SHAKE-256f signature + in-payload canary (where applicable)",
-      "refreshedAt": "2026-07-25T17:09:57.034Z"
+      "refreshedAt": "2026-07-27T03:18:03.695Z"
     },
     "publicsuffix-list": {
       "version": "master",
@@ -159,38 +159,35 @@
       },
       "runtime_artifact": "lib/vendor/public-suffix-list.data.js",
       "integrity_layers": "sha256 + sha3-512 + SLH-DSA-SHAKE-256f signature + in-payload canary (where applicable)",
-      "refreshedAt": "2026-07-25T17:09:57.034Z"
+      "refreshedAt": "2026-07-27T03:18:03.695Z"
     },
-    "peculiar-pki": {
-      "version": "2.0.0+pkijs-3.4.0",
-      "license": "MIT",
-      "author": "Peculiar Ventures",
-      "source": "https://github.com/PeculiarVentures",
-      "_about": "Meta-bundle of @peculiar/x509 + pkijs + reflect-metadata + every transitive ASN.1 schema package. Used by lib/mtls-engine-default.js as the pure-JS CA + PKCS#12 engine wired into b.mtlsCa.",
-      "components": {
-        "@peculiar/x509": {
-          "url": "https://github.com/PeculiarVentures/x509",
-          "version": "2.0.0"
-        },
-        "pkijs": {
-          "url": "https://github.com/PeculiarVentures/PKI.js",
-          "version": "3.4.0"
-        }
-      },
+    "@blamejs/pki": {
+      "version": "0.3.25",
+      "license": "Apache-2.0",
+      "author": "blamejs",
+      "source": "https://github.com/blamejs/pki",
       "exports": [
         "x509",
-        "pkijs",
-        "crypto"
+        "crl",
+        "pkcs12",
+        "key",
+        "webcrypto",
+        "schema",
+        "csr",
+        "cms",
+        "ocsp",
+        "tsp"
       ],
       "files": {
-        "server": "lib/vendor/pki.cjs"
+        "server": "lib/vendor/blamejs-pki.cjs"
       },
-      "bundler": "esbuild --format=cjs --platform=node --alias:reflect-metadata=reflect-metadata/lite --external:node:crypto --external:crypto",
-      "bundledAt": "2026-07-13T00:00:00Z",
+      "bundler": "esbuild --format=cjs --platform=node --external:crypto --external:node:crypto",
+      "bundledAt": "2026-07-26T00:00:00Z",
+      "cpe": "cpe:2.3:a:blamejs:pki:0.3.25:*:*:*:*:node.js:*:*",
       "hashes": {
-        "server": "sha256:2307ef65e070757ffb13442b377e45efb9fa1a10432d9b39618387720ab990ed"
+        "server": "sha256:ca475ca19f86eb9cce5ad185132b9e69fea49d1e72bae404c4845cc80727f5be"
       },
-      "refreshedAt": "2026-07-25T17:09:57.034Z"
+      "refreshedAt": "2026-07-27T03:18:03.695Z"
     }
   }
 }