@blamejs/core 0.9.12 → 0.9.15

package/lib/metrics.js

@@ -39,9 +39,12 @@
 
 var C = require("./constants");
 var canonicalJson = require("./canonical-json");
+var nodeFs   = require("node:fs");
+var atomicFile = require("./atomic-file");
+var safeJson = require("./safe-json");
 var { defineClass } = require("./framework-error");
 var { boot } = require("./log");
-var nb = require("./numeric-bounds");
+var numericBounds = require("./numeric-bounds");
 var { resolveRoute, captureResponseStatus, HTTP_STATUS } = require("./request-helpers");
 var validateOpts = require("./validate-opts");
 
@@ -276,7 +279,7 @@ function create(opts) {
   ], "b.metrics");
   var namespace     = opts.namespace || "";
   var defaultLabels = opts.defaultLabels || {};
-  nb.requirePositiveFiniteIntIfPresent(opts.labelCardinalityCap,
+  numericBounds.requirePositiveFiniteIntIfPresent(opts.labelCardinalityCap,
     "labelCardinalityCap", MetricsError, "metrics/bad-opt");
   var cardinalityCap = opts.labelCardinalityCap || DEFAULT_CARDINALITY_CAP;
 
@@ -678,9 +681,253 @@ function _resetForTest() {
   _activeTap = null;
 }
 
+// ---- Snapshot writer/reader ----
+//
+// Out-of-process metrics export pattern for long-running daemons:
+// the daemon writes a JSON snapshot atomically every N seconds; a
+// separate CLI process reads + renders. Bypasses the HTTP-port +
+// Unix-socket coupling that the regular Prometheus exposition
+// handler requires. Useful for systemd daemons that don't want to
+// bind a stats port at all (operator runs `daemon stats` and the
+// CLI just reads the file).
+//
+// The writer is atomic — every write goes through atomic-file's
+// writeSync (temp-file + rename + fsync) so a reader that lands
+// between rename and fsync sees the previous complete snapshot
+// rather than a partially-written one.
+//
+// Surface:
+//
+//   var stop = b.metrics.snapshot.startWriter({
+//     path:       "/run/blamejs-daemon/metrics.json",
+//     intervalMs: 5000,
+//     fields:     function () { return { uptimeMs: ..., counters: {...} }; },
+//   });
+//   // ...later:
+//   stop();   // clears timer; runs one final fields() flush before returning
+//
+//   var snap = b.metrics.snapshot.read("/run/blamejs-daemon/metrics.json");
+//   process.stdout.write(b.metrics.snapshot.render(snap, { format: "text" }));
+
+/**
+ * @primitive b.metrics.snapshot.startWriter
+ * @signature b.metrics.snapshot.startWriter(opts)
+ * @since     0.9.13
+ * @status    stable
+ * @related   b.metrics.snapshot.read, b.metrics.snapshot.render
+ *
+ * Start a periodic writer that calls `opts.fields()` every
+ * `opts.intervalMs` and writes the returned object as JSON to
+ * `opts.path` atomically. Returns a `stop()` function that clears
+ * the timer + performs one final flush before resolving.
+ *
+ * @opts
+ *   path:        string,    // absolute path to write the snapshot
+ *   intervalMs:  number,    // milliseconds between flushes (>=100)
+ *   fields:      Function,  // returns an object — written as JSON
+ *
+ * @example
+ *   var stop = b.metrics.snapshot.startWriter({
+ *     path:       "/run/blamejs/metrics.json",
+ *     intervalMs: 5000,
+ *     fields:     function () {
+ *       return {
+ *         uptimeMs:    process.uptime() * 1000,
+ *         queueDepth:  myQueue.size,
+ *         lastSyncAt:  lastSyncAt,
+ *       };
+ *     },
+ *   });
+ *   // ... on SIGTERM:
+ *   stop();
+ */
+function snapshotStartWriter(opts) {
+  opts = opts || {};
+  validateOpts.requireNonEmptyString(opts.path,
+    "metrics.snapshot.startWriter: opts.path",
+    MetricsError, "metrics-snapshot/bad-path");
+  if (typeof opts.intervalMs !== "number" || !isFinite(opts.intervalMs) || opts.intervalMs < 100) {
+    throw new MetricsError("metrics-snapshot/bad-interval",
+      "metrics.snapshot.startWriter: opts.intervalMs must be a finite number >= 100, got " + opts.intervalMs);
+  }
+  if (typeof opts.fields !== "function") {
+    throw new MetricsError("metrics-snapshot/bad-fields",
+      "metrics.snapshot.startWriter: opts.fields must be a function returning the snapshot object");
+  }
+  var p          = opts.path;
+  var fieldsFn   = opts.fields;
+  var intervalMs = opts.intervalMs;
+
+  var doFlush = function () {
+    var snap;
+    try {
+      snap = fieldsFn();
+    } catch (e) {
+      log("snapshot.fields() threw: " + (e && e.message ? e.message : String(e)));
+      return;
+    }
+    if (!snap || typeof snap !== "object") {
+      log("snapshot.fields() returned non-object; skipping flush");
+      return;
+    }
+    var payload = {
+      writtenAt: new Date().toISOString(),
+      fields:    snap,
+    };
+    try {
+      atomicFile.writeSync(p, JSON.stringify(payload) + "\n", { fileMode: 0o644 });
+    } catch (e) {
+      log("snapshot.writeSync failed: " + (e && e.message ? e.message : String(e)));
+    }
+  };
+
+  // First flush is synchronous so the file exists by the time
+  // startWriter returns. Subsequent flushes run on the interval.
+  doFlush();
+  var timer = setInterval(doFlush, intervalMs);
+  if (typeof timer.unref === "function") timer.unref();
+
+  return function stop() {
+    clearInterval(timer);
+    doFlush();   // final flush captures last state before the daemon exits
+  };
+}
+
+/**
+ * @primitive b.metrics.snapshot.read
+ * @signature b.metrics.snapshot.read(path)
+ * @since     0.9.13
+ * @status    stable
+ * @related   b.metrics.snapshot.startWriter, b.metrics.snapshot.render
+ *
+ * Read + parse a snapshot file written by `startWriter`. Returns
+ * `{ writtenAt, fields }`. Throws `MetricsError` with code
+ * `metrics-snapshot/...` on missing file, parse failure, or
+ * shape mismatch.
+ *
+ * @example
+ *   var snap = b.metrics.snapshot.read("/run/blamejs/metrics.json");
+ *   console.log("uptime:", snap.fields.uptimeMs);
+ *   console.log("written at:", snap.writtenAt);
+ */
+function snapshotRead(p) {
+  validateOpts.requireNonEmptyString(p,
+    "metrics.snapshot.read: path",
+    MetricsError, "metrics-snapshot/bad-path");
+  var raw;
+  try {
+    raw = nodeFs.readFileSync(p, "utf8");
+  } catch (e) {
+    throw new MetricsError("metrics-snapshot/not-found",
+      "metrics.snapshot.read: " + p + " — " + (e && e.message ? e.message : String(e)));
+  }
+  var parsed;
+  // safeJson.parse with bounded maxBytes — the snapshot file is read
+  // by a separate CLI / sidecar process from where it's written, and a
+  // hostile actor with write access to the snapshot path could replace
+  // it with a multi-GB file that would OOM the reader. 4 MiB ceiling
+  // is well above the framework's expected snapshot size (~5-50 KiB)
+  // and the safeJson absolute cap stays within reach.
+  try {
+    parsed = safeJson.parse(raw, { maxBytes: 4 * 1024 * 1024 });   // allow:raw-byte-literal — 4 MiB snapshot-file ceiling
+  } catch (e) {
+    throw new MetricsError("metrics-snapshot/bad-json",
+      "metrics.snapshot.read: " + p + " contains invalid JSON: " + (e && e.message ? e.message : String(e)));
+  }
+  if (!parsed || typeof parsed !== "object" ||
+      typeof parsed.writtenAt !== "string" || !parsed.fields ||
+      typeof parsed.fields !== "object") {
+    throw new MetricsError("metrics-snapshot/bad-shape",
+      "metrics.snapshot.read: " + p + " is not a startWriter-produced snapshot (missing writtenAt or fields)");
+  }
+  return parsed;
+}
+
+/**
+ * @primitive b.metrics.snapshot.render
+ * @signature b.metrics.snapshot.render(snap, opts)
+ * @since     0.9.13
+ * @status    stable
+ * @related   b.metrics.snapshot.read
+ *
+ * Format a snapshot object for human or machine consumption.
+ *
+ *   format: "text"       — operator-readable lines, one field per row (default)
+ *   format: "prometheus" — Prometheus 0.0.4 text format, gauge metrics
+ *                          named with a configurable prefix; only top-level
+ *                          numeric fields under `snap.fields` are emitted
+ *
+ * @opts
+ *   format:  "text" | "prometheus",   // default: "text"
+ *   prefix:  string,                   // prometheus-only; default: "blamejs"
+ *
+ * @example
+ *   var snap = b.metrics.snapshot.read("/run/blamejs/metrics.json");
+ *   process.stdout.write(b.metrics.snapshot.render(snap));
+ *   // or for Prometheus scraping:
+ *   res.setHeader("Content-Type", "text/plain; version=0.0.4");
+ *   res.end(b.metrics.snapshot.render(snap, { format: "prometheus", prefix: "myapp" }));
+ */
+function snapshotRender(snap, opts) {
+  opts = opts || {};
+  var format = opts.format || "text";
+  if (!snap || typeof snap !== "object" || !snap.fields) {
+    throw new MetricsError("metrics-snapshot/bad-snap",
+      "metrics.snapshot.render: snap must be a startWriter-produced object (got " + typeof snap + ")");
+  }
+  var fields = snap.fields;
+  if (format === "text") {
+    var lines = ["snapshot written-at: " + snap.writtenAt];
+    // allow:bare-canonicalize-walk — sort is for stable human-readable
+    // output ordering, not canonicalize-for-hashing
+    var keys = Object.keys(fields).sort();
+    for (var i = 0; i < keys.length; i++) {
+      var k = keys[i];
+      var v = fields[k];
+      var s;
+      if (typeof v === "number") s = String(v);
+      else if (typeof v === "string") s = v;
+      else if (typeof v === "boolean") s = v ? "true" : "false";
+      else s = JSON.stringify(v);
+      lines.push("  " + k + ": " + s);
+    }
+    return lines.join("\n") + "\n";
+  }
+  if (format === "prometheus") {
+    var prefix = opts.prefix || "blamejs";
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(prefix)) {
+      throw new MetricsError("metrics-snapshot/bad-prefix",
+        "metrics.snapshot.render: prometheus prefix must match [a-zA-Z_][a-zA-Z0-9_]*, got '" + prefix + "'");
+    }
+    var out = [];
+    // allow:bare-canonicalize-walk — sort is for stable Prometheus
+    // exposition output ordering, not canonicalize-for-hashing
+    var keys2 = Object.keys(fields).sort();
+    for (var j = 0; j < keys2.length; j++) {
+      var k2 = keys2[j];
+      var v2 = fields[k2];
+      if (typeof v2 !== "number" || !isFinite(v2)) continue;   // only numeric scalars
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(k2)) continue;       // skip prom-incompatible names
+      var metric = prefix + "_" + k2;
+      out.push("# TYPE " + metric + " gauge");
+      out.push(metric + " " + v2);
+    }
+    return out.join("\n") + "\n";
+  }
+  throw new MetricsError("metrics-snapshot/bad-format",
+    "metrics.snapshot.render: format must be 'text' or 'prometheus', got '" + format + "'");
+}
+
+var snapshot = {
+  startWriter: snapshotStartWriter,
+  read:        snapshotRead,
+  render:      snapshotRender,
+};
+
 module.exports = {
   create:                    create,
   tap:                       tap,
+  snapshot:                  snapshot,
   MetricsError:              MetricsError,
   DEFAULT_HTTP_BUCKETS:      DEFAULT_HTTP_BUCKETS,
   DEFAULT_CARDINALITY_CAP:   DEFAULT_CARDINALITY_CAP,

package/lib/middleware/api-encrypt.js

@@ -96,7 +96,7 @@
  *   public/private routes can debug their wiring.
  */
 
-var crypto = require("../crypto");
+var bCrypto = require("../crypto");
 var C = require("../constants");
 var lazyRequire = require("../lazy-require");
 var nonceStoreLib = require("../nonce-store");
@@ -449,7 +449,7 @@ function create(opts) {
     res.json = function (data) {
       try {
         var ptBuf = Buffer.from(JSON.stringify(data), "utf8");
-        var ctBuf = crypto.encryptPacked(ptBuf, sessionKey);
+        var ctBuf = bCrypto.encryptPacked(ptBuf, sessionKey);
         var encrypted = { _ct: ctBuf.toString("base64") };
         if (sessionCtx) {
           encrypted._sid = sessionCtx.sid;
@@ -480,7 +480,7 @@ function create(opts) {
   function _decryptEkToSessionKey(ek) {
     for (var ki = 0; ki < keypairs.length; ki++) {
       try {
-        var sessionKeyB64 = crypto.decrypt(ek, keypairs[ki]);
+        var sessionKeyB64 = bCrypto.decrypt(ek, keypairs[ki]);
         var candidate = Buffer.from(sessionKeyB64, "base64");
         if (candidate.length === SESSION_KEY_BYTES) return candidate;
       } catch (_e) { /* try next keypair */ }
@@ -518,7 +518,7 @@ function create(opts) {
 
     if (typeof ek === "string" && typeof nonce === "string") {
       // ---- Bootstrap path (per-request mode OR first request of session) ----
-      var nonceHash = crypto.sha3Hash(nonce, "hex");
+      var nonceHash = bCrypto.sha3Hash(nonce, "hex");
       var expireAt = now + replayWindowMs;
       var freshNonce;
       try { freshNonce = await nonceStore.checkAndInsert(nonceHash, expireAt); }
@@ -655,7 +655,7 @@ function create(opts) {
     var clearObj;
     try {
       var ctBuf = Buffer.from(ct, "base64");
-      var ptBuf = crypto.decryptPacked(ctBuf, sessionKey);
+      var ptBuf = bCrypto.decryptPacked(ctBuf, sessionKey);
       clearObj = safeJson.parse(ptBuf.toString("utf8"), { maxBytes: maxDecryptedBytes });
     } catch (_e) {
       _emitFailure(req, "tag");
@@ -751,7 +751,7 @@ function client(opts) {
   var perSessionLastResCtr = 0;
 
   function _resetSession() {
-    perSessionKey = crypto.generateBytes(SESSION_KEY_BYTES);
+    perSessionKey = bCrypto.generateBytes(SESSION_KEY_BYTES);
     perSessionSid = _generateUuidV4();
     perSessionReqCtr = 0;
     perSessionLastResCtr = 0;
@@ -774,7 +774,7 @@ function client(opts) {
     }
     perSessionLastResCtr = responseBody._ctr;
     var resCtBuf = Buffer.from(responseBody._ct, "base64");
-    var resPtBuf = crypto.decryptPacked(resCtBuf, perSessionKey);
+    var resPtBuf = bCrypto.decryptPacked(resCtBuf, perSessionKey);
     return safeJson.parse(resPtBuf.toString("utf8"), { maxBytes: maxDecryptedBytes });
   }
 
@@ -783,13 +783,13 @@ function client(opts) {
     if (!perSessionKey) _resetSession();
     var ts = Date.now();
     var ptBuf = Buffer.from(JSON.stringify(payload), "utf8");
-    var ctBuf = crypto.encryptPacked(ptBuf, perSessionKey);
+    var ctBuf = bCrypto.encryptPacked(ptBuf, perSessionKey);
     perSessionReqCtr += 1;
     var body;
     if (perSessionReqCtr === 1) {
       // Bootstrap envelope — full _ek + _nonce; server stores sid → sessionKey.
-      var ek = crypto.encrypt(perSessionKey.toString("base64"), pubkey);
-      var nonce = crypto.generateBytes(REQUEST_NONCE_BYTES).toString("hex");
+      var ek = bCrypto.encrypt(perSessionKey.toString("base64"), pubkey);
+      var nonce = bCrypto.generateBytes(REQUEST_NONCE_BYTES).toString("hex");
       body = {
         _ek:    ek,
         _ct:    ctBuf.toString("base64"),
@@ -812,11 +812,11 @@ function client(opts) {
 
   function _encryptPerRequest(payload) {
     if (payload === undefined) payload = null;
-    var sessionKey = crypto.generateBytes(SESSION_KEY_BYTES);
-    var ek = crypto.encrypt(sessionKey.toString("base64"), pubkey);
+    var sessionKey = bCrypto.generateBytes(SESSION_KEY_BYTES);
+    var ek = bCrypto.encrypt(sessionKey.toString("base64"), pubkey);
     var ptBuf = Buffer.from(JSON.stringify(payload), "utf8");
-    var ctBuf = crypto.encryptPacked(ptBuf, sessionKey);
-    var requestNonce = crypto.generateBytes(REQUEST_NONCE_BYTES).toString("hex");
+    var ctBuf = bCrypto.encryptPacked(ptBuf, sessionKey);
+    var requestNonce = bCrypto.generateBytes(REQUEST_NONCE_BYTES).toString("hex");
     var ts = Date.now();
     return {
       body: {
@@ -832,7 +832,7 @@ function client(opts) {
             "apiEncrypt.client: response missing _ct field");
         }
         var resCtBuf = Buffer.from(responseBody._ct, "base64");
-        var resPtBuf = crypto.decryptPacked(resCtBuf, sessionKey);
+        var resPtBuf = bCrypto.decryptPacked(resCtBuf, sessionKey);
         return safeJson.parse(resPtBuf.toString("utf8"), { maxBytes: maxDecryptedBytes });
       },
     };
@@ -857,7 +857,7 @@ function client(opts) {
 // Slice offsets are RFC 4122 UUID hex-byte boundaries (`xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx`)
 // — protocol-fixed values, not byte sizes. allow:raw-byte-literal
 function _generateUuidV4() {
-  var b = crypto.generateBytes(16);                     // allow:raw-byte-literal — UUID is exactly 16 bytes
+  var b = bCrypto.generateBytes(16);                     // allow:raw-byte-literal — UUID is exactly 16 bytes
   // Set version (4) and variant (10x) bits per RFC 4122.
   b[6] = (b[6] & 0x0f) | 0x40;
   b[8] = (b[8] & 0x3f) | 0x80;

package/lib/middleware/body-parser.js

@@ -100,7 +100,7 @@
  *     dots collapsed, control characters stripped, length capped at 255.
  *     Tmp file path is generated by the framework, never derived from
  *     the operator-supplied filename — so a malicious filename can't
- *     collide with a sensitive path.
+ *     collide with a sensitive nodePath.
  *   - Multipart parser refuses fields whose `name` is in POISONED_KEYS
  *     (consistent with the JSON path).
  *   - Tmp files set with mode 0o600, parent dir created with 0o700.
@@ -108,12 +108,12 @@
  *     error) so a crashing handler doesn't leak files.
  */
 
-var fs = require("fs");
+var nodeFs = require("fs");
 var os = require("os");
-var path = require("path");
+var nodePath = require("path");
 var nodeCrypto = require("node:crypto");
 var atomicFile      = require("../atomic-file");
-var crypto          = require("../crypto");
+var bCrypto         = require("../crypto");
 var lazyRequire     = require("../lazy-require");
 var requestHelpers  = require("../request-helpers");
 var safeBuffer      = require("../safe-buffer");
@@ -682,7 +682,7 @@ async function _parseMultipart(req, opts, ctParams) {
   }
   // Resolve tmpDir per-request so directory-creation failure surfaces as a
   // structured error rather than a deferred fs throw.
-  var tmpDir = opts.tmpDir || path.join(os.tmpdir(), "blamejs-uploads");
+  var tmpDir = opts.tmpDir || nodePath.join(os.tmpdir(), "blamejs-uploads");
   try { atomicFile.ensureDir(tmpDir, 0o700); }
   catch (e) {
     throw new BodyParserError(
@@ -733,7 +733,7 @@ async function _parseMultipart(req, opts, ctParams) {
     currentFilename = null;
     currentMime = null;
     currentTmpPath = null;
-    if (currentFd !== null) { try { fs.closeSync(currentFd); } catch (_e) { /* fd already closed */ } currentFd = null; }
+    if (currentFd !== null) { try { nodeFs.closeSync(currentFd); } catch (_e) { /* fd already closed */ } currentFd = null; }
     currentSize = 0;
     currentHash = null;
     currentBuf = null;
@@ -762,10 +762,10 @@ async function _parseMultipart(req, opts, ctParams) {
   }
 
   function _cleanup() {
-    if (currentFd !== null) { try { fs.closeSync(currentFd); } catch (_e) { /* fd already closed */ } currentFd = null; }
-    if (currentTmpPath) { try { fs.unlinkSync(currentTmpPath); } catch (_e) { /* tmp file already removed */ } }
+    if (currentFd !== null) { try { nodeFs.closeSync(currentFd); } catch (_e) { /* fd already closed */ } currentFd = null; }
+    if (currentTmpPath) { try { nodeFs.unlinkSync(currentTmpPath); } catch (_e) { /* tmp file already removed */ } }
     for (var i = 0; i < files.length; i++) {
-      try { fs.unlinkSync(files[i].path); } catch (_e) { /* tmp file already removed */ }
+      try { nodeFs.unlinkSync(files[i].path); } catch (_e) { /* tmp file already removed */ }
     }
   }
 
@@ -945,10 +945,10 @@ async function _parseMultipart(req, opts, ctParams) {
 
               // Generate the tmp path — never derived from the
               // operator-supplied filename.
-              var unique = crypto.generateToken(C.BYTES.bytes(16));
-              currentTmpPath = path.join(tmpDir, "blamejs-up-" + unique);
+              var unique = bCrypto.generateToken(C.BYTES.bytes(16));
+              currentTmpPath = nodePath.join(tmpDir, "blamejs-up-" + unique);
               try {
-                currentFd = fs.openSync(currentTmpPath, "wx", 0o600);
+                currentFd = nodeFs.openSync(currentTmpPath, "wx", 0o600);
               } catch (e) {
                 done(new BodyParserError("body-parser/multipart-tmp-open",
                   "could not open multipart tmp file: " + ((e && e.message) || String(e)),
@@ -1027,7 +1027,7 @@ async function _parseMultipart(req, opts, ctParams) {
                 try {
                   var written = 0;
                   while (written < bodyChunk.length) {
-                    written += fs.writeSync(currentFd, bodyChunk, written, bodyChunk.length - written);
+                    written += nodeFs.writeSync(currentFd, bodyChunk, written, bodyChunk.length - written);
                   }
                 } catch (e) {
                   done(new BodyParserError("body-parser/multipart-tmp-write",
@@ -1068,7 +1068,7 @@ async function _parseMultipart(req, opts, ctParams) {
               // fileFilter rejected — already recorded in filesRejected; no
               // tmp file was opened, nothing to clean up here.
             } else if (currentFd !== null) {
-              try { fs.closeSync(currentFd); } catch (_e) { /* fd already closed */ }
+              try { nodeFs.closeSync(currentFd); } catch (_e) { /* fd already closed */ }
               currentFd = null;
               files.push({
                 field:    currentField,
@@ -1247,7 +1247,7 @@ function create(opts) {
           if (cleanedUp) return;
           cleanedUp = true;
           for (var i = 0; i < mpResult.files.length; i++) {
-            try { fs.unlinkSync(mpResult.files[i].path); } catch (_e) { /* tmp file already removed */ }
+            try { nodeFs.unlinkSync(mpResult.files[i].path); } catch (_e) { /* tmp file already removed */ }
           }
         }
         res.on("finish", cleanup);
@@ -1500,7 +1500,7 @@ module.exports = {
   BodyParserError:  BodyParserError,
   // Standalone async helpers — surfaced via b.parsers.{json,multipart}.
   // The middleware composes these so the request-handling pipeline and
-  // the operator-callable surface share one parsing path.
+  // the operator-callable surface share one parsing nodePath.
   parseJson:        parseJsonStandalone,
   parseMultipart:   parseMultipartStandalone,
   // Internal helpers exposed for tests + the csrf-protect refactor.

package/lib/middleware/compression.js

@@ -90,7 +90,7 @@
 
 var zlib = require("node:zlib");
 var C = require("../constants");
-var nb = require("../numeric-bounds");
+var numericBounds = require("../numeric-bounds");
 var requestHelpers = require("../request-helpers");
 var validateOpts = require("../validate-opts");
 var { defineClass } = require("../framework-error");
@@ -271,12 +271,12 @@ function create(opts) {
   var threshold;
   if (opts.threshold === undefined) {
     threshold = DEFAULT_OPTS.threshold;
-  } else if (nb.isNonNegativeFiniteInt(opts.threshold)) {
+  } else if (numericBounds.isNonNegativeFiniteInt(opts.threshold)) {
     threshold = opts.threshold;
   } else {
     throw new CompressionError("compression/bad-opt",
       "middleware.compression: threshold must be a non-negative finite integer; got " +
-        nb.shape(opts.threshold));
+        numericBounds.shape(opts.threshold));
   }
   var encodings     = Array.isArray(opts.encodings) && opts.encodings.length > 0
                         ? opts.encodings.slice() : DEFAULT_OPTS.encodings.slice();

package/lib/middleware/csp-nonce.js

@@ -113,7 +113,7 @@
  */
 
 var C = require("../constants");
-var crypto = require("../crypto");
+var bCrypto = require("../crypto");
 var numericBounds = require("../numeric-bounds");
 var validateOpts = require("../validate-opts");
 var { defineClass } = require("../framework-error");
@@ -283,7 +283,7 @@ function create(opts) {
   // Pre-fix the typeof-only check accepted Infinity / NaN — both
   // bypassed the `< MIN_NONCE_BYTES` guard (NaN < N is always false,
   // Infinity < N is always false), then crashed per-request when
-  // `crypto.generateBytes(Infinity)` hit ERR_OUT_OF_RANGE. Route through
+  // `bCrypto.generateBytes(Infinity)` hit ERR_OUT_OF_RANGE. Route through
   // shared numeric-bounds (positive finite int) before the lower-bound
   // check so the typo / coercion is caught at create() time.
   if (!numericBounds.isPositiveFiniteInt(nonceBytes)) {
@@ -322,7 +322,7 @@ function create(opts) {
   if (opts.placeholder === undefined) {
     // OS-RNG → SHAKE256 → hex via the framework random helper.
     placeholder = PLACEHOLDER_PREFIX +
-                  crypto.generateToken(PLACEHOLDER_RAND_BYTES) +
+                  bCrypto.generateToken(PLACEHOLDER_RAND_BYTES) +
                   PLACEHOLDER_SUFFIX;
   } else if (typeof opts.placeholder !== "string" || opts.placeholder.length === 0) {
     throw new CspNonceError("csp-nonce/bad-placeholder",
@@ -336,7 +336,7 @@ function create(opts) {
     // Generate the nonce. Cheap (16 bytes from getrandom → SHAKE256 →
     // base64 encode); do it always for consistency unless `always:
     // false` was set explicitly.
-    var nonce = crypto.generateBytes(nonceBytes).toString("base64");
+    var nonce = bCrypto.generateBytes(nonceBytes).toString("base64");
 
     // Attach to req for handler access.
     req[property] = nonce;

package/lib/middleware/health.js

@@ -100,7 +100,7 @@
  */
 
 var C = require("../constants");
-var nb = require("../numeric-bounds");
+var numericBounds = require("../numeric-bounds");
 var requestHelpers = require("../request-helpers");
 var safeAsync = require("../safe-async");
 var validateOpts = require("../validate-opts");
@@ -179,22 +179,22 @@ function create(opts) {
   var defaultTimeoutMs;
   if (opts.defaultTimeoutMs === undefined) {
     defaultTimeoutMs = DEFAULT_TIMEOUT_MS;
-  } else if (nb.isPositiveFiniteInt(opts.defaultTimeoutMs)) {
+  } else if (numericBounds.isPositiveFiniteInt(opts.defaultTimeoutMs)) {
     defaultTimeoutMs = opts.defaultTimeoutMs;
   } else {
     throw new HealthError("health/bad-opt",
       "defaultTimeoutMs must be a positive finite integer; got " +
-        nb.shape(opts.defaultTimeoutMs));
+        numericBounds.shape(opts.defaultTimeoutMs));
   }
   var cacheMs;
   if (opts.cacheMs === undefined) {
     cacheMs = 0;
-  } else if (nb.isNonNegativeFiniteInt(opts.cacheMs)) {
+  } else if (numericBounds.isNonNegativeFiniteInt(opts.cacheMs)) {
     cacheMs = opts.cacheMs;
   } else {
     throw new HealthError("health/bad-opt",
       "cacheMs must be a non-negative finite integer; got " +
-        nb.shape(opts.cacheMs));
+        numericBounds.shape(opts.cacheMs));
   }
   var includeMeta = opts.includeMeta !== false;
   var version = opts.version || null;
@@ -237,12 +237,12 @@ function create(opts) {
     var timeoutMs;
     if (copts.timeoutMs === undefined) {
       timeoutMs = defaultTimeoutMs;
-    } else if (nb.isPositiveFiniteInt(copts.timeoutMs)) {
+    } else if (numericBounds.isPositiveFiniteInt(copts.timeoutMs)) {
       timeoutMs = copts.timeoutMs;
     } else {
       throw new HealthError("health/bad-opt",
         "registerCheck: timeoutMs must be a positive finite integer; got " +
-          nb.shape(copts.timeoutMs));
+          numericBounds.shape(copts.timeoutMs));
     }
     checks.push({
       name:      name,