@blamejs/blamejs-shop 0.4.56 → 0.4.57

package/lib/vendor/blamejs/lib/auth/sd-jwt-vc-holder.js

@@ -144,21 +144,9 @@ function create(opts) {
   var algorithm = _resolveHolderAlg(opts.holderKey, opts.algorithm);
   var auditOn = opts.auditOn !== false;
 
-  function _emitAudit(action, outcome, metadata) {
-    if (!auditOn) return;
-    try {
-      audit().safeEmit({
-        action:   action,
-        outcome:  outcome,
-        metadata: metadata || {},
-      });
-    } catch (_e) { /* drop-silent */ }
-  }
+  var _emitAudit = audit().namespaced(null, { audit: auditOn });
 
-  function _emitMetric(verb) {
-    try { observability().safeEvent("auth.sdJwtVc.holder." + verb, 1, {}); }
-    catch (_e) { /* drop-silent */ }
-  }
+  var _emitMetric = observability().namespaced("auth.sdJwtVc.holder");
 
   async function store(spec) {
     if (!spec || typeof spec !== "object") {

package/lib/vendor/blamejs/lib/auth/sd-jwt-vc-issuer.js

@@ -104,21 +104,9 @@ function create(opts) {
     keysRotated:  0,
   };
 
-  function _emitAudit(action, outcome, metadata) {
-    if (!auditOn) return;
-    try {
-      audit().safeEmit({
-        action:   action,
-        outcome:  outcome,
-        metadata: metadata || {},
-      });
-    } catch (_e) { /* drop-silent */ }
-  }
+  var _emitAudit = audit().namespaced(null, { audit: auditOn });
 
-  function _emitMetric(verb) {
-    try { observability().safeEvent("auth.sdJwtVc.issuer." + verb, 1, {}); }
-    catch (_e) { /* drop-silent */ }
-  }
+  var _emitMetric = observability().namespaced("auth.sdJwtVc.issuer");
 
   async function issue(spec) {
     if (!spec || typeof spec !== "object") {

package/lib/vendor/blamejs/lib/auth/sd-jwt-vc.js

@@ -636,7 +636,7 @@ async function verify(presentation, opts) {
     // refused with the precise alg-mismatch error rather than handed to
     // node:crypto.verify.
     jwtExternal._assertAlgKtyMatch(kbAlg, holderKey);
-    var holderKeyObj = nodeCrypto.createPublicKey({ key: holderKey, format: "jwk" });
+    var holderKeyObj = bCrypto.importPublicJwk(holderKey);
     var kbParsed = _verifyJwt(maybeKbJwt, holderKeyObj, kbAlg);
     // Constant-time compares: the nonce is a verifier-issued replay-defense
     // value, so a short-circuiting !== leaks a matching-prefix timing oracle.

package/lib/vendor/blamejs/lib/auth/status-list.js

@@ -69,13 +69,13 @@ var MAX_LIST_BYTES = C.BYTES.mib(1);
 
 function _b64url(buf) { return bCrypto.toBase64Url(buf); }
 
-function _fromB64url(s) {
-  try { return bCrypto.fromBase64Url(s); }
-  catch (_e) {
-    throw new StatusListError("status-list/bad-base64",
-      "status-list segment is not valid base64url");
-  }
-}
+// No typeMessage — a non-string input falls into the decode-failure path,
+// matching this sink's original catch-everything behavior.
+var _fromB64url = bCrypto.makeBase64UrlDecoder({
+  errorClass: StatusListError,
+  code:       "status-list/bad-base64",
+  badMessage: "status-list segment is not valid base64url",
+});
 
 function _validateBits(bits) {
   if (!SUPPORTED_BIT_SIZES[bits]) {

package/lib/vendor/blamejs/lib/auth/step-up.js

@@ -64,6 +64,7 @@ var lazyRequire      = require("../lazy-require");
 var validateOpts     = require("../validate-opts");
 var safeJson         = require("../safe-json");
 var structuredFields = require("../structured-fields");
+var codepointClass   = require("../codepoint-class");
 var C                = require("../constants");
 var { AuthError }    = require("../framework-error");
 
@@ -86,7 +87,7 @@ function _quote(value) {
   // Reject CTLs and quote-injecting characters.
   for (var i = 0; i < value.length; i += 1) {
     var code = value.charCodeAt(i);
-    if (code < 32 || code === 127) {                                    // ASCII control codepoints
+    if (codepointClass.isForbiddenControlChar(code, { forbidTab: true })) {  // ASCII control codepoints
       throw new AuthError("auth-step-up/bad-challenge",
         "challenge value contains control character at index " + i);
     }
@@ -378,22 +379,15 @@ function parseChallenge(headerValue) {
   if (rest.length === 0) return null;
   var out = { error: null, scope: null, acrValues: null, maxAge: null, raw: {} };
   // Split on commas at top level, but respect quoted strings.
-  var tokens = _splitWwwAuth(rest);
-  for (var i = 0; i < tokens.length; i += 1) {
-    var token = tokens[i].trim();
-    var eq = token.indexOf("=");
-    if (eq === -1) continue;
-    var key = token.slice(0, eq).trim().toLowerCase();
-    var val = token.slice(eq + 1).trim();
-    if (val.length >= 2 && val.charAt(0) === '"' && val.charAt(val.length - 1) === '"') {
-      val = val.slice(1, val.length - 1);
-    }
+  var kvps = structuredFields.parseKeyValuePieces(_splitWwwAuth(rest));
+  structuredFields.forEachKeyValue(kvps, function (key, val) {
+    val = structuredFields.stripDoubleQuotes(val);
     out.raw[key] = val;
     if (key === "error")              out.error     = val;
     else if (key === "scope")         out.scope     = val;
     else if (key === "acr_values")    out.acrValues = val.split(/\s+/);
     else if (key === "max_age")       out.maxAge    = parseInt(val, 10);
-  }
+  });
   return out;
 }
 

package/lib/vendor/blamejs/lib/auth-bot-challenge.js

@@ -88,13 +88,8 @@ function _requireKey(key) {
 }
 
 function _requireSessionStore(store) {
-  if (!store || typeof store !== "object" ||
-      typeof store.get !== "function" ||
-      typeof store.set !== "function" ||
-      typeof store.del !== "function") {
-    throw new AuthBotChallengeError("auth-bot-challenge/bad-opt",
-      "sessionStore must be a b.cache-shaped object (get/set/del)");
-  }
+  validateOpts.requireMethods(store, ["get", "set", "del"],
+    "sessionStore (b.cache-shaped)", AuthBotChallengeError, "auth-bot-challenge/bad-opt");
 }
 
 function _requireBotGuard(bg) {
@@ -105,14 +100,8 @@ function _requireBotGuard(bg) {
 }
 
 function _requireLockout(lk) {
-  if (!lk || typeof lk !== "object" ||
-      typeof lk.recordFailure !== "function" ||
-      typeof lk.recordSuccess !== "function" ||
-      typeof lk.check !== "function") {
-    throw new AuthBotChallengeError("auth-bot-challenge/bad-opt",
-      "lockout must be a b.auth.lockout-shaped instance " +
-      "(recordFailure/recordSuccess/check)");
-  }
+  validateOpts.requireMethods(lk, ["recordFailure", "recordSuccess", "check"],
+    "lockout (b.auth.lockout-shaped instance)", AuthBotChallengeError, "auth-bot-challenge/bad-opt");
 }
 
 function _defaultKeyExtractor(req) {
@@ -222,29 +211,9 @@ function create(opts) {
   var obsInst       = opts.observability || null;
   var clock         = opts.clock || Date.now;
 
-  function _emitObs(name, labels) {
-    var sink = obsInst || _safeGlobalObs();
-    if (!sink) return;
-    try { sink.event(name, 1, labels); } catch (_e) { /* drop-silent */ }
-  }
-
-  function _safeGlobalObs() {
-    try { return observability(); } catch (_e) { return null; }
-  }
+  var _emitObs = observability().makeCounterEmitter(obsInst);
 
-  function _emitAudit(action, key, outcome, metadata, req) {
-    if (!auditInst) return;
-    try {
-      var event = {
-        action:   action,
-        outcome:  outcome,
-        resource: { kind: "auth.bot_challenge", id: key },
-        metadata: metadata || {},
-      };
-      if (req) event.actor = requestHelpers.extractActorContext(req);
-      auditInst.safeEmit(event);
-    } catch (_e) { /* audit best-effort */ }
-  }
+  var _emitAudit = requestHelpers.makeResourceAuditEmitter(auditInst, "auth.bot_challenge");
 
   async function _readState(key) {
     try {

package/lib/vendor/blamejs/lib/backup/bundle.js

@@ -148,24 +148,17 @@ async function create(opts) {
     // earlier required-vs-skip branch above (existsSync → continue when
     // not entry.required) is honored before we reach this point; the
     // dest path is then computed from entry.relativePath, not srcPath.
-    var plain;
-    var srcFd = nodeFs.openSync(srcPath, "r");
-    try {
-      var srcStat = nodeFs.fstatSync(srcFd);
-      plain = Buffer.alloc(srcStat.size);
-      var read = 0;
-      while (read < srcStat.size) {
-        var n = nodeFs.readSync(srcFd, plain, read, srcStat.size - read, null);
-        if (n === 0) break;
-        read += n;
-      }
-      if (read !== srcStat.size) {
-        throw new BackupBundleError("backup-bundle/short-read",
-          "create: short read on '" + entry.relativePath + "': " + read + " of " + srcStat.size + " bytes");
-      }
-    } finally {
-      try { nodeFs.closeSync(srcFd); } catch (_c) { /* close best-effort */ }
-    }
+    // TOCTOU-safe read via atomic-file; the short-read message keeps the
+    // per-entry relativePath context via errorFor.
+    var plain = atomicFile.fdSafeReadSync(srcPath, {
+      errorFor: function (kind, detail) {
+        if (kind === "short-read") {
+          return new BackupBundleError("backup-bundle/short-read",
+            "create: short read on '" + entry.relativePath + "': " + detail.read + " of " + detail.size + " bytes");
+        }
+        return undefined;
+      },
+    });
     var checksum = bCrypto.checksum(plain);
     var encResult = await bCrypto.encryptWithFreshSalt(plain, passphrase);
     var encPath = _encryptedPathFor(entry.relativePath);

package/lib/vendor/blamejs/lib/backup/index.js

@@ -59,7 +59,9 @@ var backupManifest = require("./manifest");
 var lazyRequire = require("../lazy-require");
 var validateOpts = require("../validate-opts");
 var numericBounds = require("../numeric-bounds");
+var boundedMap = require("../bounded-map");
 var audit = lazyRequire(function () { return require("../audit"); });
+var auditEmit = require("../audit-emit");
 var compliance = lazyRequire(function () { return require("../compliance"); });
 // lazyRequire ../db so backup stays a leaf module operators can use
 // without the rest of the framework's DB chain loaded in the same
@@ -228,17 +230,9 @@ function diskStorage(opts) {
 // ---- Engine ----
 
 function _validateStorage(storage) {
-  if (!storage || typeof storage !== "object") {
-    throw new BackupError("backup/bad-storage",
-      "storage backend is required (use b.backup.diskStorage or pass a custom one)");
-  }
-  var required = ["writeBundle", "readBundle", "listBundles", "deleteBundle", "hasBundle"];
-  for (var i = 0; i < required.length; i++) {
-    if (typeof storage[required[i]] !== "function") {
-      throw new BackupError("backup/bad-storage",
-        "storage backend missing method '" + required[i] + "'");
-    }
-  }
+  validateOpts.requireMethods(storage,
+    ["writeBundle", "readBundle", "listBundles", "deleteBundle", "hasBundle"],
+    "storage backend", BackupError, "backup/bad-storage");
 }
 
 async function _resolveVaultKeyJson(vaultKeyJsonOpt) {
@@ -488,15 +482,7 @@ function create(opts) {
     } catch (_e) { /* db not available in this module graph — flush is a no-op */ }
   }
 
-  function _emitAudit(action, info, outcome) {
-    if (!auditOn) return;
-    audit().safeEmit({
-      action:   action,
-      outcome:  outcome,
-      metadata: info || {},
-      reason:   info && info.reason ? info.reason : null,
-    });
-  }
+  var _emitAudit = auditEmit.gatedReasonEmitter({ audit: auditOn });
 
   async function run(runOpts) {
     runOpts = runOpts || {};
@@ -1091,18 +1077,10 @@ module.exports = {
  */
 function bundleAdapterStorage(opts) {
   opts = opts || {};
-  if (!opts.adapter || typeof opts.adapter !== "object") {
-    throw new BackupError("backup/bad-adapter",
-      "bundleAdapterStorage: opts.adapter is required (an object with writeFile/readFile/listKeys/deleteKey/hasKey)");
-  }
+  validateOpts.requireMethods(opts.adapter,
+    ["writeFile", "readFile", "listKeys", "deleteKey", "hasKey"],
+    "bundleAdapterStorage: opts.adapter", BackupError, "backup/bad-adapter");
   var adapter = opts.adapter;
-  var required = ["writeFile", "readFile", "listKeys", "deleteKey", "hasKey"];
-  for (var i = 0; i < required.length; i += 1) {
-    if (typeof adapter[required[i]] !== "function") {
-      throw new BackupError("backup/bad-adapter",
-        "bundleAdapterStorage: adapter missing method '" + required[i] + "'");
-    }
-  }
   // v0.12.8 — `format: "tar"` becomes the default for new bundles.
   // `format: "directory"` opts back into the v0.12.7 file-by-file
   // layout for operators with existing bundles. The format is
@@ -1435,11 +1413,9 @@ function bundleAdapterStorage(opts) {
         if (slash <= 0) continue;
         var bid = key.slice(0, slash);
         if (!_isValidBundleId(bid)) continue;
-        var stats = byBundle.get(bid);
-        if (!stats) {
-          stats = { count: 0, hasTar: false, hasTarGz: false, hasOther: false };
-          byBundle.set(bid, stats);
-        }
+        var stats = boundedMap.getOrInsert(byBundle, bid, function () {
+          return { count: 0, hasTar: false, hasTarGz: false, hasOther: false };
+        });
         stats.count += 1;
         var rest = key.slice(slash + 1);
         if (rest === "bundle.tar")         stats.hasTar = true;
@@ -2341,17 +2317,8 @@ bundleAdapterStorage.fsAdapter = function (fsOpts) {
  *   // path composes through unwrap + read.gz + read.tar.
  */
 bundleAdapterStorage.objectStoreAdapter = function (client, osOpts) {
-  if (!client || typeof client !== "object") {
-    throw new BackupError("backup/bad-adapter",
-      "objectStoreAdapter: client is required (a b.objectStore-shaped object with put / get / head / delete / list)");
-  }
-  var required = ["put", "get", "head", "delete", "list"];
-  for (var i = 0; i < required.length; i += 1) {
-    if (typeof client[required[i]] !== "function") {
-      throw new BackupError("backup/bad-adapter",
-        "objectStoreAdapter: client missing method '" + required[i] + "'");
-    }
-  }
+  validateOpts.requireMethods(client, ["put", "get", "head", "delete", "list"],
+    "objectStoreAdapter: client", BackupError, "backup/bad-adapter");
   osOpts = osOpts || {};
   var prefix = "";
   if (osOpts.prefix !== undefined && osOpts.prefix !== null) {

package/lib/vendor/blamejs/lib/bounded-map.js

@@ -37,6 +37,7 @@
  */
 
 var numericBounds = require("./numeric-bounds");
+var validateOpts = require("./validate-opts");
 var { defineClass } = require("./framework-error");
 
 var BoundedMapError = defineClass("BoundedMapError");
@@ -99,4 +100,114 @@ function boundedMap(opts) {
   };
 }
 
-module.exports = { boundedMap: boundedMap, BoundedMapError: BoundedMapError };
+// getOrInsert(map, key, factory, opts?) — Map.prototype.getOrInsertComputed(key,
+// factory) polyfill. The native method lands in Node 26 but the framework floor
+// is 24.16, so the framework's request-keyed Maps hand-roll `var v = m.get(k);
+// if (!v) { v = ...; m.set(k, v); }` everywhere. This is the ONE place that
+// shape lives, so the floor-bump sweep swaps the body for the native method in
+// a single edit instead of N call sites. Returns the existing value; otherwise
+// computes factory(key), stores it, and returns it.
+//
+// Optional cardinality ceiling so a CAPPED caller (e.g. b.metrics' label
+// cardinality cap) composes this rather than re-rolling the get-then-set with
+// its own size guard: when `opts.maxSize` is a number and the key is absent at
+// or above that size, the value is NOT stored and `opts.onFull(key)` (or
+// undefined) is returned. Works on a plain Map or the boundedMap facade above.
+function _assertMapLike(map, fnName) {
+  validateOpts.requireMethods(map, ["has", "get", "set"],
+    fnName + ": map (Map-like)", BoundedMapError, "bounded-map/bad-map");
+}
+
+function getOrInsert(map, key, factory, opts) {
+  _assertMapLike(map, "getOrInsert");
+  if (typeof factory !== "function") {
+    throw new BoundedMapError("bounded-map/bad-factory",
+      "getOrInsert: factory must be a function, got " + (typeof factory));
+  }
+  if (map.has(key)) return map.get(key);
+  if (opts && opts.maxSize !== undefined) {
+    // A bad maxSize silently breaks the ceiling (NaN/Infinity never cap →
+    // unbounded; negative always caps → never stores) — validate via the
+    // shared numeric-bounds / validate-opts assertions, never a hand-rolled
+    // typeof check.
+    numericBounds.requirePositiveFiniteIntIfPresent(opts.maxSize,
+      "getOrInsert: opts.maxSize", BoundedMapError, "bounded-map/bad-max-size");
+    validateOpts.optionalFunction(opts.onFull,
+      "getOrInsert: opts.onFull", BoundedMapError, "bounded-map/bad-on-full");
+    if (map.size >= opts.maxSize) {
+      return opts.onFull ? opts.onFull(key) : undefined;
+    }
+  }
+  var value = factory(key);
+  map.set(key, value);
+  return value;
+}
+
+// requireAbsent / requirePresent complete the keyed-store guard family that
+// getOrInsert opened. A framework registry (topics, jobs, metrics, RoPA
+// activities, DSR tickets, …) keys a Map and guards every mutation by
+// presence: a unique INSERT throws on a duplicate key, an UPDATE/lookup throws
+// when the key is missing. That guard — `if (map.has(k)) throw <duplicate>` /
+// `if (!map.has(k)) throw <not-found>` — recurred across ~18 registries, each
+// re-rolling the check beside its own .set. Centralizing it makes the
+// uniqueness/existence check impossible to forget (the primitive IS the check)
+// while leaving the caller its own typed error and value shape.
+
+// requireAbsent(map, key, onConflict) — uniqueness guard before an insert.
+// When `key` is already present, invokes onConflict(key, existingValue)
+// (callers throw their own typed duplicate error from it) and returns its
+// result; otherwise returns undefined and the caller performs its insert.
+function requireAbsent(map, key, onConflict) {
+  _assertMapLike(map, "requireAbsent");
+  if (typeof onConflict !== "function") {
+    throw new BoundedMapError("bounded-map/bad-on-conflict",
+      "requireAbsent: onConflict must be a function, got " + (typeof onConflict));
+  }
+  if (map.has(key)) return onConflict(key, map.get(key));
+  return undefined;
+}
+
+// requirePresent(map, key, onMissing) — existence guard before an update or
+// lookup. When `key` is absent, invokes onMissing(key) (callers throw their
+// own typed not-found error) and returns its result; otherwise returns the
+// existing value, so a must-exist lookup is a single call.
+function requirePresent(map, key, onMissing) {
+  _assertMapLike(map, "requirePresent");
+  if (typeof onMissing !== "function") {
+    throw new BoundedMapError("bounded-map/bad-on-missing",
+      "requirePresent: onMissing must be a function, got " + (typeof onMissing));
+  }
+  if (!map.has(key)) return onMissing(key);
+  return map.get(key);
+}
+
+// requireAbsentMember(set, key, onConflict) — the Set sibling of requireAbsent.
+// A value-LESS membership store (a Set tracking seen keys while parsing, or
+// visited nodes during a recursive walk) rejects a re-occurrence:
+// `if (set.has(key)) throw <duplicate|cycle>` before `set.add(key)`. Unlike
+// requireAbsent (a keyed Map with values), the container has nothing to return,
+// so only `.has` is required — a Set, or any { has } membership view. When the
+// member is already present, invokes onConflict(key) (the caller throws its own
+// typed duplicate / cycle error) and returns its result; otherwise returns
+// undefined and the caller performs its `.add`.
+function requireAbsentMember(set, key, onConflict) {
+  if (!set || typeof set.has !== "function") {
+    throw new BoundedMapError("bounded-map/bad-set",
+      "requireAbsentMember: set must be a Set-like { has }");
+  }
+  if (typeof onConflict !== "function") {
+    throw new BoundedMapError("bounded-map/bad-on-conflict",
+      "requireAbsentMember: onConflict must be a function, got " + (typeof onConflict));
+  }
+  if (set.has(key)) return onConflict(key);
+  return undefined;
+}
+
+module.exports = {
+  boundedMap:          boundedMap,
+  BoundedMapError:     BoundedMapError,
+  getOrInsert:         getOrInsert,
+  requireAbsent:       requireAbsent,
+  requirePresent:      requirePresent,
+  requireAbsentMember: requireAbsentMember,
+};

package/lib/vendor/blamejs/lib/breach-deadline.js

@@ -149,21 +149,11 @@ function forStates(states, detectedAtMs) {
 // deadline registry and tracks per-state filing status.
 function createReporter(opts) {
   opts = opts || {};
-  var auditOn = opts.audit !== false;
   var now = typeof opts.now === "function" ? opts.now : function () { return Date.now(); };
   var seq = 0;
   var breaches = new Map();
 
-  function _emitAudit(action, outcome, metadata) {
-    if (!auditOn) return;
-    try {
-      audit().safeEmit({
-        action:   "breach.report." + action,
-        outcome:  outcome,
-        metadata: metadata || {},
-      });
-    } catch (_e) { /* drop-silent */ }
-  }
+  var _emitAudit = audit().namespaced("breach.report", opts.audit);
 
   function open(spec) {
     if (!spec || typeof spec !== "object") {

package/lib/vendor/blamejs/lib/cache.js

@@ -70,6 +70,7 @@
  *   LRU + TTL cache with operator-supplied namespacing, drop-silent key validation on hot-path observability, and pluggable backends that share semantics across single-process and clustered nodes.
  */
 
+var boundedMap = require("./bounded-map");
 var cacheRedis = require("./cache-redis");
 var redisClient = require("./redis-client");
 var clusterStorage = require("./cluster-storage");
@@ -179,16 +180,8 @@ function _defaultSizeOf(value) {
 }
 
 function _validateBackendObject(backend) {
-  var required = ["get", "set", "del", "clear", "size", "close"];
-  if (typeof backend !== "object" || backend === null) {
-    throw _err("BAD_OPT", "cache.create: custom backend must be an object");
-  }
-  for (var i = 0; i < required.length; i++) {
-    if (typeof backend[required[i]] !== "function") {
-      throw _err("BAD_OPT", "cache.create: custom backend missing method '" + required[i] +
-        "' (required: " + required.join(", ") + ")");
-    }
-  }
+  validateOpts.requireMethods(backend, ["get", "set", "del", "clear", "size", "close"],
+    "cache.create: custom backend", CacheError, "BAD_OPT");
 }
 
 function _validateCreateOpts(opts) {
@@ -338,8 +331,7 @@ function _memoryBackend(cfg) {
     totalBytes += bytes;
     if (tags && tags.length > 0) {
       for (var i = 0; i < tags.length; i++) {
-        var s = tagIndex.get(tags[i]);
-        if (!s) { s = new Set(); tagIndex.set(tags[i], s); }
+        var s = boundedMap.getOrInsert(tagIndex, tags[i], function () { return new Set(); });
         s.add(key);
       }
     }
@@ -1028,12 +1020,9 @@ function create(opts) {
   var operatorObs      = opts.observability || null;
   var clock            = opts.clock || function () { return Date.now(); };
   var invalidationPubsub = opts.invalidationPubsub || null;
-  if (invalidationPubsub && (
-        typeof invalidationPubsub.publish !== "function" ||
-        typeof invalidationPubsub.subscribe !== "function" ||
-        typeof invalidationPubsub.unsubscribe !== "function")) {
-    throw _err("BAD_OPT",
-      "cache.create: invalidationPubsub must implement { publish, subscribe, unsubscribe } (b.pubsub.create instance)");
+  if (invalidationPubsub) {
+    validateOpts.requireMethods(invalidationPubsub, ["publish", "subscribe", "unsubscribe"],
+      "cache.create: invalidationPubsub (b.pubsub.create instance)", CacheError, "BAD_OPT");
   }
   var invalidationChannel = "cache:" + namespace + ":invalidate";
   var invalidationToken = null;

package/lib/vendor/blamejs/lib/cbor.js

@@ -54,6 +54,7 @@
  */
 
 var C = require("./constants");
+var safeBuffer = require("./safe-buffer");
 var { defineClass } = require("./framework-error");
 
 var CborError = defineClass("CborError", { alwaysPermanent: true });
@@ -300,7 +301,7 @@ function decode(buffer, opts) {
   }
   var buf = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
   var maxBytes = _capInt(opts.maxBytes, DEFAULT_MAX_BYTES, ABSOLUTE_MAX_BYTES);
-  if (buf.length > maxBytes) {
+  if (safeBuffer.byteLengthOf(buf) > maxBytes) {
     throw new CborError("cbor/too-large",
       "cbor.decode: input " + buf.length + " bytes exceeds maxBytes " + maxBytes);
   }

package/lib/vendor/blamejs/lib/cdn-cache-control.js

@@ -336,20 +336,19 @@ function parse(headerValue) {
   if (trimmed.length === 0) return null;
 
   var out = { directives: {} };
-  var pieces = structuredFields.splitTopLevel(trimmed, ",");
-  for (var p = 0; p < pieces.length; p += 1) {
-    var raw = pieces[p].trim();
-    if (raw.length === 0) continue;
-    var eq = raw.indexOf("=");
+  var kvps = structuredFields.parseKeyValuePieces(
+    structuredFields.splitTopLevel(trimmed, ","));
+  for (var p = 0; p < kvps.length; p += 1) {
+    var kvp = kvps[p];
     var key, val, bare;
-    if (eq === -1) {
-      key = raw.toLowerCase();
+    if (kvp.value === null) {
+      key = kvp.key;
       val = "";
       bare = true;
     }
     else {
-      key = raw.slice(0, eq).trim().toLowerCase();
-      val = raw.slice(eq + 1).trim();
+      key = kvp.key;
+      val = kvp.value.trim();
       bare = false;
       // Unquote sf-string per RFC 8941 §3.3.3 (defensive — operators
       // routinely emit `s-maxage="3600"` even though the directive is

package/lib/vendor/blamejs/lib/cert.js

@@ -100,10 +100,8 @@ function _createSealedDiskStorage(opts) {
     CertError, "cert/bad-storage-root");
   var rootDir = nodePath.resolve(opts.rootDir);
   var vaultStore = opts.vault || vault().getDefaultStore();
-  if (!vaultStore || typeof vaultStore.seal !== "function" || typeof vaultStore.unseal !== "function") {
-    throw new CertError("cert/bad-storage-vault",
-      "cert.storage: vault must expose seal(buf) + unseal(buf) — typically b.vault.getDefaultStore()");
-  }
+  validateOpts.requireMethods(vaultStore, ["seal", "unseal"],
+    "cert.storage: vault (typically b.vault.getDefaultStore())", CertError, "cert/bad-storage-vault");
 
   function _ensureDir(dir) { atomicFile.ensureDir(dir); }
   function _certDir(name)  { return nodePath.join(rootDir, name); }
@@ -411,12 +409,7 @@ function create(opts) {
   var ocspTimer = null;
   var stopped = false;
 
-  function _emitAudit(action, outcome, metadata) {
-    if (!auditEnabled) return;
-    try {
-      audit().safeEmit({ action: action, outcome: outcome, metadata: metadata || {} });
-    } catch (_e) { /* drop-silent — audit emission is hot-path */ }
-  }
+  var _emitAudit = audit().namespaced(null, { audit: auditEnabled });
 
   function _bootAcme() {
     if (acmeClient) return acmeClient;